Scala中的String類就是Java的String類，所以可以直接呼叫Java裡String的所有方法。

• 檢視字串的型別

scala> "Hello, world".getClass.getName
res1: String = java.lang.String

• 獲取字串長度

scala> val s = "Hello, world"
s: String = Hello, world
scala> s.length
res2: Int = 12

• 連線字串

scala> val s = "Hello" + " world"
 

s: String = Hello world
scala> s
res4: String = Hello world

• 把String當作字元序列來處理，可以通過foreach方法遍歷字串中的每個字元。

scala> "Hello".foreach(println)
H
e
l
l
o

• 可以通過for迴圈把字串當做字元序列來處理

scala> for(c <- "hello") println(c)
h
e
l
l
o

• 可以將字串當做位元組序列

scala> s.getBytes.foreach(println)
72
101
108
 

108
111
32
119
111
114
108
100

• 字串還可以使用filter這樣的函式式方法

scala> val result = "hello world".filter(_ != '1')
result: String = hello world

• Scala擁有String和Collection中的功能

// drop(n)方法是從集合頭部開始，丟棄n個元素，並保留剩餘元素的集合方法
scala> "scala".drop(2)  
res8: String = ala
// take(n)方法會保留所給集合的頭n個元素，然後丟棄剩餘的部分
scala> res8.take
 
(2)
res9: String = al

scala> res9.capitalize
res10: String = Al

• 測試字串相等
  Scala中提供==操作符來比較兩個字串的例項

scala> val s1 = "Hello"
s1: String = Hello

scala> val s2 = "Hello"
s2: String = Hello

scala> val s3 = "H" + "ello"
s3: String = Hello

scala> s1 == s2
res11: Boolean = true

scala> s1 == s3
res12: Boolean = true

scala> s1 == s3

使用==，當字串是null是也不會丟擲NullPointerException

scala> val s4: String = null
s4: String = null

scala> s3 == s4
res14: Boolean = false

如果比較兩個字串時，不考慮字元大小寫問題，可以直接將字串先轉成全部大寫或者全部小寫，然後使用==方法

scala> val s1 = "hello"
s1: String = hello

scala> val s2 = "hello"
s2: String = hello

scala> s1.toUpperCase == s2.toUpperCase
res16: Boolean = true

也可以忽略大小寫比較兩個字串

scala> val a = "Marisa"
a: String = Marisa

scala> val b = "marisa"
b: String = marisa

scala> a.equalsIgnoreCase(b)
res17: Boolean = true

• 在Scala中，可以用三個雙引號建立多行的字串

scala> val foo = """This is 
     | a multiline
     | String"""
foo: String =
This is
a multiline
String

scala> foo
res18: String =
This is
a multiline
String

使用如下方法左對齊第一行之後的每一行

scala> val speech = """Four score and
     | |seven years age""".stripMargin
speech: String =
Four score and
seven years age

也可以自定義上面程式碼中的管道符，如下：

scala> val speech = """Four score and
     | #seven years ago""".stripMargin('#')
speech: String =
Four score and
seven years ago

scala> speech
res19: String =
Four score and
seven years ago

將多個字串轉換成一個連續的行

scala> val speech = """Four score and
     | |seven years ago
     | |our fathers""".stripMargin.replace("\n", " ")
speech: String = Four score and seven years ago our fathers

scala> speech
res20: String = Four score and seven years ago our fathers

Scala中多行字串可以包括單引號和雙引號，無需對其進行轉意

scala> val s = """This is know as a
     | |"multline" string
     | |or 'heredoc' syntax.""".stripMargin.replace("\n", " ")
s: String = This is know as a "multline" string or 'heredoc' syntax.

scala> s
res21: String = This is know as a "multline" string or 'heredoc' syntax.

• 分割字串，使用String物件中的split()方法，作用的結果是產生一個以字串為元素的一個數組

scala> "hello world".split(" ")
res22: Array[String] = Array(hello, world)

scala> "hello world".split(" ").foreach(println)
hello
world

scala> val s = "eggs,milk,butter,Coco Puffs"
s: String = eggs,milk,butter,Coco Puffs

scala> s.split(",")
res25: Array[String] = Array(eggs, milk, butter, Coco Puffs)

scala> s.split(",").map(_.trim)
res27: Array[String] = Array(eggs, milk, butter, Coco Puffs)
// 使用正則表示式空格分割一個字串
scala> "hello world, this is Al".split("\\s+")
res29: Array[String] = Array(hello, world,, this, is, Al)

• 字串中的變數替換，Scala中基礎的字串插值就是在字串前加字幕‘s’，然後在字串中放入變數，每個變數都應以‘$’開頭。字串前加字母‘s’時，其實是在建立一個處理字串字面量

scala> val name = "GnahzNib"
name: String = GnahzNib

scala> val age = 33
age: Int = 33

scala> val weight = 140.0
weight: Double = 140.0

scala> println(s"$name is $age years old, and weights $weight pounds.")
GnahzNib is 33 years old, and weights 140.0 pounds.

在字串字面量中使用表示式，“${}內可嵌入任何表示式”,包括等號表示式。

scala> println(s"Age next year: ${age + 1}")
Age next year: 34

scala> println(s"You are 33 years old:${age == 33}")
You are 33 years old:true

注意，在列印物件欄位時使用花括號。

scala> case class Student(name: String, score: Int)
defined class Student

scala> val hannah = Student("Hannah", 95)
hannah: Student = Student(Hannah,95)

scala> println(s"${hannah.name} has a score of ${hannah.score}")
Hannah has a score of 95

字串差值f（printf格式化）

scala> println(f"$name is $age years old, and weighs $weight%.2f pounds.")
GnahzNib is 33 years old, and weighs 140.00 pounds.

scala> printf(f"$name is $age years old, and weighs $weight%.2f pounds.")
GnahzNib is 33 years old, and weighs 140.00 pounds.

其他插入符

scala> s"gnahz\nnib"
res36: String =
gnahz
nib

• 挨個處理字串中的字元
  原始的String呼叫filter方法，建立一個新的字串，生成的字串呼叫map方法，遍歷其每個字元。

scala> val upper = "hello, world".filter(_!='l').map(_.toUpper)
upper: String = HEO, WORD

跟map函式等價的for/yield迴圈的表示如下：

scala> val upper = for(c <- "hello, world") yield c.toUpper
upper: String = HELLO, WORLD

在for迴圈新增yield實際上是將每次迴圈的結果放到了一個臨時存放區中，當迴圈結束時，在臨時存放區中的所有元素以一個集合的形式返回。

scala> val result = for{
     | c <- "hello, world"
     | if c != 'l'
     | }yield c.toUpper
result: String = HEO, WORD

總結：
map方法或者是for/yield都是將一個集合轉換成為另一個新的集合，foreach則是典型的對每個元素進行操作但不返回結果的方法。

• 字串中的查詢模式
  在一個String上呼叫.r方法可以建立一個Regex物件，之後再查詢是否含有一個匹配時就可以用findFirstIn,當需要查詢是否完全匹配時可以用findAllIn。

// 匹配一個或多個數字序列
scala> val numPatter = "[0-9]+".r
numPatter: scala.util.matching.Regex = [0-9]+

scala> val address = "123 Main Street Suite 101"
address: String = 123 Main Street Suite 101

scala> val match1 = numPatter.findFirstIn(address)
match1: Option[String] = Some(123)

scala> val match1 = numPatter.findAllIn(address)
match1: scala.util.matching.Regex.MatchIterator = non-empty iterator

scala> match1.foreach(println)
123
101

• 字串中的替換模式
  用正則表示式匹配一段字串，然後替換它們。因為String是不可變的，不可以在它上面直接查詢然後替換，但是可以建立一個新的String，而這個新的String包含了替換後的內容。
  在一個String上呼叫replaceAll，要給結果賦一個新的變數

scala> val address = "123 Main Street".replaceAll("[0-9]", "x")
address: String = xxx Main Street

可以建立一個正則表示式，然後在正則表示式上呼叫replaceAllIn方法，要給結果賦一個新值。

scala> val regex = "[0-9]".r
regex: scala.util.matching.Regex = [0-9]

scala> val newAddress = regex.replaceAllIn("123 Main Street", "x")
newAddress: String = xxx Main Street

• 抽取String中模式匹配的部分
  抽取一個或者多個在字串中的正則匹配到的部分，定義想要抽取的正則表示式，在它們周圍加上括號這樣就可以將其當做“正則表示式組”來使用

scala> val pattern = "([0-9]+) ([A-Za-z]+)".r
pattern: scala.util.matching.Regex = ([0-9]+) ([A-Za-z]+)

scala> val pattern(count, fruit) = "100 Bananas"
count: String = 100
fruit: String = Bananas

• 訪問字串中的一個字元
  得到字串中指定位置的一個字元。

scala> "hello".charAt(0)
res43: Char = h
// Scala的Array符號
scala> "hello"(0)
res44: Char = h

• String中新增自定義的方法
  定義一個隱式轉換的類，然後在這個類中定義一些方法，來實現期望的行為。

scala> implicit class StringImprovements(s: String){
     | def increment = s.map(c => (c + 1).toChar)
     | }
defined class StringImprovements

scala> val result = "HAL".increment
result: String = IBM