首页 > 其他分享 >Kotlin—String的常用方法

Kotlin—String的常用方法

时间：2023-02-11 11:15:01浏览次数：52  
标签：常用 String val Kotlin println str 字符串 函数

 

 

Kotlin—String的常用方法

2021-03-26 21:48:46  1051   0  

参考目录 [show]

阅读完需：约 17 分钟

Kotlin的String类中有非常多的方法，下面列举一些经常用到的方法，首先定义一个字符串变量，后面都以这个变量来验证String相关的方法。

//定义字符串
val str = "123456789"

1. 字符串截取

字符串截取操作可以使用substring、dropXXX系列和takeXXX系列方法

drop(n: Int): String

去掉前n个字符，返回其余的字符串，等同于substring(n)

//删掉前3个字符
println(str.drop(3))
//输出结果：456789

dropLast(n: Int): String

去掉后n个字符，返回其余的字符串，等同于substring(0, str.length – n)

//删掉后4个字符
println(str.dropLast(4))
//输出结果：12345

dropWhile(predicate: (Char) -> Boolean): String

根据条件从前往后逐一去掉字符，直到不满足条件时则返回后面的字符串，该方法参数是一个lambda表达式，下面举几个例子

//删掉字符串前面等于1或2的字符
val str = "123456789"
println(str.dropWhile {
    it == '1' || it == '2'
})
//输出结果：3456789

val str = "12111223456789"
println(str.dropWhile {
    it == '1' || it == '2'
})
//输出结果：3456789

val str = "13456781219232"
println(str.dropWhile {
    it == '1' || it == '2'
})
//输出结果：3456781219232
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
  12. 12
  13. 13
  14. 14
  15. 15
  16. 16
  17. 17
  18. 18

dropLastWhile(predicate: (Char) -> Boolean): String

和dropWhile相反，dropLastWhile是从后面开始根据条件去掉字符串

val str = "13456781219232"
println(str.dropLastWhile {
    it == '1' || it == '2'
})
//输出结果：1345678121923
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5

take(n: Int): String

获取前n个字符，如果n大于字符串的长度则会返回整个字符串

//获取前4个字符
println(str.take(4))
//输出结果：1234

//获取前20个字符
println(str.take(20))
//输出结果：123456789
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7

takeLast(n: Int): CharSequence

和take方法对应，takeLast则是从后开始获取n个字符

//获取后3个字符，输出：789
println(str.takeLast(3))

takeWhile(predicate: (Char) -> Boolean): String

这个方法会从前往后一直返回满足条件的字符，直到不满足条件为止

//获取以6开头的所有字符
println(str.takeWhile {
	it == '6'
})
//输出结果为空

//获取以1或2开头的所有字符
println(str.takeWhile {
	it == '1' || it == '2'
})
//输出结果为空：12
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11

takeLastWhile(predicate: (Char) -> Boolean): String

这个方法和takeWhile对应,从后往前匹配，返回符合条件的数据

takeIf(predicate: (T) -> Boolean): T?

这个方法会根据lambda参数条件判断，满足条件返回自身，否则返回null。参数对象是一个泛型，不仅适合String类型，其他任何类型都可以。

//判断字符串的长度是否大于5
println(str.takeIf {
	it.length > 5
})
//输入结果：123456789
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5

first() / first(predicate: (Char) -> Boolean): Char

返回字符串的第一个元素，或者可以传入一个过滤条件，返回满足条件的第一个元素

println(str.first()) //输出：1
println(str.first {it == '5'}) //输出：5
println(str.first {it == 'a'}) 
//输出：
Exception in thread "main" java.util.NoSuchElementException: Char sequence contains no character matching the predicate.
	at com.example.demoapp.DemoCheckKt.main(DemoCheck.kt:19)
	at com.example.demoapp.DemoCheckKt.main(DemoCheck.kt)
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7

firstOrNull() / firstOrNull(predicate: (Char) -> Boolean): Char

和上面的方法一样，返回字符串的第一个元素，或者可以传入一个过滤条件，返回满足条件的第一个元素，但是不一样的地方在于，上面的方法如果没有匹配的结果则会抛出NoSuchElementException异常，而firstOrNull则不会抛出异常，会直接返回null。

与first()和firstOrNull()相对应的方法，last()、lastOrNull()则是获取最后一个满足条件的元素。还有find(predicate: (Char) -> Boolean): Char?方法也是根据条件查找元素，就不再赘述了。

2. 空格处理

trim

//去掉开头的空格
println(" 123  456 ".trimStart())

//去掉结尾的空格
println(" 123  456 ".trimEnd())

//去掉两端的空格
println(" 123  456 ".trim())

//过滤字符:去掉所有空格,输出：12345678
println("123 456  7   8".filter { !it.isWhitespace() })
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11

3.反转字符串

reversed

//反转字符串，输出：987654321
println(str.reversed())

4. 字符串查找

获取第一个元素

主要包含first() | firstOrNull()和first{} | firstOrNull{}四个函数

first() | firstOrNull()

  • 作用 ：查找字符串的第一个元素
  • 区别 ：若字符串为空串时，前者会抛出NoSuchElementException异常 ，后者会返回null

例：

val str = "kotlin very good"
str.first()   <=>   str[0]   <=>   str.get(0)

其还实现了查找等于某一个字符的第一个元素,即first{}高阶函数

val str = "kotlin very good"
// 如果未查找到满足条件的元素，会抛出NoSuchElementException异常
str.first{ it == 'o' }

还有一个firstOrNull()函数，它和first()函数的区别在于如果字符串为空串时，first()函数会抛出异常，而firstOrNull()函数会返回null。当然还有firstOrNull{}函数，它和first{}函数的区别在于如果字符串为空串时，first{}函数会抛出异常，而firstOrNull{}函数会返回null

获取最后一个元素

val str = ...
str.last()   <==>   str.get(lastIndex)   <==>  str[lastIndex]
其中 lastIndex 是一个拓展属性，其实现是 length - 1

同时还实现了查找等于某一个字符的最后一个元素,即last{}高阶函数

val str = "kotlin very good"
// 如果未查找到满足条件的元素，会抛出NoSuchElementException异常
str.last{ it == 'o' }   // 其实从源码中我们发现其是对原字符串反转之后再进行遍历查找满足条件的元素。

lastOrNull()同firstOrNUll()一样。lastOrNull{}同firstOrNUll{}一样。

查找元素

其实查找元素提供了两个高阶函数find{}、findLast{}。不过他们都是对firstOrNull()或lastOrNull()函数进行处理。这里不多作累述。

查找对应元素的下标

这里提供查找对应元素下标的几个函数：

  • indexOf() : 查找某一个元素或字符串在原字符串中第一次出现的下标。
  • indexLastOf() : 查找某一个元素或字符串在原字符串中最后一次出现的下标。
  • indexOfFirst{} : 同indexOf()
  • indexOfLast{} : 同indexLastOf()

例：

println(str.indexOfFirst { it == 'o' })
println(str.indexOfLast { it == 'o' })
println(str.indexOf('o',0))
println(str.indexOf("very",0))
println(str.lastIndexOf('o'))
println(str.lastIndexOf("good"))
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5

输出结果为：

1
14
1
7
14
12
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5

5. 字符串替换

Kotlin除了实现Java中的replace()ha函数外，还提供了另外的replaceFirst()、replaceAfter()、replaceBefore()、replaceIndent()、等函数。下面会对这些函数意义进行实例讲解。

replace()函数

replace()函数提供了4个重载函数。他们能实现不同的功能

replace(oldChar,newChar,ignoreCase = false)

其中：

  • 作用 ： 把原字符串中的某一个字符全部替换成新的字符。然后返回新的字符串
  • 参数说明：
  1. oldChar: 需要替换的字符
  2. newChar: 新的字符
  3. ignoreCase : 是否引用Java中的replace()函数。默认值为false，即用Java的replace()函数
// 把字符`a`全部替换为`A`
val str = "Kotlin is a very good programming language"
println(str.replace('a','A'))

输出结果为：

Kotlin is A very good progrAmming lAnguAge

replace(oldValue,newValue,ignoreCase = false)

其中：

  • 作用 ： 把原字符串中的某一个字符全部替换成新的字符。然后返回新的字符串
  • 参数说明：
  1. oldValue: 需要替换的字符串
  2. newValue: 新的字符串
  3. ignoreCase : 是否引用Java中的replace()函数。默认值为false，即用Java的replace()函数

例：

// 把字符串`Kotlin`替换成字符串`Java`
val str = "Kotlin is a very good programming language"
println(str.replace("Kotlin","Java"))

输出结果为：

Java is a very good programming language

replace(regex,replacement)

其中：

  • 作用 ： 根据定义的正则规则去匹配源字符串，把满足规则的字符串替换成新的字符串。
  • 参数说明：
  1. regex: 正则表达式
  2. replacement: 新的字符串

例：

// 正则的规则为检测数字，如果为数字则替换成字符串`kotlin`val str = "1234a kotlin 5678 3 is 4"println(str.replace(Regex("[0-9]+"),"kotlin"))

输出结果为：

kotlina kotlin kotlin kotlin is kotlin

replace(regex: Regex, noinline transform: (MatchResult) -> CharSequence)

其中：

  • 作用 ： 根据定义的正则规则去匹配源字符串，把满足规则的字符串通过transform{}高阶函数映射的新字符串替换。
  • 参数说明：
  1. regex: 正则表达式
  2. transform: 高阶函数

例：

val str = "1234a kotlin 5678 3 is 4"
val newStr = str.replace(Regex("[0-9]+"),{
    "abcd "
})

输出结果为：

abcd abcd abcd abcd a kotlin abcd abcd abcd abcd  abcd  is abcd

可以从上述的两个函数中看到两个函数的区别。关于高阶函数、正则表达式的知识点可以先自行看资料理解。小生会在后续的章节中补上相关的内容…

经过上面的replace()函数的讲解。并且对几个重载函数进行了分析。相信大家对replace()函数中的参数都有大致的了解。并且下面的几个函数也是大致相同的操作。故而下面的几个函数操作，只会举例说明其作用。

replaceFirst()函数

作用：把满足条件的第一个字符或字符串替换成新的字符或字符串

例：

val str = "Kotlin is a very good programming language"println(str.replaceFirst('a','A'))
println(str.replaceFirst( "Kotlin","Java"))

输出结果为：

Kotlin is A very good programming language
Java is a very good programming language

replaceBefore()函数

作用：截取满足条件的第一个字符或字符串后面的字符串，包含满足条件字符或字符串自身，并在其前面加上新的字符串。

例：

val str = "Kotlin is a very good programming language"println(str.replaceBefore('a',"AA"))
println(str.replaceBefore("Kotlin","Java"))

输出结果为：

AAa very good programming language
JavaKotlin is a very good programming language

replaceBeforeLast()函数

作用：截取满足条件的最后一个字符或字符串后面的字符串，包含满足条件字符或字符串自身，并在其前面加上新的字符串。

例：

val str = "Kotlin is a very good programming language"println(str.replaceBeforeLast('a',"AA"))
println(str.replaceBeforeLast("Kotlin","Java"))

输出结果为：

AAage
JavaKotlin is a very good programming language

replaceAfter()函数

作用：截取满足条件的第一个字符或字符串前面的字符串，包含满足条件字符或字符串自身，并在其后面加上新的字符串。

例：

val str = "Kotlin is a very good programming language"println(str.replaceAfter('a',"AA"))
println(str.replaceAfter("Kotlin","Java"))

输出结果为：

Kotlin is aAA
KotlinJava

replaceAfterLast()函数

作用：截取满足条件的最后一个字符或字符串前面的字符串，包含满足条件字符或字符串自身，并在其后面加上新的字符串。

例：

val str = "Kotlin is a very good programming language"println(str.replaceAfterLast('a',"AA"))
println(str.replaceAfterLast("Kotlin","Java"))

输出结果为：

Kotlin is a very good programming languaAA
KotlinJava

6. 字符串分割

Kotlin除了实现Java中的split()函数之外，还提供了splitToSequence()函数来分割字符串。分割成功后都会返回一个字符串集合用于我们后续操作。

split()函数

split()函数也是提供了4个重载函数。其中，用正则表达式为条件分割占用两个。用字符分割占用一个。用字符串分割占用一个。

使用正则表达式分割

在Kotlin中使用正则表达式，使用的是Regex类，而Java中使用正则表达式使用的Pattern类。这里分别举例说明

例：

var str2 = "1 kotlin 2 java 3 Lua 4 JavaScript"
 
val list3 = str2.split(Regex("[0-9]+"))
for (str in list3){
    print("$str \t")
}
 
println()
 
val list4 = str2.split(Pattern.compile("[0-9]+"))
for (str in list4){
    print("$str \t")
}
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
  12. 12

输出结果为：

kotlin  java  Lua  JavaScript 	
kotlin  java  Lua  JavaScript

使用字符或字符串分割

在实际的项目开发中，还是这种方式用的要多一些。不过这里值得注意的是，不管是用字符分割，还是字符串分割，其都是一个可变参数。即其参数的个数不定。

例：

val str1 = "Kotlin is a very good programming language"
 
val list1 = str1.split(' ')
for (str in list1){
    print("$str \t")
}
 
println()
 
val list2 = str1.split(" ")
for (str in list2){
    print("$str \t")
}
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
  12. 12

输出结果为：

Kotlin   is   a   very 	good 	programming 	language
Kotlin   is   a   very 	good 	programming 	language

这里举例一个可变参数情况的例子：

val str3 = "a b c d e f g h 2+3+4+5"
val list5 = str3.split(' ','+')
for (str in list5){
    print("$str \t")
}
  1. 1
  2. 2
  3. 3
  4. 4

输出结果为：

a 	b 	c 	d 	e 	f 	g 	h 	2 	3 	4 	5

splitToSequence()函数

此函数同样可以用字符串或字符去分割，其用法和上述的split()函数一样

7. 获取字符串长度

在Kotlin中用两种获取字符串长度的方法。其实也是一种而已

  1. 直接用length属性获取长度
  2. 用count()函数获取，其实count()函数的做法也是返回了length长度。

实例：

val str = "kotlin very good"
 
// 1. 直接用length属性获取
println("str.length => ${str.length}")
 
// 2. 用count()函数获取
println("str.count() => ${str.count()}")
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6

输出结果为：

str.length => 16
str.count() => 16

这里我们看一看count()函数的源码

/**
 * Returns the length of this char sequence.
 * 其实也就是返回了length属性...
 */
@kotlin.internal.InlineOnly
public inline fun CharSequence.count(): Int {
    return length
}
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7

8. 统计重复字符

上面讲到了count()函数，是返回了length属性获取字符串的长度。其实源码中还提供了一个叫count{}的高阶函数，用于统计字符串中重复某个字符的个数。

看一看他的源码

public inline fun CharSequence.count(predicate: (Char) -> Boolean): Int {
    var count = 0
    for (element in this) if (predicate(element)) count++
    return count
}
  1. 1
  2. 2
  3. 3
  4. 4

源码解释：该函数接受一个Boolean类型的Lambda表达式。然后循环这个字符串，如果我的条件成立，则变量count自增。循环完成之后返回重复的个数count

实例：

val str = "kotlin very good"
val count = str.count { it == 'o' }
println("count : $count")

输出结果为：

count : 3

9. 验证字符串

在实际的开发中，特别是Android开发中，会经常遇到验证输入框的内容是否为空串的时候。在Kotlin中，和Java一样提供了几个处理这种情况的函数。

下列几个函数都是处理字符串为空串或为空的：

  • isEmpty() : 其源码是判断其length是等于0，若等于0则返回true,反之返回false。不能直接用于可空的字符串
  • isNotEmpty() : 其源码是判断其length是否大于0，若大于0则返回true,反之返回false。不能直接用于可空的字符串
  • isNullOrEmpty() : 其源码是判断该字符串是否为null或者其length是否等于0。
  • isBlank() : 其源码是判断其length是否等于0,或者判断其包含的空格数是否等于当前的length。不能直接用于可空的字符串
  • isNotBlank() : 其源码是对isBlank()函数取反。不能直接用于可空的字符串
  • isNotOrBlank() : 其源码判断该字符串是否为null。或者调用isBlank()函数

实例：

val str : String? = "kotlin"
 
// 可以看出当str为可空变量的时候，isNullOrEmpty()和isNotOrBlank()可以不做直接调用而不做任何处理
，而其他的函数则不行
println(str?.isEmpty())
println(str?.isNotEmpty())
println(str.isNullOrEmpty())
println(str?.isBlank())
println(str?.isNotBlank())
println(str.isNullOrBlank())
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9

输出结果为：

false
true
false
false
true
false
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5

10. 字符串连接

字符串链接，在Java中只能使用+来链接，当然除了StringBuilder、StringBuffer除外。而在Kotlin中除了使用+以外，还可以使用plus()函数。其接受任意类型。plus()函数是一个运算符重载函数。在前面的章节中讲解过了。

实例讲解：

val oldStr = "kotlin"
println(oldStr.plus(" very good"))
println(oldStr + " very good")

输出结果为：

kotlin very good
kotlin very good

11. 判断字符串的起始与结尾

在实际的开发中，判断字符串的起始与结尾是很常用的。

startsWith()

其中：

作用： 判断其字符串是否由某一个字符或字符串起始。参数说明：

  1. char : 起始字符
  2. prefix : 起始字符串
  3. ignoreCase : 是否调用Java中的此函数。默认为false
  4. startIndex : 开始位置

例：

val str = "kotlin"
str.startsWith('k')         // 是否有字符`k`起始
str.startsWith("Kot")       // 是否由字符串`kot`起始
str.startsWith("lin",3)     // 当起始位置为3时，是否由字符串`lin`起始

输出结果为：

true
true
true

endsWith()

其中：

作用： 判断其字符串是否由某一个字符或字符串结尾。参数说明：

  1. char : 结尾字符
  2. suffix : 结尾字符串
  3. ignoreCase : 是否调用Java中的此函数。默认为false

例：

val str = "kotlin"
println(str.endsWith("lin"))  // 是否由字符串`lin`结尾
println(str.endsWith('n'))    // 是否由字符`n`结尾

输出结果为：

true
true

http://www.enmalvi.com/2021/03/26/kotlin-string/

标签：常用,String,val,Kotlin,println,str,字符串,函数
From： https://www.cnblogs.com/pengmn/p/17111045.html

相关文章

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99