Kotlin实战(二)_kotlin indexoffirst

一、字符串

1.1、字符串查找

查找第一个元素

//1、使用【index】或get(index)获取元素，查找第一个元素
println(a[0])//H
println(a.get(100))//数组越界则抛出StringIndexOutOfBoundsException异常

//2、使用 first/firstOrNull 查找第一个元素
println(a.first())//H first查找第一个元素，如果字符串为空，则抛出NoSuchElementException异常
println(a.firstOrNull())//H firstOrNull查找第一个元素，如果字符串为空，不会抛出异常，返回null
println("".firstOrNull())//null

//3、使用 first{}/firstOrNull{} 查找
println(a.first { it =='H'})//H   first{}函数查找第一个元素，如果字符串为空，则抛出NoSuchElementException异常
println(a.firstOrNull { it =='H'})//H  firstOrNull{}函数查找第一个元素 ，如果字符串为空，不会抛出异常，返回null
println("".firstOrNull { it =='H'})//null
1
2
3
4
5
6
7
8
9
10
11
12
13

查找最后一个元素

val a = "Hello Kotlin"
println(a.get(a.length-1))//n  //使用get(index)查找最后一个元素
println(a[a.length-1])//n  //使用【index】查找最后一个元素

println(a.last())//n  //使用last()查找最后一个元素，注意：如果字符串为null则抛出NoSuchElementException异常
println(a.lastOrNull())//n //使用lastOrNull()查找最后一个元素 ，如果字符串为空，不会抛出异常，返回null
println("".lastOrNull())//null
1
2
3
4
5
6
7

查找元素

查找元素提供了两个高阶函数find{}、findLast{}。

val a = "Hello Kotlin"
println(a.find { it=='H' })//H  从前往后查找第一个H 字符串为null 返回null ，对firstOrNull()处理
println(a.findLast { it=='H' })//H  从后往前查找第一个H 字符串为null 返回null 对lastOrNull()处理
1
2
3

查找对应元素的下标

这里提供查找对应元素下标(每找到返回-1)的几个函数：

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

val a = "Hello Kotlin"
println(a.indexOf('o',0))//4  从第0位置开始查找
println(a.indexOf("Kotlin",1))//6 从第1位置开始查找
println(a.indexOfFirst { it == 'o' })//4
println(a.indexOfLast { it == 'o' })//7
println(a.lastIndexOf('o'))//7
println(a.lastIndexOf("llo"))//2
1
2
3
4
5
6
7

是否包含子字符串

println(a.contains("ll"))//true  是否包含子字符 
println(a.contains("LL", true))//true  是否包含子字符  参数2：是否忽略大小写
1
2

1.2、字符串截取

subString()函数

Kotlin中是使用了Java中的subString()函数

expect fun String.substring(startIndex: Int): String
expect fun String.substring(startIndex: Int, endIndex: Int): String
fun String.substring(range: IntRange): String
1
2
3

使用如下:

val a = "Hello Kotlin"
println(a.substring(0,4))//Hell 从第0位置截取到第4位置  4不包含
println(a.substring(4))//o Kotlin  从第4位置截取到结尾 4 包含
println(a.substring(IntRange(0,4)))//Hello 从第0位置截取到第4位置 4包含 调用的源码是substring(range.start, range.endInclusive + 1)
1
2
3
4

substringAfter()函数

在第一次出现分隔符后返回子字符串。如果字符串不包含分隔符，则返回missingDelimiterValue，默认为原始字符串。

fun String.substringAfter(delimiter: Char, missingDelimiterValue: String = this): String
fun String.substringAfter(delimiter: String, missingDelimiterValue: String = this): String 
1
2

使用如下:

println(a.substringAfter("l"))//lo Kotlin 截取第一次出现指定字符（不包括该字符）之后字符串 默认未找到返回原字符串
println(a.substringAfter("KKKK","ERROR"))//ERROR 截取第一次出现指定字符（不包括该字符）之后字符串 未找到返回指定字符串
1
2

substringAfterLast()函数

在最后一次出现分隔符后返回一个子字符串。如果字符串不包含分隔符，则返回missingDelimiterValue，默认为原始字符串。

fun String.substringAfterLast(delimiter: Char, missingDelimiterValue: String = this): String
fun String.substringAfterLast(delimiter: String, missingDelimiterValue: String = this): String
1
2

使用如下:

println(a.substringAfterLast("l"))//in 截取最后一次出现指定字符（不包括该字符）之后字符串 默认未找到返回原字符串
println(a.substringAfterLast("KKKK","ERROR"))//ERROR  截取最后一次出现指定字符（不包括该字符）之后字符串 未找到返回指定字符串

1
2
3
4

substringBefore()函数

在第一次出现分隔符之前返回一个子字符串。如果字符串不包含分隔符，则返回missingDelimiterValue，默认为原始字符串。

fun String.substringBefore(delimiter: Char, missingDelimiterValue: String = this): String
fun String.substringBefore(delimiter: String, missingDelimiterValue: String = this): String 
1
2

使用如下:

println(a.substringBefore("l"))//He 截取第一次出现指定字符（不包括该字符）之前字符串 默认未找到返回原字符串
println(a.substringBefore("KKKK","ERROR"))//ERROR  截取第一次出现指定字符（不包括该字符）之前字符串 未找到返回指定字符串
1
2

substringBeforeLast()函数

在最后一次出现分隔符之前返回一个子字符串。如果字符串不包含分隔符，则返回missingDelimiterValue，默认为原始字符串。

fun String.substringBeforeLast(delimiter: Char, missingDelimiterValue: String = this): String
fun String.substringBeforeLast(delimiter: String, missingDelimiterValue: String = this): String
1
2

使用如下:

println(a.substringBeforeLast("l"))//Hello Kot  截取最后一次出现指定字符（不包括该字符）之前字符串 默认未找到返回原字符串
println(a.substringBeforeLast("KKKK","ERROR"))//ERROR   截取最后一次出现指定字符（不包括该字符）之前字符串 未找到返回指定字符串
1
2

subSequence()函数截取

fun subSequence(startIndex: Int, endIndex: Int): CharSequence
fun CharSequence.subSequence(range: IntRange): CharSequence = subSequence(range.start, range.endInclusive + 1)
1
2

从源码中可以看出，其大致和subString()函数一样，但是没有 只传递startIndex的函数

使用如下:

val a = "Hello Kotlin"
println(a.subSequence(0,4))//Hell 从第0位置截取到第4位置  4不包含
println(a.subSequence(IntRange(0,4)))//Hello   从第0位置截取到第4位置  4包含 调用的源码是subSequence(range.start, range.endInclusive + 1)
1
2
3

1.3、字符串替换

replace()函数

把原字符串中的某一个字符全部替换成新的字符。然后返回新的字符串

fun String.replace(oldChar: Char, newChar: Char, ignoreCase: Boolean = false): String
fun String.replace(oldValue: String, newValue: String, ignoreCase: Boolean = false): String

inline fun CharSequence.replace(regex: Regex, replacement: String): String = regex.replace(this, replacement)

inline fun CharSequence.replace(regex: Regex, noinline transform: (MatchResult) -> CharSequence): String =
    regex.replace(this, transform)
1
2
3
4
5
6
7

使用如下:

val a = "1Hello 2 Kotlin"
println(a.replace('o','8'))//1Hell8 2 K8tlin  将所有的o替换为8 不忽略大小写
println(a.replace('O','8',true))//1Hell8 2 K8tlin 将所有的o替换为8 忽略大小写
println(a.replace("Kotlin","Java"))//1Hello 2 Java 将所有的Kotlin替换为Java 不忽略大小写
println(a.replace("kotlin","Java",true))//1Hello 1 Java 将所有的kotlin替换为Java 忽略大小写

val r2 = Regex("[0-9]")
println(a.replace(r2,"2018"))//2018Hello 2018 Kotlin 使用正则匹配替换【0-9】为2018
println(a.replace(r2){
    if(it.value=="2"){
           "A"
    }else{
           "B"
    }
})//BHello A Kotlin  使用正则匹配替换【0-9】如果是2替换为A其他替换为B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

replaceFirst()函数

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

fun String.replaceFirst(oldChar: Char, newChar: Char, ignoreCase: Boolean = false): String
fun String.replaceFirst(oldValue: String, newValue: String, ignoreCase: Boolean = false): String

inline fun CharSequence.replaceFirst(regex: Regex, replacement: String): String = regex.replaceFirst(this, replacement)
1
2
3
4

使用如下:

val a="Hello Kotlin"
println(a.replaceFirst('o','8'))//Hell8 Kotlin  将首个的o替换为8 不忽略大小写
println(a.replaceFirst('O','8',true))//Hell8 Kotlin 将首个的o替换为8 忽略大小写
println(a.replaceFirst("Kotlin","Java"))//Hello Java 将首个的Kotlin替换为Java 不忽略大小写
println(a.replaceFirst("kotlin","Java",true))//Hello Java 将首个的kotlin替换为Java 忽略大小写

println(a.replaceFirst(Regex("[a-z]"),"8"))//H8llo Kotlin 将首个符合正则[a-z]替换为8 不忽略大小写
println(a.replaceFirst(Regex("[a-z]",RegexOption.IGNORE_CASE),"8"))//8ello Kotlin 将首个符合正则[a-z]替换为8 忽略大小写
1
2
3
4
5
6
7
8

replaceBefore()函数

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

fun String.replaceBefore(delimiter: Char, replacement: String, missingDelimiterValue: String = this): String
fun String.replaceBefore(delimiter: String, replacement: String, missingDelimiterValue: String = this): String
1
2

使用如下:

val a="Hello Kotlin"
println(a.replaceBefore('l',"4"))//4llo Kotlin 截取首个满足条件的字符或字符串 包括本身，截取到结尾。在截取后字符串前面加上新字符
println(a.replaceBefore("ll","4"))//4llo Kotlin 截取首个满足条件的字符或字符串 包括本身，截取到结尾。在截取后字符串前面加上新字符
1
2
3

replaceBeforeLast()函数

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

fun String.replaceBeforeLast(delimiter: Char, replacement: String, missingDelimiterValue: String = this): String 
fun String.replaceBeforeLast(delimiter: String, replacement: String, missingDelimiterValue: String = this): String 
1
2

使用如下:

val a="Hello Kotlin"
println(a.replaceBeforeLast('l',"4"))//4lin 截取最后满足条件的字符或字符串 包括本身，截取到结尾。在截取后字符串前面加上新字符
println(a.replaceBeforeLast("ll","4"))//4llo Kotlin 截取最后满足条件的字符或字符串 包括本身，截取到结尾。在截取后字符串前面加上新字符

1
2
3
4

replaceAfter()函数

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

fun String.replaceAfter(delimiter: Char, replacement: String, missingDelimiterValue: String = this): String 
fun String.replaceAfter(delimiter: String, replacement: String, missingDelimiterValue: String = this): String
1
2

使用如下:

val a="Hello Kotlin"
println(a.replaceAfter('l',"4"))//Hel4 从开始位置截取到首个满足条件字符或字符串，包括本身，在截取后字符串后面加上新字符
println(a.replaceAfter("ll","4"))//Hell4 从开始位置截取到首个满足条件字符或字符串，包括本身，在截取后字符串后面加上新字符

1
2
3
4

replaceAfterLast()函数

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

fun String.replaceAfterLast(delimiter: String, replacement: String, missingDelimiterValue: String = this): String 
fun String.replaceAfterLast(delimiter: Char, replacement: String, missingDelimiterValue: String = this): String 
1
2

使用如下:

val a="Hello Kotlin"
println(a.replaceAfterLast('l',"4"))//Hello Kotl4  从开始位置截取到最后满足条件字符或字符串，包括本身，在截取后字符串后面加上新字符
println(a.replaceAfterLast("ll","4"))//Hell4   从开始位置截取到最后满足条件字符或字符串，包括本身，在截取后字符串后面加上新字符
1
2
3

1.4、字符串分割

split()函数

fun CharSequence.split(vararg delimiters: Char, ignoreCase: Boolean = false, limit: Int = 0): List<String>
fun CharSequence.split(vararg delimiters: String, ignoreCase: Boolean = false, limit: Int = 0): List<String>

inline fun CharSequence.split(regex: Regex, limit: Int = 0): List<String>
fun CharSequence.split(regex: Pattern, limit: Int = 0): List<String>
1
2
3
4
5

使用方式:

val a="H1e2l13l41o"
println(a.split('e'))//[H1, 2l13l41o] 以e分割，默认不忽略大小写
println(a.split("E",ignoreCase = true))//[H1, 2l13l41o] 以E分割 ignoreCase = true忽略大小写
println(a.split("L",ignoreCase = true,limit = 2))//[H1e2, 13l41o] 以L分割 ignoreCase = true 忽略大小写,limit = 2 最大返回分割后数据为2
println(a.split("e","4",ignoreCase = true,limit = 10))//[H1, 2l13l, 1o] 以e、4分割 ignoreCase = true 忽略大小写,limit = 2 最大返回分割后数据为10

println(a.split(Regex("[0-9]")))//[H, e, l, , l, , o] 使用正则"[0-9]"分割,可指定分割后数据个数
println(a.split(Regex("[A-Z]",RegexOption.IGNORE_CASE)))//[, 1, 2, 13, 41, ] 使用正则"[0-9]"分割,RegexOption.IGNORE_CASE 忽略大小
println(a.split(Pattern.compile("[A-Z]",Pattern.CASE_INSENSITIVE)))//[, 1, 2, 13, 41, ] java方式使用正则"[0-9]"分割,Pattern.CASE_INSENSITIVE 忽略大小

1
2
3
4
5
6
7
8
9
10

splitToSequence()函数

fun CharSequence.splitToSequence(vararg delimiters: Char, ignoreCase: Boolean = false, limit: Int = 0): Sequence<String>
fun CharSequence.splitToSequence(vararg delimiters: String, ignoreCase: Boolean = false, limit: Int = 0): Sequence<String>
1
2

使用方式:

val a="H1e2l13l41o"
a.splitToSequence('e')//[H1, 2l13l41o] 以e分割，默认不忽略大小写
a.splitToSequence("E",ignoreCase = true)//[H1, 2l13l41o] 以E分割 ignoreCase = true忽略大小写
a.splitToSequence("L",ignoreCase = true,limit = 2)//[H1e2, 13l41o] 以L分割 ignoreCase = true 忽略大小写,limit = 2 最大返回分割后数据为2
a.splitToSequence("e","4",ignoreCase = true,limit = 10)//[H1, 2l13l, 1o] 以e、4分割 ignoreCase = true 忽略大小写,limit = 2 最大返回分割后数据为10
1
2
3
4
5

splitToSequence()与split()不同于返回值,splitToSequence()返回Sequence<String>,而split()返回List<String>

1.5、字符串的比较

expect fun String?.equals(other: String?, ignoreCase: Boolean = false)
open operator fun equals(other: Any?): Boolean
1
2

使用如下:

val a="Hello Kotlin"
val b=String(StringBuffer().append("Hello").append(" Kotlin"))
val c="hello kotlin"
println(a===b)//false   === 比较地址
println(a==b)//true  == 比较值 与equals相同
println(a.equals(b))//true 比较值 
println(a.equals(c,true))//true 比较值 忽略大小写
1
2
3
4
5
6
7

1.6、字符串其他操作

字符串模板

符串可以包含模板表达式，即可求值的代码片段，并将其结果连接到字符串中

val a="Hello Kotlin"
println("$a 长度为 ${a.length}")//Hello Kotlin 长度为 12
//打印$
println("输出${'$'}")//输出$
1
2
3
4

获取字符串长度

val a="Hello Kotlin"
println(a.length)//12
println(a.count())//12 count()内部调用的就是length
1
2
3

统计重复字符个数

val a = "Hello Kotlin"
// count{}该函数接受一个Boolean类型的Lambda表达式。然后循环这个字符串，如果我的条件成立，则变量count自增。循环完成之后返回重复的个数count
println(a.count {
    it == 'l'
})//3
1
2
3
4
5

验证字符串

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

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

val a: String? = "Hello Kotlin"

println(a?.isEmpty())//false 判断字符是否为空，需要使用？空安全调用
println(a?.isNotEmpty())//true 判断字符是否为不为空，需要使用？空安全调用
println(a.isNullOrEmpty())//false 判断字符是否为为空，原字符为空返回false，无需空安全调用
println(a?.isBlank())//false 判断字符空格数是否为字符串的长度，需要使用？空安全调用
println(a?.isNotBlank())//true 判断字符空格数是否不为字符串的长度，需要使用？空安全调用
println(a.isNullOrBlank())//false  判断字符空格数是否为字符串的长度，原字符为空返回false，无需空安全调用
1
2
3
4
5
6
7
8

字符串连接

val a = "Hello"
println(a+" Kotlin")//Hello Kotlin
println("$a Kotlin")//Hello Kotlin 常用
println(a.plus(" Kotlin"))//Hello Kotlin plus()函数是一个运算符重载函数(+)
1
2
3
4

字符串反转

和数组一样,字符串也是可以反转元素的,可以调用reversed()函数

val a = "Hello"
println(a.reversed())//olleH 字符串反转
1
2

判断字符串起始

fun CharSequence.startsWith(char: Char, ignoreCase: Boolean = false): Boolean
fun String.startsWith(prefix: String, ignoreCase: Boolean = false): Boolean
fun String.startsWith(prefix: String, startIndex: Int, ignoreCase: Boolean = false): Boolean
fun CharSequence.startsWith(prefix: CharSequence, ignoreCase: Boolean = false): Boolean
fun CharSequence.startsWith(prefix: CharSequence, startIndex: Int, ignoreCase: Boolean = false): Boolean 
1
2
3
4
5

使用如下:

val a="Hello Kotlin"
println(a.startsWith('H'))//true  判断是否以指定字符开始 默认不忽略大小写
println(a.startsWith("Hello"))//true 判断是否以指定字符串开始 默认不忽略大小写
println(a.startsWith("hello",ignoreCase = true))//true 判断是否以指定字符串开始 ignoreCase = true忽略大小写
println(a.startsWith("llo",2))//true 判断是否以指定字符串从指定位置（2）开始
1
2
3
4
5

判断字符串结束

fun String.endsWith(suffix: String, ignoreCase: Boolean = false): Boolean
fun CharSequence.endsWith(char: Char, ignoreCase: Boolean = false): Boolean
fun CharSequence.endsWith(suffix: CharSequence, ignoreCase: Boolean = false): Boolean 
1
2
3

val a="Hello Kotlin"
println(a.endsWith('n'))//true 判断是否以指定字符结尾 默认不忽略大小写
println(a.endsWith("in"))//true  判断是否以指定字符串结尾 默认不忽略大小写
println(a.endsWith("IN",true))//true  判断是否以指定字符串结尾 忽略大小写
1
2
3
4

字符串原样输出

/*---------------------------- 原样输出字符串 ----------------------------*/
val place4="""
    12
    12
    31<html>2</html>
    12
    32
    32 ss
"""
println(place4)
1
2
3
4
5
6
7
8
9
10

字符串删除空格

inline fun String.trim(): String

inline fun String.trimStart(): String
inline fun String.trimEnd(): String

fun String.trimStart(vararg chars: Char): String
fun String.trimEnd(vararg chars: Char): String

inline fun String.trimStart(predicate: (Char) -> Boolean): String
inline fun String.trimEnd(predicate: (Char) -> Boolean): String 

fun String.trimIndent(): String
fun String.trimMargin(marginPrefix: String = "|"): String
1
2
3
4
5
6
7
8
9
10
11
12
13

使用如下:

val a = "  Hello Kotlin  "
println(a.trim())//Hello Kotlin		清除首位空格
println(a.trimStart())//Hello Kotlin        清除开始空格
println(a.trimEnd())//  Hello Kotlin        清除结束空格

val a1 = "Hello Kotlin"
println(a1.trimEnd('n', 'l', 'i'))//Hello Kot  清除结尾指定字符
println(a1.trimEnd {
    it == 'n'||it=='l'||it=='i'
})//Hello Kot  清除结尾指定字符（高阶函数）
println(a1.trimStart('H', 'e'))//llo Kotlin  清除开始指定字符
println(a1.trimStart {
    it == 'H' || it == 'e'
})//llo Kotlin  清除开始指定字符（高阶函数）

val b = """
    ABC
    123
    456
    """
println(b.trimIndent())//清除每一行前面的最小缩进
//ABC
//123
//456

val withoutMargin1 = """ABC
            |123
            |456
            """
println(withoutMargin1.trimMargin())//清除每一行前面的最小缩进和默认'|'字符组合
//ABC
//123
//456

val withoutMargin2 = """
#XYZ
#foo
#bar
"""
println(withoutMargin2.trimMargin("#"))//清除每一行前面的最小缩进和指定字符组合（此处指定"#"）
//XYZ
//foo
//bar
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

Kotlin实战(三)