scala特性  面向对象特性、函数式编程、静态类型、扩展性和并发
表达式     scala中一切皆为表达式，理解表达式是理解其语法的前提
方法与函数  两者的区别和转换
模式匹配    常用的几种模式 
trait 
集合操作  
读取数据源   通过Source类读取数据 
隐式转换 隐式参数 
异常处理 
类型层级 
基本数值类型转换 
正则匹配 




一切皆为表达式  
表达式语法 对函数式编程友好 可读性好
Unit 类似 void  忽略返回值

方法与函数
方法在类中定义 ，方法是类的一部分
函数则是一个完整的对象，可以赋给一个变量

方法转函数
隐式转化  
val f2 = f1 _

显式转化
val f2: (Int) => Int = f1


模式匹配 
常量模式 变量模式 通配符模式
模式守卫
def patternShow(x : Any) = x match {
  //模式守卫
  case x if(x == 3) => "守卫"
  //通配符模式
　case _ => "通配符"
}

Option
val x:Option[Int] = Some(5)
子类有Some和None
val map = Map (("a",1),("b",2))
//get 返回类型 Option[Int]
map.get("b") match {
  case some(x) => println(x)
  case None => println("不存在")
}

Trait(特质) 相当于 Java 的接口  还可以定义属性和方法的实现
类只能单继承 ，可以使用with关键字混入多个 Trait(特质) 

集合操作
转换操作 transformation 和 行动操作 action

case class Pet(name: String, age: Int)
val pets = List(Pet("cat",3),Pet("dog",5),Pet("tiger",7))

pets.maxBy(pet => pet.age)

pets.maxBy(_.age)
Pet = Pet(tiger,7)
pets.minBy(_.age)
Pet = Pet(cat,3)

pets.filter(_.age>1)

val list1 = List(1,2)
val list2 = List(3,4,5)
val list3 = List(list1,list2)
List[List[Int]] = List(List(1, 2), List(3, 4, 5))

list3.flatten
List[Int] = List(1, 2, 3, 4, 5)

List(1,2,3).map(_+1)
List[Int] = List(2, 3, 4)

val list1 = List(1,2,3,4)
val list2 = List(3,4,5,6)
list1.diff(list2)
List[Int] = List(1, 2)
list2.diff(list1)
List[Int] = List(5, 6)

list1.intersect(list2)
list1.union(list2)
list1.union(list2).distinct


flatMap
先map 然后flatten

List('a','b','c').flatMap( ch => List(ch,ch.toUpper))
List[Char] = List(a, A, b, B, c, C)

val list1 = List(1,2,3,4,5)
list1.forall(_<9)
list1.forall(_>3)
list1.exists(_>3)



import scala.io.Source
val source = Source.fromString("test")
source.foreach(println)
val fileContent = io.Source.fromFile("myfile.txt").mkString
val fileLines = io.Source.fromFile("myfile.txt").getLines.toList
val url:String = "http://codefun007.xyz/pv.htm"
val source = Source.fromURL(url,"UTF-8")
val result = source.mkString
    

读取文件所有行 去重  按首字符排序，首字符相同按长度排序 打印结果
io.Source.fromFile("myfile.txt", "UTF-8").getLines().toList.distinct.sortBy(s => (s.charAt(0), s.length)).foreach(println)



java和scala集合之间的转换
scala.collection.JavaConversions

import scala.collection.JavaConversions.bufferAsJavaList
scala.collection.mutable.Buffer => java.util.List
java.util.List也可以转换成scala.collection.mutable.Buffer。

import scala.collection.JavaConversions.asScalaBuffer
java.util.List => scala.collection.mutable.Buffer

import scala.collection.JavaConversions._


scala.collection.Iterable <=> java.lang.Iterable
scala.collection.Iterable <=> java.util.Collection
scala.collection.Iterator <=> java.util.{ Iterator, Enumeration }
scala.collection.mutable.Buffer <=> java.util.List
scala.collection.mutable.Set <=> java.util.Set
scala.collection.mutable.Map <=> java.util.{ Map, Dictionary }
scala.collection.concurrent.Map <=> java.util.concurrent.ConcurrentMap

scala.collection.Seq         => java.util.List
scala.collection.mutable.Seq => java.util.List
scala.collection.Set         => java.util.Set
scala.collection.Map         => java.util.Map
java.util.Properties   => scala.collection.mutable.Map[String, String]


隐式参数
implicit
调用该函数或方法时，在变量作用域中找到一个与指定类型相匹配的使用implicit修饰的对象，即隐式值，注入到函数参数中 
隐式参数 根据类型匹配 ，因此作用域中不能同时出现两个相同类型的隐式变量


异常处理
try catch finally  加 模式匹配

try{
...
}catch{
  case e:ExceptionA => ...
  case e:ExceptionB => ...
  case _ => ...
}finally{
  ...
}

没有checked异常
throw表达式的返回值为Nothing
Nothing类型是所有类型的子类型

顶级类 Any   包含两个子类 AnyVal 和 AnyRef
AnyVal 所有值类型的父类，其中包含一个特殊的值Unit
AnyRef 所有引用类型的父类
Null 所有引用类型的子类型，可以赋给任何引用类型变量
Nothing 所有类型的子类


第三方java类库 使用 
参数 手动包装成java类型

import java.lang.{Long => JLong, Double => JDouble}
queryRunner.update(conn, sql, new JLong(1L), new JDouble(2.2))

val str = "Scala is Scalable and cool"

val pattern = "Scala".r
println(pattern findFirstIn str)
Some(Scala)

 
val pattern = new Regex("(S|s)cala") 
println((pattern findAllIn str).mkString(","))  
Scala,Scala

println(pattern replaceFirstIn(str, "Java"))
Java is Scalable and cool