数据类型
Byte 8位 short 16位 int 32位 Long 64位
Unit 无值（void）
Null null 或空引用
Nothing 在Scala的类层级的最低端；任何其他类型的子类型
Any 所有其他类的超类
AnyRef Scala里所有引用类(reference class)的基类
for 循环过滤
for(var x <- List if condition1;if condition2){…}
for 使用 yield
var value = for{var x <- List if condition1;if condition2…}
yield x
匿名函数 var func= (x:Int) => {x+1}
**var result = func(7)-1
函数柯里化（currying）**
将原来接受多个参数的函数变成接受一个参数的过程
def add(x:Int,y:Int)=x+y //普通的相加函数
def add(x:Int)(y:Int)=x+y //柯里化函数
add(1)(2)
柯里化实现原理：
def add(x:Int)=(y:Int)=>x+y
val result=add(1) //add函数的返回值是一个匿名函数，x被实例化，y还是这个匿名函数的参数
val sum=result(2)
闭包**
闭包是可以保存每一次函数调用状态的函数，普通函数是没有状态的。
闭包是由函数和环境组成，它使得函数内部的变量即使脱离了函数的作用范围依然可以访问到。
例子： def f(x:Int) = (i : Int) => (x+i)
val a = f(1)
val b = f(2)
println(a(10))
println(b(20))
trait 相当于java接口，但还可以定义属性和方法实现，一般情况下Scala的类只能够继承单一父类，但是如果是 Trait(特征) 的话就可以继承多个，从结果来看就是实现了多重继承
isEqual 方法没有定义方法的实现，isNotEqual定义了方法的实现。子类继承特征可以实现未被实现的方法。所以其实 Scala Trait(特征)更像 Java 的抽象类。
trait Equal {
def isEqual(x: Any): Boolean
def isNotEqual(x: Any): Boolean = !isEqual(x)
}
class Point(xc: Int, yc: Int) extends Equal {
var x: Int = xc
var y: Int = yc
def isEqual(obj: Any) =
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}
object Test {
def main(args: Array[String]) {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3,
println(p1.isNotEqual(p2))
println(p1.isNotEqual(p3))
println(p1.isNotEqual(2))
}
}
特征构造顺序
特征也可以有构造器，由字段的初始化和其他特征体中的语句构成。这些语句在任何混入该特征的对象在构造是都会被执行。
构造器的执行顺序：
调用超类的构造器；
特征构造器在超类构造器之后、类构造器之前执行；
特征由左到右被构造；
每个特征当中，父特征先被构造；
如果多个特征共有一个父特征，父特征不会被重复构造
所有特征被构造完毕，子类被构造。
object
在scala中没有静态方法和静态字段，所以在scala中可以用object来实现这些功能，直接用对象名调用的方法都是采用这种实现方式
注意：object不能提供构造器参数，也就是说object必须是无参的
object Dog{
private var age=0
def Age={
age+=1
age
}
}
class Dog{
var age1=Dog.age //Dog.age是object Dog的私有字段。
}
class
//类默认是public级别的
class Person{
var age=18 //字段必须得初始化()
def Age=age //这个是方法，没有参数可以省略()
def incremen(){this.age+=1}
}
class Student{
var age=20 //底层编译器会自动为私有的age添加get和set的公有方法,可以理解为伪public类型
private[this] var gender="male" //private[this] 只有该类的this可以使用
private var name="clow" //声明了private,底层编译器会自动为私有的name添加get和set的私有方法
//但是可以自己定义属性方法
def getName=this.name
def setName(value:String){this.name=value}
}
//构造器的使用
class Teacher {
var age: Int = _
var name: String = _ //可以预留
//重载的构造器和C#里面的public Teacher(){}类似
def this(age: Int, name: String){
this() //必须得调用一次主构造器
this.age=age
this.name=name
}
}
在scala中，类名可以和对象名为同一个名字，该对象称为该类的伴生对象，类和伴生对象可以相互访问他们的私有属性，但是
他们必须在同一个源文件内。类只会被编译，不能直接被执行，类的申明和主构造器在一起被申明，在一个类中，主构造器只有一个，
所有必须在内部申明主构造器或者是其他申明主构造器的辅构造器，主构造器会执行类定义中的所有语句。scala对每个字段都会提供
getter和setter方法，同时也可以显示的申明，但是针对val类型，只提供getter方法，默认情况下，字段为公有类型，可以在setter
方法中增加限制条件来限定变量的变化范围，在scala中方法可以访问改类所有对象的私有字段
List
基本操作：head isEmpty tail 返回一个列表，包含除了第一元素之外的其他元素
连接：::: List.:::() List.concat() -> 连接两个或多个列表
List.fill() 创建一个指定重复数量的元素列表
List.fill(number)(value) // 重复 value number次
List.tabulate() 通过给定的函数来创建列表
方法的第一个参数为元素的数量，可以是二维的，第二个参数为指定的函数，我们通过指定的函数计算结果并返回值
插入到列表中，起始值为 0
reverse 用于将列表的顺序反转
常用方法:
+:() 为列表预添加元素
::() 在列表开头添加元素
:::() 在列表开头添加指定列表的元素
:+() 复制添加元素后列表
init 返回所有元素，除了最后一个
def addString(b: StringBuilder): StringBuilder 将列表的所有元素添加到 StringBuilder
def addString(b: StringBuilder, sep: String): StringBuilder 将列表的所有元素添加到 StringBuilder，并指定分隔符
def apply(n: Int): A 通过列表索引获取元素
def contains(elem: Any): Boolean 检测列表中是否包含指定的元素
contains copyToArray distinct equals exists sum sorted min max map length lastIndexOf last
iterator
intersect 计算多个集合的交集
drop 丢弃前n个元素 dropRight 丢弃最后n个元素
take 提取列表的前n个元素 takeRight 提取列表的后n个元素
dropWhile(p: (A) => Boolean) 从左向右丢弃元素，直到条件p不成立
def endsWith[B](that: Seq[B]): Boolean 检测列表是否以指定序列结尾
def filter(p: (A) => Boolean): List[A] 输出符号指定条件的所有元素
def forall(p: (A) => Boolean): Boolean 检测所有元素
Set 没有重复的对象集合，所有的元素都是唯一
默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包。
默认引用 scala.collection.immutable.Set
连接： ++ 或者 Set.++()
交集： Set.& 或者 Set.intersect
差集 &~ diff
添加 + 移除 - contains copyToArray size
def addString(b: StringBuilder): StringBuilder 将不可变集合的所有元素添加到字符串缓冲区
def addString(b: StringBuilder, sep: String): StringBuilder 将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
def apply(elem: A) 检测集合中是否包含指定元素
drop 返回丢弃前n个元素新集合
def splitAt(n: Int): (Set[A], Set[A]) 把不可变集合拆分为两个容器，第一个由前 n 个元素组成，第二个由剩下的元素组成
Map 默认情况下 Scala 使用不可变 Map。
使用可变集合，需显式的引入 import scala.collection.mutable.Map
可同时使用可变与不可变 Map，不可变的直接使用 Map，可变的使用 mutable.Map
// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()
// Map 键值对演示
val colors = Map(“red” -> “#FF0000”, “azure” -> “#F0FFFF”)
A += (‘I’ -> 1)
基本操作：keys values isEmpty remove
合并 ++ 或 Map.++() 合并时会移除重复的 key
Map.contains 方法来查看 Map 中是否存在指定的 Key
clear clone count filterKeys
def default(key: A): B 定义 Map 的默认值，在 key 不存在时返回。
def retain(p: (A, B) => Boolean): Map.this.type 如果符合满足条件的返回 true
Tuple 元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素,将单个的值包含在圆括号中构成的
Scala 支持的元组最大长度为 22
Tuple.productIterator() 方法来迭代输出元组的所有元素
Tuple.swap 方法 交换元组的元素
Option(选项)类型用来表示一个值是可选的（有值或无值)。
Option[T] 是一个类型为 T 的可选值的容器： 如果值存在， Option[T] 就是一个 Some[T] ，如果不存在， Option[T] 就是对象 None 。
getOrElse() 方法来获取元组中存在的元素或者使用其默认的值
使用 isEmpty() 方法来检测元组中的元素是否为 None
常用方法: get map iterator isDefined foreach flatMap filterNot
orNull 如果选项包含有值返回选项值，否则返回 null
orElse 如果一个 Option 是 None ， orElse 方法会返回传名参数的值，否则，就直接返回这个 Option。
getOrElse 如果选项包含有值，返回选项值，否则返回设定的默认值
Iterator（迭代器）
next hasNext min max length size
继承
1、重写一个非抽象方法必须使用override修饰符。
2、只有主构造函数才可以往基类的构造函数里写参数。
3、在子类中重写超类的抽象方法时，你不需要使用override关键字。
正则表达式
import scala.util.matching.Regex
val pattern = “Scala”.r
val str = “Scala is Scalable and cool”
println(pattern findFirstIn str) //Some(Scala)
将匹配的文本替换为指定的关键词，可以使用 replaceFirstIn( ) 方法来替换第一个匹配项
使用 replaceAllIn( ) 方法替换所有匹配项;
异常
try{…}catch{
case ex:FileNotFoundException =>
case ex:IOException =>
}finally {…}
文件 I/O
import java.io._
val writer = new PrintWriter(new File(“test.txt” ))
writer.write(“菜鸟教程”)
writer.close()
从屏幕上读取用户输入 Console.readLine
从文件上读取内容 使用 Scala 的 Source 类及伴生对象来读取文件
import scala.io.Source