Scala Cookbook翻译 Chapter 1.Strings 第二部分

1.5 遍历字符

• 问题：你想遍历字符串中的每个字符，在遍历字符串时对每个字符进行操作。

1.5.1 解决方案：

• 根据你的需求和喜好，你可以使用map或者foreach方法，一个是循环，另一个是其他方法。

• map把输入字符转成大写的例子

  scala> val upper = "hello, world".map(c => c.toUpper)
  upper: String = HELLO, WORLD
  
  //大部分使用以下缩写，使用下划线的魔法
  scala> val upper = "hello, world".map(_.toUpper)
  upper: String = HELLO, WORLD
  

• 任何集合中，如字符串的字符序列，你可以把集合方法链接在一起以达到预期的结果。下面的例子是在原始字符串的基础上调用filter方法将所有的小写字母“L”删除后创建一个新的字符串，然后已这个新的字符串作为ma方法的输入将剩余的字符转换成大写字符。

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

• 当你刚开始使用Scala时可能不大习惯map方法，使用Scala的for循环可以达到相同的结果。

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

• 要写一个和map方法一样的for循环，可以在循环结束添加一个yield，此时的for/yield循环和前两个map方法例子是一样的。

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

• 在for循环中添加yield本质上是将每次循环结果放置到暂存区，当循环结果，所有在暂存区的元素将作为一个集合返回。下例for/yield循环结果和第三个map方法一样。

  val result = for {
  c <- "hello, world"
  if c != 'l'
  } yield c.toUppe
  

• map方法和for/yield方法用于将一个集合转换成另一个，而foreach方法通常用来操作每个元素而且没有返回值，下面这个打印的情况比较有用。

  scala> "hello".foreach(println)
  h 
  e 
  l 
  l
  o
  

1.5.2 讨论

• 因为Scala把string当做字符序列，并且Scala是面向对象和函数式编程语言，你可以如上述方法显示的一样遍历字符串中的字符，下面使用经典Java方法进行比较。

  String s = "Hello";
  StringBuilder sb = new StringBuilder();
  for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);
      // do something with the character ...
      // sb.append ...
  }
  String result = sb.toString();
  

• 可以看到Scala方法更加简洁并且还是很可读的，这种简洁和可读使你更加专注于解决手上的问题，一旦你熟悉Scala，就像Java例子中的命令代码掩盖了业务逻辑。

• 维基百科中对命令式编程的描述是这样的：命令式编程是一种编程范式，在改变程序状态的一系列声明中描述计算。命令程序定义计算机的命令序列来执行。这是Java的例子所示，它定义了一系列明确的声明告诉计算机如何达到预期的结果。

1.5.3 理解map如何工作：

• 根据你的编码偏好，你可以在map方法中使用大的代码块。这两个例子证明了通过一个运算来传递一个map方法的语法。

  // first example
  "HELLO".map(c => (c.toByte+32).toChar)
  
  // second example
  "HELLO".map{ c =>
  (c.toByte+32).toChar
  }
  

• 注意算法一次操作一个字符。因为这个例子中map方法被字符串调用，map将字符串当做一个字符元素的有序集合。map方法有一个隐式循环，并且在循环中一次操作一个字符运算。

• 尽管这个运算很短，设想一下它需要很长的时间。在这种情况下，为了保持你的代码清晰，你可能想要把它写成一个方法（或函数），这个方法可以传递到map方法。要编写一个可以传递到map方法执行字符串中的字符的方法，定义它以一个单一的字符作为输入，然后执行该方法中的字符的逻辑。当逻辑完成时，返回任何运算返回的结果。尽管下面的运算依然很短，它演示了如何创建一个自定义方法，并将这个方法传递到map中。

  // 自定义操作字符的方法
  scala> def toLower(c: Char): Char = (c.toByte+32).toChar
  toLower: (c: Char)Char
  
  // 使用map方法
  scala> "HELLO".map(toLower)
  res0: String = hello
  

• 作为额外的好处，同样的方法也可以使用在for/yield方法中。

  scala> val s = "HELLO"
  s: java.lang.String = HELLO
  
  scala> for (c <- s) yield toLower(c)
  res1: String = hello
  

• 在讨论中我使用了“方法”一词，但是你也可以在这里使用函数代替方法，那么函数和方法的不同是什么?

  • 下面这个函数相当于toLower方法

    val toLower = (c: Char) => (c.toByte+32).toChar
    toLower: Char => Char = <function1>
    

  • 这个函数可以和之前使用的toLower方法以同样的方式传递到map中

    scala> "HELLO".map(toLower)
    res0: String = hello    
    

  • 详情可看第九章函数编程，查看更多函数信息和方法函数区别的。

1.5.4 完整的例子

• 下面的例子演示如何在字符串中调用getBytes方法，然后传递代码块到foreach方法中来计算一个字符串的Adler-32校验和值。

  package tests
  /**
  * Calculate the Adler-32 checksum using Scala.
  * @see http://en.wikipedia.org/wiki/Adler-32
  */
  object Adler32Checksum {
      val MOD_ADLER = 65521
  
      def main(args: Array[String]) {
          val sum = adler32sum("Wikipedia")
          printf("checksum (int) = %d\n", sum)
          printf("checksum (hex) = %s\n", sum.toHexString)
      }
  
      def adler32sum(s: String): Int = {
          var a = 1
          var b = 0
          s.getBytes.foreach{char =>
              a = (char + a) % MOD_ADLER
              b = (b + a) % MOD_ADLER
          }
          // note: Int is 32 bits, which this requires
          b * 65536 + a // or (b << 16) + a
      }
  
  }
  

• getBytes方法返回一个字符串的字节有序集合，如下所示：

  scala> "hello".getBytes
  res0: Array[Byte] = Array(104, 101, 108, 108, 111)
  

• 调用getBytes之后添加foreach方法可以操作每个字节的值：

  scala> "hello".getBytes.foreach(println)
  104
  101
  108
  108
  111
  

• 上面例子中使用foreach代替map，因为目标是循环字符串中的每个字节，并且在每个字节上进行一些操作，但是你并不想在循环的最后返回任何值。

• 查看更多

  The Adler-32 checksum algorithm

---

1.6 字符串中的搜索模式

• 问题：确定一个字符串中是否包含正则表达式模式

1.6.1 解决方案

• 通过在字符串上调用.r方法创建一个正则表达式对象，当你查找一个匹配时使用findFirstIn模式，搜索所有匹配时用findAllIn。

• 首先创建一个你想搜索的正则表达式模式，下面例子中是一个或多个数字字符的序列。

  //创建规则
  scala> val numPattern = "[0-9]+".r
  numPattern: scala.util.matching.Regex = [0-9]+
  
  //创建需要查找的字符串例子
  scala> val address = "123 Main Street Suite 101"
  address: java.lang.String = 123 Main Street Suite 101
  
  //使用findFirstIn方法查找第一个匹配（返回的是Option[String]，讨论中详解）
  scala> val match1 = numPattern.findFirstIn(address)
  match1: Option[String] = Some(123)
  
  //使用findAllIn查找复杂匹配,返回迭代器
  scala> val matches = numPattern.findAllIn(address)
  matches: scala.util.matching.Regex.MatchIterator = non-empty iterator
  
  //循环输出结果
  scala> matches.foreach(println)
  123
  101
  

• 如果findAllIn查找不到任何结果，就会返回一个空的迭代器，你不需要检查结果是否为空，所以你可以和之前一样写代码。如果你需要把结果输出成Array数组，可以再findAllIn之后调用toArray方法。

  scala> val matches = numPattern.findAllIn(address).toArray
  matches: Array[String] = Array(123, 101)
  

• 如果没有匹配结果，这个方法会yield一个空的Array数组，其他方法如toList,toSeq,toVector也可用。

1.6.2 讨论

• 在字符串之后使用.r方法比创建一个正则表达式对象要更加简单。另一个方法是导入Regex类，创建正则实例，然后如下方式使用实例:

  scala> import scala.util.matching.Regex
  import scala.util.matching.Regex
  
  scala> val numPattern = new Regex("[0-9]+")
  numPattern: scala.util.matching.Regex = [0-9]+
  
  scala> val address = "123 Main Street Suite 101"
  address: java.lang.String = 123 Main Street Suite 101
  
  scala> val match1 = numPattern.findFirstIn(address)
  match1: Option[String] = Some(123)
  

• 尽管稍显繁琐，不过更加明显易懂。我发现很容易在字符串的后面忽略.r（然后花了几分钟想知道我看到的代码如何工作）

1.6.3 处理findFirstIn返回的Option

• 如在解决方案中提到过的，findFirstIn方法查找字符串中的第一个匹配然后返回一个Option[String]:

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

• 在章节20.6会详细说明Option/Some/None模式，简单的理解Option就是它是保存0个或1个值的容器。在这个findFirstIn的例子中，如果成功会返回字符串“123”如Some(123)，如果查找失败会返回None:

  scala> val address = "No address given"
  address: String = No address given
  
  scala> val match1 = numPattern.findFirstIn(address)
  match1: Option[String] = None
  

• 总结就是，一个定义的方法返回的Option[String]要不返回的是Some(String)，要么是None。正常使用Option的方式一般如下：

  • 在结果后调用getOrElse
  • 在匹配表达式中使用Option
  • 在foreach循环中使用Option

• 章节20.6会详细描述这些方法，为了方便这里会简单介绍下。

• 使用getOrElse方法,会试图“get”到结果，同时还指定当方法失败时应使用的默认值：

  scala> val result = numPattern.findFirstIn(address).getOrElse("no match")
  result: String = 123
  

• 因为Option是0个或1个元素的集合,一个有经验的Scala开发者会在这种情况下同时使用foreach循环。

  numPattern.findFirstIn(address).foreach { e =>
      // perform the next step in your algorithm,
      // operating on the value 'e'
  }
  

• 匹配表达式也为这个问题提供了一个非常可读的解决方案，更多查看20.6章。

  match1 match {
      case Some(s) => println(s"Found: $s")
      case None =>
  }
  

• 对这个方法进行总结，下面的REPL例子显示了创建正则表达式，通过findFirstIn搜索字符串，在匹配结果使用foreach循环的完整结果。

  scala> val numPattern = "[0-9]+".r
  numPattern: scala.util.matching.Regex = [0-9]+
  
  scala> val address = "123 Main Street Suite 101"
  address: String = 123 Main Street Suite 101
  
  scala> val match1 = numPattern.findFirstIn(address)
  match1: Option[String] = Some(123)
  
  scala> match1.foreach { e =>
      | println(s"Found a match: $e")
      | }
  Found a match: 123
  

• 查看更多

  The StringOps class
  The Regex class

---

1.7 字符串中的替换模式

• 问题：想要在字符串中搜索一个正则表达式模式并替换他们。

1.7.1 解决方案

• 因为字符串是不可改变的，你不能直接在字符串的基础上进行查找并替换的操作。但是你可以创建一个包含被替换内容的新字符串。有以下几种方式做到这个。

• 可以在字符串上调用replaceAll，记住将结果分配给一个新的变量。

  scala> val address = "123 Main Street".replaceAll("[0-9]", "x")
  address: java.lang.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
  

• 只替换第一个匹配模式的，使用replaceFirst方法：

  scala> val result = "123".replaceFirst("[0-9]", "x")
  result: java.lang.String = x23
  

• 也可以使用一个正则表达式的replaceFirstIn:

  scala> val regex = "H".r
  regex: scala.util.matching.Regex = H
  
  scala> val result = regex.replaceFirstIn("Hello world", "J")
  result: String = Jello world