Scala（一）之“字符串”

    Scala中的String类就是Java的String类，所以可以直接调用Java里String的所有方法。

• 查看字符串的类型

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

• 获取字符串长度

scala> val s = "Hello, world"s: String = Hello, worldscala> s.lengthres2: Int = 12

• 连接字符串

scala> val s = "Hello" + " world"s: String = Hello worldscala> sres4: String = Hello world

• 把String当作字符序列来处理，可以通过foreach方法遍历字符串中的每个字符。

scala> "Hello".foreach(println)Hello

• 可以通过for循环把字符串当做字符序列来处理

scala> for(c <- "hello") println(c)hello

• 可以将字符串当做字节序列

scala> s.getBytes.foreach(println)7210110810811132119111114108100

• 字符串还可以使用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 = alscala> res9.capitalizeres10: String = Al

• 测试字符串相等
  Scala中提供==操作符来比较两个字符串的实例

scala> val s1 = "Hello"s1: String = Helloscala> val s2 = "Hello"s2: String = Helloscala> val s3 = "H" + "ello"s3: String = Helloscala> s1 == s2res11: Boolean = truescala> s1 == s3res12: Boolean = truescala> s1 == s3

使用==，当字符串是null是也不会抛出NullPointerException

scala> val s4: String = nulls4: String = nullscala> s3 == s4res14: Boolean = false

如果比较两个字符串时，不考虑字符大小写问题，可以直接将字符串先转成全部大写或者全部小写，然后使用==方法

scala> val s1 = "hello"s1: String = helloscala> val s2 = "hello"s2: String = helloscala> s1.toUpperCase == s2.toUpperCaseres16: Boolean = true

也可以忽略大小写比较两个字符串

scala> val a = "Marisa"a: String = Marisascala> val b = "marisa"b: String = marisascala> a.equalsIgnoreCase(b)res17: Boolean = true

• 在Scala中，可以用三个双引号创建多行的字符串

scala> val foo = """This is      | a multiline     | String"""foo: String =This isa multilineStringscala> foores18: String =This isa multilineString

使用如下方法左对齐第一行之后的每一行

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

也可以自定义上面代码中的管道符，如下：

scala> val speech = """Four score and     | #seven years ago""".stripMargin('#')speech: String =Four score andseven years agoscala> speechres19: String =Four score andseven 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 fathersscala> speechres20: 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> sres21: 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)helloworldscala> val s = "eggs,milk,butter,Coco Puffs"s: String = eggs,milk,butter,Coco Puffsscala> 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 = GnahzNibscala> val age = 33age: Int = 33scala> val weight = 140.0weight: Double = 140.0scala> 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: 34scala> 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 Studentscala> 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 =gnahznib

• 挨个处理字符串中的字符
  原始的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.toUpperupper: String = HELLO, WORLD

在for循环添加yield实际上是将每次循环的结果放到了一个临时存放区中，当循环结束时，在临时存放区中的所有元素以一个集合的形式返回。

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

总结：
map方法或者是for/yield都是将一个集合转换成为另一个新的集合，foreach则是典型的对每个元素进行操作但不返回结果的方法。

• 字符串中的查找模式
  在一个String上调用.r方法可以创建一个Regex对象，之后再查找是否含有一个匹配时就可以用findFirstIn,当需要查找是否完全匹配时可以用findAllIn。

// 匹配一个或多个数字序列scala> val numPatter = "[0-9]+".rnumPatter: scala.util.matching.Regex = [0-9]+scala> val address = "123 Main Street Suite 101"address: String = 123 Main Street Suite 101scala> val match1 = numPatter.findFirstIn(address)match1: Option[String] = Some(123)scala> val match1 = numPatter.findAllIn(address)match1: scala.util.matching.Regex.MatchIterator = non-empty iteratorscala> match1.foreach(println)123101

• 字符串中的替换模式
  用正则表达式匹配一段字符串，然后替换它们。因为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]".rregex: 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]+)".rpattern: scala.util.matching.Regex = ([0-9]+) ([A-Za-z]+)scala> val pattern(count, fruit) = "100 Bananas"count: String = 100fruit: 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 StringImprovementsscala> val result = "HAL".incrementresult: String = IBM