Scala（一）之“字符串”

    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