scala总结

http://www.runoob.com/scala/scala-basic-syntax.html
API文档：https://www.scala-lang.org/api/current/index.html

scala的配置

mv scala-2.11.7 scala                   # 重命名 Scala 目录
mv /download/scalapath /usr/local/share # 下载目录需要按你实际的下载路径
vi ~/.bash_profile

在文件的末尾加入:
export PATH="$PATH:/usr/local/share/scala/bin"

source ~/.bash_profile

scala
Welcome to Scala 2.11.8 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_181).
Type in expressions for evaluation. Or try :help.

添加source ~/.bash_profile到~/.zshrc文件中

注意：如果在vim /etc/profile中进行配置，可能会无效

Zero、基础语法，数据类型，访问修饰符，运算符，判断语句和循环语句
1.运行Scala文件

有HelloWorld.scala 文件

$ scalac HelloWorld.scala
$ scala HelloWorld.scala

2.scala特性
（纯）面向对象特性
函数式编程
静态类型
扩展性
并发行

3.

一、scala之方法与函数的定义
1.方法
def funcName([参数列表]) :[return type] = {
funcBody
return [expr]
}

例子：
在object add里面定义addInt方法

object add{
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

2.函数
val funcName=([参数列表])=>{
funcBody
return [expr]
}

例子：

object multiplier{
        var factor = 3
        val multiplier = (i:Int,j:Int)=>{
	        i*j
	    }

        def main(arg:Array[String]){
                println(multiplier(5,6))
        }
}

二、scala之可变字符串与不可变字符串

object testString{
	val greeting:String = "Hello,World!" //不可变
	val buf = new StringBuilder   //可变
	buf += 'a'
	buf ++= "bcdef"

	def main(args:Array[String]){
		println(greeting)
		println("buf is" + buf.toString)
	}
}

三、数组的定义

一维数组：

var 数组名:Array[String] = new Array[String](数组长度)

或

var 数组名 = new Array[String](数组长度)

z(0) = "Runoob"; z(1) = "Baidu"; z(4/2) = "Google"

也可以下列方式定义

var z = Array("Runoob", "Baidu", "Google")

多维数组：

var myMatrix = ofDim[Int](行数,列数)  //定义一个3*3的空数组

四、列表List
参考：http://www.runoob.com/scala/scala-lists.html

List的特征是其元素以线性方式存储，集合中可以存放重复对象。

//一维列表
// 字符串列表
val site: List[String] = List("Runoob", "Google", "Baidu")

// 整型列表
val nums: List[Int] = List(1, 2, 3, 4)

// 空列表
val empty: List[Nothing] = List()


// 二维列表
val dim: List[List[Int]] =
   List(
      List(1, 0, 0),
      List(0, 1, 0),
      List(0, 0, 1)
   )

//构造列表的两个基本单位是 Nil 和 ::
//Nil 也可以表示为一个空列表。

// 字符串列表
val site = "Runoob" :: ("Google" :: ("Baidu" :: Nil))

// 整型列表
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))

// 空列表
val empty = Nil

// 二维列表
val dim = (1 :: (0 :: (0 :: Nil))) ::
          (0 :: (1 :: (0 :: Nil))) ::
          (0 :: (0 :: (1 :: Nil))) :: Nil

五、集合Set
http://www.runoob.com/scala/scala-sets.html

Set是最简单的一种集合。集合中的对象不按特定的方式排序，并且没有重复对象。

Scala 集合分为可变的和不可变的集合。
默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包；默认引用 scala.collection.immutable.Set，为不可变集合。

不可变集合：

val set = Set(1,2,3)
println(set.getClass.getName) // 

println(set.exists(_ % 2 == 0)) //true
println(set.drop(1)) //Set(2,3)

可变集合：

import scala.collection.mutable.Set // 可以在任何地方引入 可变集合

val mutableSet = Set(1,2,3)
println(mutableSet.getClass.getName) // scala.collection.mutable.HashSet

mutableSet.add(4)
mutableSet.remove(1)
mutableSet += 5
mutableSet -= 2

println(mutableSet) // Set(5, 3, 4)

val another = mutableSet.toSet
println(another.getClass.getName) // scala.collection.immutable.Set

六、映射Map
http://www.runoob.com/scala/scala-maps.html

Map(映射)是一种可迭代的键值对（key/value）结构，所有的值都可以通过键来获取。Map 中的键都是唯一的，Map 也叫哈希表（Hash tables）。

Map 有两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以。默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合，你需要显式的引入 import scala.collection.mutable.Map类。

在 Scala中你可以同时使用可变与不可变 Map：不可变的直接使用 Map，可变的使用 mutable.Map。

//不可变map

// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()

// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

//定义 Map 时，需要为键值对定义类型。如果需要添加 key-value 对，可以使用 + 号，如下所示：

A += ('I' -> 1)

//三个常用方法
keys	 返回 Map 所有的键(key)
values	 返回 Map 所有的值(value)
isEmpty  在 Map 为空时返回true

//通过 foreach 循环输出 Map 中的 keys 和 values

object Test {
   def main(args: Array[String]) {
      val sites = Map("runoob" -> "http://www.runoob.com",
                       "baidu" -> "http://www.baidu.com",
                       "taobao" -> "http://www.taobao.com")

      sites.keys.foreach{ i =>  
                           print( "Key = " + i )
                           println(" Value = " + sites(i) )}
	  println(sites.contains("runood"))  //true；查看是否包含某个键值

   }
}

七、元组Tuple
http://www.runoob.com/scala/scala-tuples.html

与列表一样，元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的:

val t = (1, 3.14, "Fred")

val t1 = new Tuple3(1, 3.14, "Fred")
val t2 = new Tuple2(1,"Hello")

println(t._2)  //打印第二个元素，3.14

//迭代元组,使用Tuple.productIterator()方法来迭代输出元组的所有元素：

object Test {
   def main(args: Array[String]) {
      val t = (4,3,2,1)
      
      t.productIterator.foreach{ i =>
		      println("Value = " + i )}
   }
}

八、选项Option
http://www.runoob.com/scala/scala-options.html

Scala Option(选项)类型用来表示一个值是可选的（有值或无值)。
Option[T] 是一个类型为 T 的可选值的容器： 如果值存在， Option[T] 就是一个 Some[T] ，如果不存在， Option[T] 就是对象 None 。

val myMap: Map[String, String] = Map("key1" -> "value")
val value1: Option[String] = myMap.get("key1")
val value2: Option[String] = myMap.get("key2")
 
println(value1) // Some("value1")
println(value2) // None

object Test {
   def main(args: Array[String]) {
      val sites = Map("runoob" -> "www.runoob.com", "google" -> "www.google.com")
      
      println("sites.get( \"runoob\" ) : " +  sites.get( "runoob" )) // Some(www.runoob.com)
      println("sites.get( \"baidu\" ) : " +  sites.get( "baidu" ))  //  None
   }
}

九、Scala Iterator（迭代器）
http://www.runoob.com/scala/scala-iterators.html

Scala Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法。

迭代器 it 的两个基本操作是 next 和 hasNext。
调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。
调用 it.hasNext() 用于检测集合中是否还有元素。

object Test {
   def main(args: Array[String]) {
      val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
      
      while (it.hasNext){
         println(it.next())
      }
   }
}

十、类和对象
http://www.runoob.com/scala/scala-classes-objects.html

使用 new 关键字来创建类的对象，Scala中的类不声明为public，一个Scala源文件中可以有多个类；可以使用 new 来实例化类，并访问类中的方法和变量。

以下实例的类定义了两个变量 x 和 y ，一个方法：move，方法没有返回值；Scala 的类定义可以有参数，称为类参数，如下例的 xc, yc，类参数在整个类中都可以访问。

import java.io._

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("x 的坐标点: " + x);
      println ("y 的坐标点: " + y);
   }
}

object Test {
   def main(args: Array[String]) {
      val pt = new Point(10, 20);

      // 移到一个新的位置
      pt.move(10, 10);
   }
}

执行以上代码，输出结果为：

$ scalac Test.scala 
$ scala Test
x 的坐标点: 20
y 的坐标点: 30

十一、Scala Trait(特征)

Scala Trait(特征) 相当于 Java 的接口，实际上它比接口还功能强大；

与接口不同的是，它还可以定义属性和方法的实现；

一般情况下Scala的一个类只能够继承单一父类，但是如果是 Trait(特征) 的话就可以被继承多个不同的接口，从结果来看就是实现了多重继承；

Trait(特征) 定义的方式与类类似，但它使用的关键字是 trait。

十二、scala模式匹配

一个模式匹配包含了一系列备选项，每个都开始于关键字 case；

每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式；

match 对应 Java 里的 switch，但是写在选择器表达式之后。即： 选择器 match {备选项}，match 表达式通过以代码编写的先后次序尝试每个模式来完成计算，只要发现有一个匹配的case，剩下的case不会继续匹配。

object Test {
   def main(args: Array[String]) {
      println(matchTest("two"))
      println(matchTest("test"))
      println(matchTest(1))
      println(matchTest(6))

   }
   def matchTest(x: Any): Any = x match {
      case 1 => "one"
      case "two" => 2
      case y: Int => "scala.Int"
      case _ => "many"
   }
}
执行以上代码，输出结果为：

$ scalac Test.scala 
$ scala Test
2
many
one
scala.Int

使用了case关键字的类定义就是就是样例类(case classes)，样例类是种特殊的类，经过优化以用于模式匹配。

十三、Scala 正则表达式
http://www.runoob.com/scala/scala-regular-expressions.html

Scala 通过 scala.util.matching 包中的 Regex 类来支持正则表达式；

import scala.util.matching.Regex

object Test {
   def main(args: Array[String]) {
      val pattern = new Regex("(S|s)cala")  // 首字母可以是大写 S 或小写 s
      val str = "Scala is scalable and cool"
      
      println((pattern findAllIn str).mkString(","))   // 使用逗号 , 连接返回结果
   }
}

十四、Scala 异常处理
Scala 的异常处理和其它语言比如 Java 类似。
Scala 的方法可以通过抛出异常的方法的方式来终止相关代码的运行，不必通过返回值。

Scala 抛出异常的方法和 Java一样，使用 throw 方法；

异常捕捉的机制与其他语言中一样，如果有异常发生，catch字句是按次序捕捉的。因此，在catch字句中，越具体的异常越要靠前，越普遍的异常越靠后。 如果抛出的异常不在catch字句中，该异常则无法处理，会被升级到调用者处，捕捉异常的catch子句，语法与其他语言中不太一样。在Scala里，借用了模式匹配的思想来做异常的匹配，因此，在catch的代码里，是一系列case字句；

finally 语句用于执行不管是正常处理还是有异常发生时都需要执行的步骤。

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Test {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException => {
            println("Missing file exception")
         }
         case ex: IOException => {
            println("IO Exception")
         }
      } finally {
         println("Exiting finally...")
      }
   }
}

十五、Scala 提取器(Extractor)
http://www.runoob.com/scala/scala-extractors.html

提取器是从传递给它的对象中提取出构造该对象的参数。

Scala 标准库包含了一些预定义的提取器，我们会大致的了解一下它们。

Scala 提取器是一个带有unapply方法的对象；unapply方法算是apply方法的反向操作：unapply接受一个对象，然后从对象中提取值，提取的值通常是用来构造该对象的值。

十六、Scala 文件 I/O
http://www.runoob.com/scala/scala-file-io.html

Scala 进行文件写操作，直接用的都是 java中 的 I/O 类 （java.io.File)

//写入文件
import java.io._

object Test {
   def main(args: Array[String]) {
      val writer = new PrintWriter(new File("test.txt" )
      writer.write("菜鸟教程")
      writer.close()
   }
}
执行以上代码，会在你的当前目录下生产一个 test.txt 文件，文件内容为"菜鸟教程":

$ scalac Test.scala 
$ scala Test
$ cat test.txt 
菜鸟教程

从屏幕上读取用户输入

import scala.io._
object Test {
   def main(args: Array[String]) {
      print("请输入菜鸟教程官网 : " )
      
      val line = StdIn.readLine()   //读取屏幕输入

      println("谢谢，你输入的是: " + line)
   }
}

从文件上读取内容：使用 Scala 的 Source 类及伴生对象来读取文件

import scala.io.Source

object Test {
   def main(args: Array[String]) {
      println("文件内容为:" )

	  //从 "test.txt"(之前已创建过) 文件中读取内容
      Source.fromFile("test.txt" ).foreach{ 
         print 
      }

   }
}
执行以上代码，输出结果为:

$ scalac Test.scala 
$ scala Test
文件内容为:
菜鸟教程