Kotlin—String的常用方法

 

 

Kotlin—String的常用方法

2021-03-26 21:48:46

 1051   0  1

參考目錄 [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/