complete scala notes

Author: zhangjunhd

2013-12-20-scala-note5-class.md

@@ -0,0 +1,42 @@
+## Scala笔记6-枚举
+
+使用枚举
+
+```scala
+object TrafficLightColor extends Enumeration {
+  val Red, Yellow, Green = Value
+}
+```
+
+可以指定ID和name:
+
+```scala
+object TrafficLightColor extends Enumeration {
+  val Red = Value(0, "Stop") // Red.toString() to get "Stop"
+  val Yellow = Value(10) // Name "Yellow"
+  val Green = Value("Go") // ID 11
+}
+```
+
+枚举的类型是TrafficLightColor.Value 而不是 TrafficLightColor 可以增加一个`类型别名`:
+
+```scala
+object TrafficLightColor extends Enumeration {
+  type TrafficLightColor = Value
+  val Red = Value(0, "Stop")
+  val Yellow = Value(10)
+  val Green = Value("Go")
+}
+
+object Run extends App {
+  import TrafficLightColor._
+  def doWhat(color: TrafficLightColor) = {
+      if (color == Red) "stop"
+      else if (color == Yellow) "hurry up" else "go"
+  }
+
+  // load Red
+  TrafficLightColor(0) // Calls Enumeration.apply
+  TrafficLightColor.withName("Red")
+}
+```

2013-12-21-scala-note6-enumeration.md

@@ -0,0 +1,156 @@
+## Scala笔记7-文件读写与序列化
+
+读文件
+
+```scala
+object Run extends App {
+  import scala.io.Source
+  val source = Source.fromFile("myfile.txt", "UTF-8")
+  // The first argument can be a string or a java.io.File
+  // You can omit the encoding if you know that the file uses the default platform encoding
+
+  for (c <- source) println(c) // c is a Char
+
+  val lineIterator = source.getLines
+  for (l <- lineIterator) println(l) // l is a String
+
+  val lines = source.getLines.toArray // the whole content as an Array
+
+  val contents = source.mkString // the whole content as a String
+}
+```
+
+缓存读，想查看某个字符，但不想一下子处理掉它
+
+```scala
+object Run extends App {
+  import scala.io.Source
+  val source = Source.fromFile("myfile.txt", "UTF-8")
+
+  val iter = source.buffered
+  while (iter.hasNext) {
+      if (iter.head == 'B') println(iter.next)
+      else iter.next
+  }
+
+  source.close()
+}
+```
+
+读文件并分成一个个单词，转换成数字
+
+```scala
+object Run extends App {
+  import scala.io.Source
+  val source = Source.fromFile("myfile.txt", "UTF-8")
+
+  val tokens = source.mkString.split("\\s+")
+
+  val numbers = for (w <- tokens) yield w.toDouble
+  val numbers2 = tokens.map(_.toDouble)
+}
+```
+
+从控制台读取数字
+
+```scala
+object Run extends App {
+  print("How old are you? ")
+  val age = readInt() // Or use readDouble or readLong
+}
+```
+
+从其他源读取
+
+```scala
+object Run extends App {
+  import scala.io.Source
+  val source1 = Source.fromURL("http://horstmann.com", "UTF-8")
+  val source2 = Source.fromString("Hello, World!") // Reads from the given string—useful for debugging
+  val source3 = Source.stdin // Reads from standard input
+}
+```
+
+读取二进制文件
+
+```scala
+import java.io.File
+import java.io.FileInputStream
+import scala.io.Source
+
+object Run extends App {
+  val file = new File("myfile")
+  val in = new FileInputStream(file)
+  val bytes = new Array[Byte](file.length.toInt)
+  in.read(bytes)
+  in.close()
+}
+```
+
+写入文本文件
+
+```scala
+import java.io.PrintWriter
+
+object Run extends App {
+  val out = new PrintWriter("numbers.txt")
+  for (i <- 1 to 100) out.println(i)
+  out.close()
+
+  // use string format
+  val quantity = 100
+  val price = .1
+  out.print("%6d %10.2f".format(quantity, price))
+}
+```
+
+访问目录
+
+遍历所有子目录
+
+```scala
+object Run extends App {
+  import java.io.File
+  def subdirs(dir: File): Iterator[File] = {
+      val children = dir.listFiles.filter(_.isDirectory)
+      children.toIterator ++ children.toIterator.flatMap(subdirs _)
+  }
+}
+```
+
+java.nio.file.Files类的walkFileTree方法
+
+```scala
+object Run extends App {
+  import java.nio.file._
+  implicit def makeFileVisitor(f: (Path) => Unit) = new SimpleFileVisitor[Path] {
+      override def visitFile(p: Path, attrs: attribute.BasicFileAttributes) = {
+          f(p)
+          FileVisitResult.CONTINUE
+      }
+  }
+
+  // Print all subdirectories with the call
+  import java.io.File
+  val dir:File = new File("/tmp")
+  // public static Path walkFileTree(Path start, FileVisitor<? super Path> visitor)
+  // Here implicit conversion adapts a function to the interface(FileVisitor)
+  Files.walkFileTree(dir.toPath, (f: Path) => println(f))
+}
+```
+
+序列化
+
+```scala
+@SerialVersionUID(42L) class Person extends Serializable
+
+object Run extends App {
+  val fred = new Person
+  import java.io._
+  val out = new ObjectOutputStream(new FileOutputStream("/tmp/test.obj"))
+  out.writeObject(fred)
+  out.close()
+  val in = new ObjectInputStream(new FileInputStream("/tmp/test.obj"))
+  val savedFred = in.readObject().asInstanceOf[Person]
+}
+```

2013-12-22-scala-note7-file.md

@@ -0,0 +1,62 @@
+## Scala笔记8-进程控制
+
+sys.process包包含了一个从字符串到ProcessBuilder对象的隐式转换。！操作符执行的就是这个ProcessBuilder对象。
+
+```scala
+object Run extends App {
+  import sys.process._
+  val result = "ls -al .." ! // result is 0 if command is done succeed
+
+  // pipe the output of one program into the input of another, using the #| operator
+  "ls -al .." #| "grep z" !
+
+  // pipe the output of one program into the input of another, using the #| operator
+  import java.io.File
+  "ls -al .." #> new File("output.txt") !
+
+  // To append to a file, use #>> instead:
+  "ls -al .." #>> new File("output.txt") !
+
+  // To redirect input from a file, use #<:
+  "grep sec" #< new File("output.txt") !
+
+  // You can also redirect input from a URL:
+  import java.net.URL
+  "grep Scala" #< new URL("http://horstmann.com/index.html") !
+}
+```
+
+如果需要在不同的目录下运行进程，或者使用不同的环境变量，用Process对象的apply方法来构造ProcessBuilder，给出命令和起始目录，以及一串(key, value)对来设置环境变量:
+
+```scala
+import java.io.File
+
+object Run extends App {
+  import sys.process._
+  val cmd = "ls -al"
+  val dirName = "/tmp"
+  val p = Process(cmd, new File(dirName), ("LANG", "en_US"))
+
+  "echo 42" #| p !
+}
+```
+
+重定向标准输出和错误输出流:
+
+```scala
+import sys.process._
+
+object Run extends App {
+  val logger = ProcessLogger(
+    (o: String) => println("out " + o),
+    (e: String) => println("err " + e))
+  "ls -al" ! logger
+
+  val out = new StringBuilder
+  val err = new StringBuilder
+  val strlogger = ProcessLogger(
+    (o: String) => out.append(o),
+    (e: String) => err.append(e))
+  "ls -al" ! strlogger
+}
+```

2013-12-23-scala-note8-process.md

@@ -0,0 +1,133 @@
+## Scala笔记9-正则表达式与文法解析
+### 正则表达式
+要构造一个Regex对象，用String类的r方法即可。如果正则表达式包含反斜杠或引号，最好使用"""..."""：
+
+```scala
+object Run extends App {
+  val numPattern = "[0-9]+".r
+
+  val wsnumwsPattern = """\s+[0-9]+\s+""".r // use the “raw” string syntax
+
+  for (matchString <- numPattern.findAllIn("99 bottles, 98 bottles"))
+    println(matchString) // 99
+                        //98
+
+  val matches = numPattern.findAllIn("99 bottles, 98 bottles").toArray // Array(99, 98)
+
+  val m0 = numPattern.findFirstIn("99 bottles, 98 bottles") // Some(99)
+  val m1 = wsnumwsPattern.findFirstIn("99 bottles, 98 bottles") // Some(98)
+
+  numPattern.findPrefixOf("99 bottles, 98 bottles") // Some(99)
+  wsnumwsPattern.findPrefixOf("99 bottles, 98 bottles") // None
+
+  numPattern.replaceFirstIn("99 bottles, 98 bottles", "XX") // "XX bottles, 98 bottles"
+  numPattern.replaceAllIn("99 bottles, 98 bottles", "XX") // "XX bottles, XX bottles"
+}
+```
+
+### 正则表达式组
+在你想要提取的子表达式两侧加上圆括号:
+
+```scala
+object Run extends App {
+  val numitemPattern = "([0-9]+) ([a-z]+)".r
+
+  val numitemPattern(num, item) = "99 bottles" // Sets num to "99", item to "bottles"
+
+  for (numitemPattern(num, item) <- numitemPattern.findAllIn("99 bottles, 98 bottles"))
+    printf("%d,%s\n", num.toInt, item) // 99,bottles
+        								  //98,bottles
+}
+```
+
+### 文法
+所谓`文法`(grammar)，指的是一组用于产出所有遵循某个特定结构的字符串的规则。文法通常以一种被称为`巴斯克范式`(BNF)的表示法编写。
+
+    digit ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
+    number::= digit | digit number
+    op    ::= "+" | "-" | "*"
+    expr  ::= number | expr op expr | "(" expr ")"
+
+更高效的做法是在解析开始之前就收集好数字，这个单独的步骤叫做`词法分析`(lexical analysis)。`词法分析器`(lexer)会丢弃掉空白和注释并形成`词法单元`(token)——标识符、数字或符号。
+
+在我们的表达式中，词法单元为number和符号+-*()。op和expr不是词法单元。它们是结构化的元素，是文法的作者创造出来的，目的是产出正确的词法单元序列。这样的符号被称为`非终结符号`。其中有个非终结符号位于层级的顶端，在我们的示例当中就是expr。这个非终结符号被称为`起始符号`，要产出正确格式的字符串，你应该从起始符号开始，持续应用文法规则，直到所有的非终结符号都被替换掉，只剩下词法单元:
+
+    expr -> expr op expr -> number op expr -> number "+" expr -> number "+" number
+
+表明3+4是个合法的表达式。
+
+最常用的“扩展巴斯克范式”，或称EBNF，允许给出可选元素和重复。将使用正则操作符?*+来分别表示0个或1个、0个或更多、1个或更多。
+
+### 组合解析器操作
+为了使用scala解析库，我们需要提供一个扩展自Parsers特质的类并定义那些由基本操作组合起来的解析操作，基本操作包括:
+
+* 匹配一个词法单元
+* 在两个操作之间做选择(|)
+* 依次执行两个操作(~)
+* 重复一个操作(rep)
+* 可选择地执行一个操作(opt)
+
+```scala
+import scala.util.parsing.combinator.RegexParsers
+
+class ExprParser extends RegexParsers {
+  val number = "[0-9]".r
+
+  def expr: Parser[Any] = term ~ opt(("+" | "-") ~ expr)
+  def term: Parser[Any] = factor ~ rep("*" ~ factor)
+  def factor: Parser[Any] = number | "(" ~ expr ~ ")"
+}
+
+object Main extends App {
+  val parser = new ExprParser
+  val result = parser.parseAll(parser.expr, "3-4*5")
+  if (result.successful) println(result.get)
+}
+```
+
+上述程序的输出`((3~List())~Some((-~((4~List((*~5)))~None))))`，解读这个结果:
+
+* 字符串字面量和正则表达式返回String值
+* p ~ q返回~样例类的一个实例
+* opt(p)返回一个Option，要么是Some(...)，要么是None
+* rep(p)返回一个List
+
+### 解析器结果变换
+与其让解析器构建出一整套由~、可选项和列表构成的复杂结构，不如将中间输出变换成有用的形式。
+
+```scala
+import scala.util.parsing.combinator.RegexParsers
+
+class ExprParser extends RegexParsers {
+  val number = "[0-9]".r
+
+  def expr: Parser[Int] = term ~ opt(("+" | "-") ~ expr) ^^ {
+    case t ~ None => t
+    case t ~ Some("+" ~ e) => t + e
+    case t ~ Some("-" ~ e) => t - e
+  }
+  def term: Parser[Int] = factor ~ rep("*" ~ factor) ^^ {
+    case f ~ r => f * r.map(_._2).product
+  }
+  def factor: Parser[Int] = number ^^ {_.toInt}| "(" ~ expr ~ ")" ^^ {
+    case _ ~ e ~ _ => e
+  }
+}
+
+object Main extends App {
+  val parser = new ExprParser
+  val result = parser.parseAll(parser.expr, "3-4*5")
+  if (result.successful) println(result.get) //-17
+}
+```
+
+* ^^符号并没有什么特别的意义，它只是恰巧比~优先级低，但又比|优先级高
+* 对于解析来说，词法单元是必须的，但在匹配之后它们通常可以被丢弃。~>和<~操作符可以用来匹配并丢弃词法单元。
+
+```scala
+def term: Parser[Int] = factor ~ rep("*" ~> factor) ^^ {
+  case f ~ r => f * r.product
+}
+
+def factor: Parser[Int] = number ^^ {_.toInt}| "(" ~> expr <~ ")"
+```