Kotlin——初級篇（八）：關於字符串（String）經常使用操做彙總

在前面講解Kotlin數據類型的時候，提到了字符串類型，固然關於其定義在前面的章節中已經講解過了。對Kotlin中的數據類型不清楚的同窗。請參考Kotlin——初級篇（三）：數據類型詳解這篇文章。
在這篇文章中，會對字符串（String）的經常使用操做作出一個講解。好比，字符串的截取、查找、獲取長度、替換等等...

目錄

1、字符串查找

字符串查找功能在實際開發中，只會用到幾個簡單的函數，這裏我只說明幾個經常使用的。

1.一、獲取第一個元素

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

1.二、 獲取最後一個元素

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{}同樣。

1.三、查找元素

其實查找元素提供了兩個高階函數find{}、findLast{}。不過他們都是對firstOrNull()或lastOrNull()函數進行處理。這裏很少做累述。

1.三、 查找對應元素的下標

這裏提供查找對應元素下標的幾個函數：

• 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
14
1
7
14
12

2、字符串截取

若是你有Java或者其餘語言的編程基礎。相信您對字符串的截取應該不會陌生。您能夠繼續的往下看，就看成是對字符串截取只是的一個鞏固。固然，您也能夠直接的跳過本節內容，由於在Kotlin中，字符串的截取的函數subString()是調用了Java中的subString()函數。

在Kotlin中除了調用subString()函數外，還能夠調用subSequence()函數，有興趣的朋友能夠去看看源碼。

2.一、 用subString()函數截取

咱們看一看subString()函數的源碼

@kotlin.internal.InlineOnly
public inline fun String.substring(startIndex: Int): String = (this as java.lang.String).substring(startIndex)

@kotlin.internal.InlineOnly
public inline fun String.substring(startIndex: Int, endIndex: Int): String 
= (this as java.lang.String).substring(startIndex, endIndex)

public fun String.substring(range: IntRange): String = substring(range.start, range.endInclusive + 1)

從以上的源碼中咱們能夠看出，Kotlin中是使用了Java中的subString()函數

其中：

• startIndex參數：截取字符串的開始下標
• endIndex參數：截取字符串的結束下標
• rang參數，是指一個IntRang類型

實例：

val str = "Kotlin is a very good programming language"

println("s = ${str.substring(10)}")  // 當只有開始下標時，結束下標爲length - 1
println(str.substring(0,15))
println(str.substring(IntRange(0,15)))

輸出結果爲：

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

注意：

• 使用subString(startIndex,endIndex)和subString(rang)時的區別。能夠從上邊的結果結合源碼能夠看出來。
• 切記下標越界的狀況。即StringIndexOutOfBoundsException異常

2.二、用subSequence()函數截取

在Kotlin中除了使用上面講解到的使用subString()截取字符串外，還可使用subSequence()函數截取。

咱們看一看其源碼實現：

public fun subSequence(startIndex: Int, endIndex: Int): CharSequence

public fun CharSequence.subSequence(range: IntRange): CharSequence = subSequence(range.start, range.endInclusive + 1)

從源碼中咱們能夠看出，其大體和subString()函數同樣，可是其不提供只傳遞startIndex的狀況

實例：

val str = "Kotlin is a very good programming language"

println(str.subSequence(0,15))
println(str.subSequence(IntRange(0,15)))

輸出結果爲：

Kotlin is a ver
Kotlin is a very

3、字符串替換

同上述字符串截取同樣，若是您有編程經驗，可跳過此節。不過對於字符串替換功能，Kotlin除了實現Java中的replace()ha函數外，還提供了另外的replaceFirst()、replaceAfter()、replaceBefore()、replaceIndent()、等函數。下面會對這些函數意義進行實例講解。

3.一、replace()函數

replace()函數提供了4個重載函數。他們能實現不一樣的功能

3.1.一、 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

3.1.二、 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

3.1.三、 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

3.1.四、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()函數中的參數都有大體的瞭解。而且下面的幾個函數也是大體相同的操做。故而下面的幾個函數操做，我只會舉例說明其做用。關於參數的介紹就不做細究了

3.二、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

3.三、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

3.四、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

3.五、replaceAfter()函數

做用：截取知足條件的第一個字符或字符串前面的字符串，包含知足條件字符或字符串自身，並在其後面加上新的字符串。

例：

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

輸出結果爲：

Kotlin is aAA
KotlinJava

3.六、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

4、字符串分割

同上一節同樣，Kotlin除了實現Java中的split()函數以外，還提供了splitToSequence()函數來分割字符串。分割成功後都會返回一個字符串集合用於咱們後續操做。

4.一、 split()函數

split()函數也是提供了4個重載函數。其中，用正則表達式爲條件分割佔用兩個。用字符分割佔用一個。用字符串分割佔用一個。

4.1.二、使用正則表達式分割

在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")
}

輸出結果爲：

kotlin  java  Lua  JavaScript   
kotlin  java  Lua  JavaScript

4.1.二、使用字符或字符串分割

在實際的項目開發中，仍是這種方式用的要多一些。不過這裏值得注意的是，不論是用字符分割，仍是字符串分割，其都是一個可變參數。即其參數的個數不定。

例：

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")
}

輸出結果爲：

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")
}

輸出結果爲：

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

4.二、 splitToSequence()函數

此函數一樣能夠用字符串或字符去分割，其用法和上述的split()函數同樣。這裏就很少累述了...

5、其餘

除了上面講解到的幾點外，還有不少經常使用的處理，好比檢測字符串是否爲空串，是否爲null，獲取字符串長度，字符串反轉，統計，轉換字符數組，獲取指定下標的字符等等。

5.一、 獲取字符串長度

在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()}")

輸出結果爲：

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
}

5.二、統計重複字符

上面講到了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
}

源碼解釋：該函數接受一個Boolean類型的Lambda表達式。而後循環這個字符串，若是個人條件成立，則變量count自增。循環完成以後返回重複的個數count

實例：

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

輸出結果爲：

count : 3

5.三、 驗證字符串

在實際的開發中，特別是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())

輸出結果爲：

false
true
false
false
true
false

5.四、字符串鏈接

字符串連接，在Java中只能使用+來連接，固然除了StringBuilder、StringBuffer除外。而在Kotlin中除了使用+之外，還可使用plus()函數。其接受任意類型。plus()函數是一個運算符重載函數。在前面的章節中講解過了。若你對Kotlin中的雲素福重載不瞭解，您能夠查看個人另外一篇文章：Kotlin——初級篇（五）：操做符與操做符重載一

實例講解：

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

輸出結果爲：

kotlin very good
kotlin very good

5.五、字符串反轉

和數組同樣，字符串也是能夠反轉元素的。直接使用reversed()函數便可。

例：

val str = "kotlin"
println("字符串反轉：${str.reversed()}")

輸出結果：

字符串反轉：niltok

5.六、判斷字符串的起始與結尾

在實際的開發中，判斷字符串的起始與結尾是很經常使用的。

5.6.一、 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

5.6.二、endsWith()

其中：

做用： 判斷其字符串是否由某一個字符或字符串結尾。
參數說明：

1. char : 結尾字符
2. suffix : 結尾字符串
3. ignoreCase : 是否調用Java中的此函數。默認爲false

例：

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

輸出結果爲：

true
true

總結

在實際的項目開發中，字符串的處理使用的狀況是不少的。特別是字符串的驗證處理、替換、分割、截取。這也是我把這些知識點整理出來的緣由。這些知識點是很基礎，但同時也是很經常使用的。若是您有編程經驗的話您就當對字符串的基礎知識的鞏固。
關於kotlin中字符串的操做就寫到這裏，其實還有不少功能，雖然在開發中用到的地方不是特別多，可是咱們最起碼能應該有個瞭解。有興趣的朋友能夠去看看其源碼的實現。

源代碼

若是各位大佬看了以後感受還闊以，就請各位大佬隨便star一下，您的關注是我最大的動力。
個人我的博客：Jetictors
Github：Jteictors
掘金：Jteictors

歡迎各位大佬進羣共同研究、探索

QQ羣號：497071402