scala基础（二）

1.match语句

val colorNum = 1
val colorStr = colorNum match{
	case 1 => "red"
	case 2 => "green"
	case 3 => "yellow"
	case _ => "Not allowed"//_代表除上面列举的其他情况

val colorNum = 4
val colorStr = colorNum match{
	case 1 => "red"
	case 2 => "green"
	case 3 => "yellow"
	case unexpected => unexpected + "is Not allowed" //可以使用变量
}

//可以对表达式类型进行匹配
for(elem <- List(9,12.3,"Spark","Hadoop","Hello")){
	val str = elem match{
		case i : Int => i +"is an int value"
		case d : Double => d + "is a double value"
		case "Spark" => "Spark is found"
		case s : String => s + "is a string value"
		case _ => "This is an unexpected value"
	}
	println(str)
}

 for (elem <- List(1,2,3,4)){
	elem match{
		case _ if(elem % 2 == 0) => println(elem + "is even.")
		case _ => println(elem + "is odd.")
	}
}

case class Car(brand: String , price: Int)
val myBYDCar = new Car("BYD",89000)
val myBMWCar = new Car("BMW",120000)
val myBenzCar = new Car("Benz",1500000)
for (car <- List(myBYDCar,myBMWCar,myBenzCar)){
	car match{
		case Car("BYD",89000) => println("hello,BYD!")
		case Car("BMW",120000) => println("hello,BMW!")
		case Car(brand,price) => println("Brand": + brand +", Price:" +price )
	}
}

总结来说，match语句的case后面可以是常见的数据类型，可以是对表达式进行类型匹配，可以是判断表达式，可以是变量，还可以是case类。
option类型：表示可能存在也可能不存在的值。


函数式编程
函数的一般形式：

def 方法名(参数列表):结果类型 = {方法体}

函数也有“类型”和“值”的概念。

def counter (value : Int): Int = { value+=1 }
// 类型：(Int) => Int 即(参数类型) => 函数返回值类型，当有多个参数时，类型用逗号隔开
// 值： (value) => {value += 1} 即 (参数名) => {函数体} 

val num: Int = 5 //普通变量声明
val counter: Int => Int = {(value) => value += 1} //定义函数
// 两个进行对比可以发现，函数定义就是 val/var 变量名: 类型名 => 值

匿名函数：lamda表达式：(参数) => 表达式

(num: Int) => num*2
val myFunc: Int => Int = (num: Int) => num*2
//因为scala具有类型推断机制，所以可以省去类型，但是num后面的类型如果也省去则无法推断，所以要给出能够推断出类型的最少信息。

闭包

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。

var b = 3
val add = (a: Int) => a + b 
println(add(1)) //4
println(add(2)) //5
//函数每次调用都会创建新的闭包

占位符
当参数在函数字面量内仅出现一次，scala可以用占位符“_”替代参数。
针对集合的操作

• 遍历操作

//方法一：
val list = List(1,2,3,4,5)
for (elem <- list) println(elem)
//方法二：
val list = List(1,2,3,4,5)
list.foreach(elem => println(elem))
//等价于 list.foreach(println)

• map操作：将集合中的每个元素映射到另一个元素，并产生结果集合。

val books = List("hadoop","hive","hdfs")
books.map(s => s.toUpperCase)

• flatMap操作:是将map映射成的集合，拍扁放到一个集合里去。
  注意两者的区别。
• filter操作：将集合中满足某个条件的元素抽取出来形成新的集合。

val name = Map(1->"Tom",2->"Bob",3->"Alice")
val Tom = name filter(kv=>kv._2 contains "Tom")

• reduce和fold操作：
• reduceLeft：从集合左侧开始将集合进行约简
• reduceRight：从集合右侧开始将集合进行约简
  -默认的reduce是 reduceLeft
• fold操作是由一个初始的值开始，和reduce一样进行约简操作。