2021-02-16 大数据课程笔记 day27

@R星校长

Scala 第一天【Scala内容】

主要内容

1. Scala介绍
2. Scala安装使用
3. Scala数据对象
4. Scala类和对象
5. Scala流程控制
6. Scala方法与函数
7. Scala字符串
8. Scala集合

学习目标

第一节 Scala介绍

1. 为什么学习Scala语言
   Scala 是基于JVM 的语言，与 java 语言类似，Java 语言是基于 JVM 的面向对象的语言。Scala 也是基于 JVM ，同时支持面向对象和面向函数的编程语言。这里学习 Scala 语言的原因是后期我们会学习一个优秀的计算框架 Spark，Spark 底层源码的编写语言就有 Scala，同时工作中很有可能使用Scala语言进行 Spark 的开发。Spark1.6 版本中底层基于 Scala 语言的版本是 Scala2.10 版本。Spark2.0 版本以上底层基于的Scala语言版本是 Scala2.11 版本。
2. Scala 官网 6 大特性
   1).Java 和 scala 可以混编
   2).类型推测(自动推测类型)
   3).并发和分布式（Actor）
   4).特质，特征(类似java中interfaces 和 abstract结合)
   5).模式匹配（类似java switch）
   6).高阶函数

第二节 Scala 安装使用

1. windows 安装,配置环境变量

• 官网下载 scala2.11：https://www.scala-lang.org/download/all.html

• 下载好后安装。双击 msi 包安装,记住安装的路径。

• 配置环境变量（和配置 jdk 一样）

  • 新建 SCALA_HOME
    注意：这里建议将 Scala 安装到纯英文没有空格和特殊符号的路径下。避免后期使用 Scala 版本出现问题。

  • 上个步骤完成后，编辑Path变量，在后面追加如下：
    %SCALA_HOME%\bin
    

• 打开 cmd , 输入：scala - version 看是否显示版本号，确定是否安装成功

2. eclipse 配置 scala 插件

• 下载插件（一定要对应 eclipse 版本下载）
  http://scala-ide.org/download/prev-stable.html
  

• 下载好zip包后，解压如下：

• 将 features 和 plugins 两个文件夹拷贝到 eclipse 安装目录中的 “dropins/scala” 目录下。进入 dropins，新建 scala 文件夹，将两个文件夹拷贝到 “dropins/scala” 下

  注意：以上这种在 eclipse 中的配置方式不建议大家配置，因为 Scala 官网中仅仅针对部分版本的 eclipse 进行过配置。所以有可能找不到对应的版本。

3. scala ide
     Scala IDE 就是 Scala 官网中针对eclipse稳定版本配置好了Scala的插件。Scala IDE 就是配置好Scala插件的eclipse。如果使用eclipse开发Scala建议使用这种方式。下载网址：http://scala-ide.org/download/sdk.html 。
4. idea 中配置 scala 插件

• 打开 idea , close 项目后，点击 Configure->Plugins
• 搜索 scala，点击 Install 安装
  注意：这里安装了 Scala，所以这里显示 “Uninstall”。
• 设置 jdk，打开 Project Structure，点击 new 选择安装好的 jdk 路径
• 创建 scala 项目，配置 scala sdk (Software Development Kit)
  点击第三步，弹出选择 SDK , 点击 Browse 选择本地安装的 Scala 目录。选择 system 对应的 Scala 版本即可。

第三节 Scala基础

1. 数据类型
2. 变量和常量的声明

• 定义变量或者常量的时候，也可以写上返回的类型，一般省略，如：val a:Int = 10
• 常量不可再赋值

1.	 /**
2.	  * 定义变量和常量
3.	  * 变量 :用 var 定义 ，可修改 
4.	  * 常量 :用 val 定义，不可修改
5.	  */
6.	  var name = "zhangsan"
7.	  println(name)
8.	  name ="lisi"
9.	  println(name)
10.	  val gender = "m"
11.	  // gender = "m"//错误，不能给常量再赋值

3. 类和对象

• 创建类

1.	class Person{
2.	  val name = "zhangsan"
3.	  val age = 18
4.	  def sayName() = {
5.	    "my name is "+ name
6.	  }
7.	}

• 创建对象

1.	object Lesson_Class {
2.	  def main(args: Array[String]): Unit = {
3.	    val person = new Person()
4.	    println(person.age);
5.	    println(person.sayName())
6.	  }
7.	}

• 对象中的 apply 方法
  object中不可以传参，当创建一个object时，如果传入参数，那么会自动寻找object中的相应参数个数的apply方法。

1.	/**
2.	* Object 相当于单例对象，不能传参
3.	* 如果在创建Object时传入参数，那么运行代码时会自动寻找Object中相应参数个数的apply方法
4.	*/
5.	object LessonObj {
6.	  def apply(name:String) = {
7.	    println(s"name is $name")
8.	  }
9.	  def apply(name:String,age:Int) = {
10.	    println(s"name is $name,age is $age")
11.	  }
12.	  def main(args: Array[String]): Unit = {
13.	     LessonObj("zhangsan")
14.	     LessonObj("zhangsan",18)
15.	  }
16.	}

• 伴生类和伴生对象

1.	class Person(xname :String , xage :Int){
2.	  var name = Person.name
3.	  val age = xage
4.	  var gender = "m"
5.	  def this(name:String,age:Int,g:String){
6.	    this(name,age)
7.	    gender = g
8.	  }
9.	
10.	  def sayName() = {
11.	     "my name is "+ name
12.	  }
13.	
14.	}
15.	
16.	object Person {
17.	  val name = "zhangsanfeng"
18.	
19.	  def main(args: Array[String]): Unit = {
20.	    val person = new Person("wagnwu",10,"f")
21.	    println(person.age);
22.	    println(person.sayName())
23.	    println(person.gender)
24.	  }
25.	}

注意点：

• 建议类名首字母大写 ，方法首字母小写，类和方法命名建议符合驼峰命名法。
• scala 中的object是单例对象，相当于java中的工具类，可以看成是定义静态的方法的类。object不可以传参数。另：Trait不可以传参数
• scala中的class类默认可以传参数，默认的传参数就是默认的构造函数。
  重写构造函数的时候，必须要调用默认的构造函数。
• class 类属性自带getter ，setter方法。
• 使用object时，不用new,使用class时要new ,并且new的时候，class中除了方法不执行，其他都执行。
• 如果在同一个文件中，object对象和class类的名称相同，则这个对象就是这个类的伴生对象，这个类就是这个对象的伴生类。可以互相访问私有变量。

4. if else

1.	/**
2.	* if else 
3.	*/
4.	val age =18 
5.	if (age < 18 ){
6.	println("no allow")
7.	}else if (18<=age&&age<=20){
8.	println("allow with other")
9.	}else{
10.	println("allow self")
11.	}

5. for ,while,do…while

1. to和until 的用法（不带步长，带步长区别）

1.	/**
2.	* to和until
3.	* 例：
4.	* 1 to 10 返回1到10的Range数组，包含10
5.	* 1 until 10 返回1到10 Range数组 ，不包含10
6.	*/
7.	
8.	println(1 to 10 )//打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
9.	println(1.to(10))//与上面等价，打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
10.	
11.	println(1 to (10 ,2))//步长为2，从1开始打印 ，1,3,5,7,9
12.	println(1.to(10, 2)) 
13.	
14.	println(1 until 10 ) //不包含最后一个数，打印 1,2,3,4,5,6,7,8,9
15.	println(1.until(10))//与上面等价
16.	
17.	println(1 until (10 ,3 ))//步长为2，从1开始打印，打印1,4,7

2. 创建 for 循环

1.	/**
2.	* for 循环
3.	* 
4.	*/
5.	for( i <- 1 to 10 ){
6.	 println(i)
7.	}

3. 创建多层 for 循环

1.	//可以分号隔开，写入多个list赋值的变量，构成多层for循环
2.	//scala中 不能写count++ count-- 只能写count+
3.	var count = 0;
4.	for(i <- 1 to 10; j <- 1 until 10){
5.	  println("i="+ i +", j="+j)
6.	  count += 1
7.	}
8.	println(count);
9.	
10.	//例子： 打印小九九
11.	for(i <- 1 until 10 ;j <- 1 until 10){
12.	  if(i>=j){
13.	    print(i +" * " + j + " = "+ i*j+" ")
14.	  }
15.	  if(i==j ){
16.	    println()
17.	  }
18.	
19.	}

4. for循环中可以加条件判断，可以使用分号隔开，也可以不使用分号

1.	//可以在for循环中加入条件判断
2.	for(i<- 1 to 10 ;if (i%2) == 0 ;if (i == 4) ){
3.	  println(i)
4.	}

5. scala 中不能使用 count++，count —只能使用 count = count+1 ，count += 1
6. for 循环用 yield 关键字返回一个集合
7. while 循环，while（）{}，do {}while()

1.	//将for中的符合条件的元素通过yield关键字返回成一个集合
2.	val list = for(i <- 1 to 10 ; if(i > 5 )) yield i 
3.	for( w <- list ){
4.	  println(w)
5.	}
6.	
7.	/**
8.	* while 循环
9.	*/
10.	var index = 0 
11.	while(index < 100 ){
12.	  println("第"+index+"次while 循环")
13.	  index += 1 
14.	}
15.	index = 0 
16.	do{
17.	  index +=1 
18.	  println("第"+index+"次do while 循环")
19.	}while(index <100 )

第四节 Scala 方法与函数

1. Scala 方法的定义

• 有参方法&无参方法

1.	def fun (a: Int , b: Int ) : Unit = {
2.	  println(a+b)
3.	}
4.	fun(1,1)
5.	
6.	def fun1 (a : Int , b : Int)= a+b
7.	println(fun1(1,2))

注意点：

• 方法定义语法 用 def 来定义
• 可以定义传入的参数，要指定传入参数的类型
• 方法可以写返回值的类型也可以不写，会自动推断，有时候不能省略，必须写，比如在递归方法中或者方法的返回值是函数类型的时候。
• scala 中方法有返回值时，可以写 return，也可以不写 return，会把方法中最后一行当做结果返回。当写 return 时，必须要写方法的返回值。
• 如果返回值可以一行搞定，可以将 {} 省略不写
• 传递给方法的参数可以在方法中使用，并且 scala 规定方法的传过来的参数为 val 的，不是 var 的。
• 如果去掉方法体前面的等号，那么这个方法返回类型必定是 Unit 的。这种说法无论方法体里面什么逻辑都成立，scala可以把任意类型转换为 Unit.假设，里面的逻辑最后返回了一个 string，那么这个返回值会被转换成 Unit，并且值会被丢弃。

2. 递归方法

3.	/**
4.	* 递归方法 
5.	* 5的阶乘
6.	*/
7.	def fun2(num :Int) :Int= {
8.	  if(num ==1)
9.	    num
10.	  else 
11.	    num * fun2(num-1)
12.	}
13.	print(fun2(5))

3. 参数有默认值的方法

• 默认值的函数中，如果传入的参数个数与函数定义相同，则传入的数值会覆盖默认值。
• 如果不想覆盖默认值，传入的参数个数小于定义的函数的参数，则需要指定参数名称。

15.	/**
16.	* 包含默认参数值的函数
17.	* 注意：
18.	* 1.默认值的函数中，如果传入的参数个数与函数定义相同，则传入的数值会覆盖默认值
19.	* 2.如果不想覆盖默认值，传入的参数个数小于定义的函数的参数，则需要指定参数名称
20.	*/
21.	def fun3(a :Int = 10,b:Int) = {
22.	  println(a+b)
23.	}
24.	fun3(b=2)

4. 可变参数的方法

• 多个参数用逗号分开

26.	/**
27.	* 可变参数个数的函数
28.	* 注意：多个参数逗号分开
29.	*/
30.	def fun4(elements :Int*)={
31.	  var sum = 0;
32.	  for(elem <- elements){
33.	    sum += elem
34.	  }
35.	  sum
36.	}
37.	println(fun4(1,2,3,4))

5. 匿名函数
   1. 有参匿名函数
   2. 无参匿名函数
   3. 有返回值的匿名函数

• 可以将匿名函数返回给val定义的值

39.	/**
40.	* 匿名函数
41.	* 1.有参数匿名函数
42.	* 2.无参数匿名函数
43.	* 3.有返回值的匿名函数
44.	* 注意：
45.	* 可以将匿名函数返回给定义的一个变量
46.	*/
47.	//有参数匿名函数
48.	val value1 = (a : Int) => {
49.	  println(a)
50.	}
51.	value1(1)
52.	//无参数匿名函数
53.	val value2 = ()=>{
54.	  println("我爱尚学堂")
55.	}
56.	value2()
57.	//有返回值的匿名函数
58.	val value3 = (a:Int,b:Int) =>{
59.	  a+b
60.	}
61.	println(value3(4,4))

6. 嵌套方法

63.	/**
64.	* 嵌套方法
65.	* 例如：嵌套方法求5的阶乘
66.	*/
67.	def fun5(num:Int)={
68.	  def fun6(a:Int,b:Int):Int={
69.	    if(a == 1){
70.	       b
71.	    }else{
72.	      fun6(a-1,a*b)
73.	    }
74.	  }
75.	  fun6(num,1)
76.	}
77.	println(fun5(5))

7. 偏应用表达式

偏应用函数是一种表达式，不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数。

80.	/**
81.	* 偏应用函数
82.	*/
83.	def log(date :Date, s :String)= {
84.	  println("date is "+ date +",log is "+ s)
85.	}
86.	
87.	val date = new Date()
88.	log(date ,"log1")
89.	log(date ,"log2")
90.	log(date ,"log3")
91.	
92.	//想要调用log，以上变化的是第二个参数，可以用偏应用函数处理，这里_需要指定类型。
93.	val logWithDate = log(date,_:String)
94.	logWithDate("log11")
95.	logWithDate("log22")
96.	logWithDate("log33")

8. 高阶函数
   函数的参数是函数，或者函数的返回类型是函数，或者函数的参数和函数的返回类型是函数的函数。

• 函数的参数是函数
• 函数的返回是函数
• 函数的参数和函数的返回是函数

98.	/**
99.	* 高阶函数
100.	* 函数的参数是函数 或者函数的返回是函数 或者函数的参数和返回都是函数
101.	*/
102.	
103.	//函数的参数是函数
104.	def hightFun(f : (Int,Int) =>Int, a:Int ) : Int = {
105.	  f(a,100)
106.	}
107.	def f(v1 :Int,v2: Int):Int = {
108.	  v1+v2
109.	}
110.	
111.	println(hightFun(f, 1))
112.	
113.	//函数的返回是函数
114.	//1，2,3,4相加
115.	def hightFun2(a : Int,b:Int) : (Int,Int)=>Int = {
116.	  def f2 (v1: Int,v2:Int) :Int = {
117.	    v1+v2+a+b
118.	  }
119.	  f2
120.	}
121.	println(hightFun2(1,2)(3,4))
122.	
123.	//函数的参数是函数，函数的返回是函数
124.	def hightFun3(f : (Int ,Int) => Int) : (Int,Int) => Int = {
125.	 f
126.	} 
127.	println(hightFun3(f)(100,200))
128.	println(hightFun3((a,b) =>{a+b})(200,200))
129.	//以上这句话还可以写成这样
130.	//如果函数的参数在方法体中只使用了一次 那么可以写成_表示
131.	println(hightFun3(_+_)(200,200))

9. 柯里化函数

• 高阶函数的简化

1.	/**
2.	* 柯里化函数
3.	*/
4.	def fun7(a :Int,b:Int)(c:Int,d:Int) = {
5.	  a+b+c+d
6.	}
7.	println(fun7(1,2)(3,4))

第五节 Scala 字符串

1. String
2. StringBuilder 可变
3. string 操作方法举例

• 比较: equals
• 比较忽略大小写: equalsIgnoreCase
• indexOf：如果字符串中有传入的 assci 码对应的值，返回下标

143.	/**
144.	* String && StringBuilder
145.	*/
146.	val str = "abcd"
147.	val str1 = "ABCD"
148.	
149.	println(str.indexOf(97))
150.	println(str.indexOf("b"))
151.	
152.	println(str==str1)
153.	/**
154.	* compareToIgnoreCase
155.	* 
156.	* 如果参数字符串等于此字符串，则返回值 0；
157.	* 如果此字符串小于字符串参数，则返回一个小于 0 的值；
158.	* 如果此字符串大于字符串参数，则返回一个大于 0 的值。
159.	* 
160.	*/
161.	println(str.compareToIgnoreCase(str1))
162.	
163.	val strBuilder = new StringBuilder
164.	strBuilder.append("abc")
165.	// strBuilder.+('d')
166.	strBuilder+ 'd'
167.	// strBuilder.++=("efg")
168.	strBuilder++= "efg" 
169.	// strBuilder.+=('h')
170.	strBuilder+= 'h' 
171.	strBuilder.append(1.0)
172.	strBuilder.append(18f)
173.	println(strBuilder)

String方法：（见附件）

第六节 Scala 集合

数组

1. 创建数组

• new Array[Int](10)
  赋值：arr(0) = xxx
• Array[String](“s1”,”s2”,”s3”)

2. 数组遍历

• for
• foreach

3. 创建一维数组和二维数组
4. 数组中方法举例

• Array.concate：合并数组
• Array.fill(5)(“zhangsan”)：创建初始值的定长数组
  创建两种方式:

1.	/**
2.	* 创建数组两种方式：
3.	* 1.new Array\[String](3)
4.	* 2.直接Array
5.	*/
6.	
7.	//创建类型为Int 长度为3的数组
8.	val arr1 = new Array[Int](3)
9.	//创建String 类型的数组，直接赋值
10.	val arr2 = Array[String]("s100","s200","s300")
11.	//赋值
12.	arr1(0) = 100
13.	arr1(1) = 200
14.	arr1(2) = 300

遍历两种方式：

1.	/**
2.	* 遍历两种方式
3.	*/
4.	for(i <- arr1){
5.	  println(i)
6.	}
7.	arr1.foreach(i => {
8.	  println(i)
9.	})
10.	
11.	for(s <- arr2){
12.	  println(s)
13.	}
14.	arr2.foreach { 
15.	  x => println(x) 
16.	}

创建二维数组:

1.	/**
2.	* 创建二维数组和遍历
3.	*/
4.	val arr3 = new Array[Array[String]](3)
5.	arr3(0)=Array("1","2","3")
6.	arr3(1)=Array("4","5","6")
7.	arr3(2)=Array("7","8","9")
8.	for(i <- 0 until arr3.length){
9.	  for(j <- 0 until arr3(i).length){
10.	    print(arr3(i)(j)+" ")
11.	  }
12.	  println()
13.	}
14.	
15.	var count = 0
16.	for(arr <- arr3 ;i <- arr){
17.	  if(count%3 == 0){
18.	     println()
19.	  }
20.	  print(i+" ")
21.	  count +=1 
22.	}
23.	
24.	arr3.foreach { arr => {
25.	  arr.foreach { println }
26.	}}
27.	
28.	
29.	val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))
30.	arr4.foreach { arr => {
31.	  arr.foreach(i => {
32.	    println(i)
33.	  })
34.	}}
35.	println("-------")
36.	for(arr <- arr4;i <- arr){
37.	  println(i)
38.	}

数组中的方法:

5. 可变长数组

1.	/**
2.	* 可变长度数组的定义
3.	*/
4.	
5.	val arr = ArrayBuffer[String]("a","b","c")
6.	arr.append("hello","scala")//添加多个元素
7.	arr.+=("end")//在最后追加元素
8.	arr.+=:("start")//在开头添加元素
9.	arr.foreach(println)

list

1. 创建list

val list = List(1,2,3,4)

• Nil 长度为 0 的 list

2. list 遍历
   foreach ，for
3. list 方法举例

• filter:过滤元素
• count:计算符合条件的元素个数
• map：对元素操作
• flatmap ：压扁扁平,先 map 再 flat

1.	//创建
2.	val list = List(1,2,3,4,5)
3.	
4.	//遍历
5.	list.foreach { x => println(x)}
6.	// list.foreach { println}
7.	//filter
8.	val list1 = list.filter { x => x>3 }
9.	list1.foreach { println}
10.	
11.	//count
12.	val value = list1.count { x => x>3 }
13.	println(value)
14.	
15.	//map
16.	val nameList = List(
17.	  "hello zhangsan",
18.	  "hello xasxt",
19.	  "hello shsxt"
20.	)
21.	val mapResult:List[Array[String]] = nameList.map{ x => x.split(" ") }
22.	mapResult.foreach{println} 
23.	
24.	//flatmap
25.	val flatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") }
26.	flatMapResult.foreach { println }

4. list 方法总结
5. 可变长 List

1.	/**
2.	* 可变长list
3.	*/
4.	val listBuffer: ListBuffer[Int] = ListBuffer[Int](1,2,3,4,5)
5.	listBuffer.append(6,7,8,9)//追加元素
6.	listBuffer.+=(10)//在后面追加元素
7.	listBuffer.+=:(100)//在开头加入元素
8.	listBuffer.foreach(println)

set

1. 创建 set
   注意：set 集合会自动去重
2. set 遍历
   foreach，for
3. set 方法举例

• 交集：intersect ,&
• 差集: diff ,&~
• 子集:subsetOf
• 最大:max
• 最小:min
• 转成数组，toList
• 转成字符串：mkString(“~”)

4. set 方法总结

1.	//创建 
2.	val set1 = Set(1,2,3,4,4)
3.	val set2 = Set(1,2,5)
4.	//遍历
5.	//注意：set会自动去重
6.	set1.foreach { println}
7.	for(s <- set1){
8.	  println(s)
9.	}
10.	println("*******")
11.	/**
12.	* 方法举例
13.	*/
14.	
15.	//交集
16.	val set3 = set1.intersect(set2)
17.	set3.foreach{println}
18.	val set4 = set1.&(set2)
19.	set4.foreach{println}
20.	println("*******")
21.	//差集
22.	set1.diff(set2).foreach { println }
23.	set1.&~(set2).foreach { println }
24.	//子集
25.	set1.subsetOf(set2)
26.	
27.	//最大值
28.	println(set1.max)
29.	//最小值
30.	println(set1.min)
31.	println("****")
32.	
33.	//转成数组，list
34.	set1.toArray.foreach{println}
35.	println("****")
36.	set1.toList.foreach{println}
37.	
38.	//mkString
39.	println(set1.mkString)
40.	println(set1.mkString("\t"))

set 方法总结

5. 可变长 set

1.	/**
2.	* 可变长Set
3.	*/
4.	import scala.collection.mutable.Set
5.	val set = Set[Int](1,2,3,4,5)
6.	set.add(100)
7.	set.+=(200)
8.	set.+=(1,210,300)
9.	set.foreach(println)

map

1. map 创建

• Map（1 –>”zhangsan’）
• Map((1,”zhangsan”))
  注意：创建map时，相同的key被后面的相同的key顶替掉，只保留一个。

1.	val map = Map(
2.	  "1" -> "zhangsan",
3.	  2 -> "shsxt",
4.	  (3,"xasxt")
5.	)

2. 获取 map 的值

• map.get(“1”).get
• map.get(100).getOrElse(“no value”)：如果 map 中没有对应项，赋值为 getOrElse 传的值。

1.	//获取值
2.	println(map.get("1").get)
3.	val result = map.get(8).getOrElse("no value")
4.	println(result)

3. 遍历 map

• for,foreach

1.	//map遍历
2.	for(x <- map){
3.	  println("====key:"+x._1+",value:"+x._2)
4.	}
5.	map.foreach(f => {
6.	  println("key:"+ f._1+" ,value:"+f._2)
7.	})

4. 遍历 key

• map.keys

1.	//遍历key
2.	val keyIterable = map.keys
3.	keyIterable.foreach { key => {
4.	  println("key:"+key+", value:"+map.get(key).get)
5.	} }
6.	println("---------")

5. 遍历 value

• map.values

1.	//遍历value
2.	val valueIterable = map.values
3.	valueIterable.foreach { value => {
4.	  println("value: "+ value)
5.	} }

6. 合并map

• ++ 例：map1.++(map2) --map1中加入map2
• ++: 例：map1.++:(map2) –map2中加入map1
  注意：合并 map 会将 map 中的相同 key 的 value 替换

1.	//合并map
2.	val map1 = Map(
3.	(1,"a"), 
4.	(2,"b"), 
5.	(3,"c") 
6.	)
7.	val map2 = Map(
8.	(1,"aa"),
9.	(2,"bb"),
10.	(2,90),
11.	(4,22),
12.	(4,"dd")
13.	)
14.	map1.++:(map2).foreach(println)

7. map 中的方法举例

• filter: 过滤，留下符合条件的记录
• count: 统计符合条件的记录数
• contains: map 中是否包含某个 key
• exist: 符合条件的记录存在不存在

1.	/**
2.	* map方法
3.	*/
4.	//count
5.	val countResult = map.count(p => {
6.	  p._2.equals("shsxt")
7.	})
8.	println(countResult)
9.	
10.	//filter
11.	map.filter(_._2.equals("shsxt")).foreach(println)
12.	
13.	//contains
14.	println(map.contains(2))
15.	
16.	//exist
17.	println(map.exists(f =>{
18.	  f._2.equals("xasxt")
19.	
20.	}))

Map 方法总结
8. 可变长 map

1.	/**
2.	* 可变长Map
3.	*/
4.	import scala.collection.mutable.Map
5.	val map = Map[String,Int]()
6.	map.put("hello",100)
7.	map.put("world",200)
8.	map.foreach(println)

元组

1. 元组定义
   与列表一样，与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。
2. 创建元组与取值

• val tuple = new Tuple（1） 可以使用 new
• val tuple2 = Tuple（1,2） 可以不使用 new，也可以直接写成 val tuple3 =（1,2,3）
• 取值用 “._XX” 可以获取元组中的值
  注意：tuple最多支持22个参数

1.	//创建，最多支持22个
2.	val tuple = new Tuple1(1)
3.	val tuple2 = Tuple2("zhangsan",2)
4.	val tuple3 = Tuple3(1,2,3)
5.	val tuple4 = (1,2,3,4)
6.	val tuple18 = Tuple18(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18)
7.	val tuple22 = new Tuple22(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)
8.	
9.	//使用
10.	println(tuple2._1 + "\t"+tuple2._2)
11.	val t = Tuple2((1,2),("zhangsan","lisi"))
12.	println(t._1._2)

3. 元组的遍历
   tuple.productIterator得到迭代器，进而遍历

1.	//遍历
2.	val tupleIterator = tuple22.productIterator
3.	while(tupleIterator.hasNext){
4.	  println(tupleIterator.next())
5.	}

4. swap,toString 方法
   注意：swap 元素翻转，只针对二元组

1.	/**
2.	* 方法
3.	*/
4.	//翻转，只针对二元组
5.	println(tuple2.swap)
6.	
7.	//toString
8.	println(tuple3.toString())

本节作业

1. 熟记Scala六大特性
2. 掌握Scala类和对象
3. 掌握Scala方法与函数
4. 掌握Scala集合
5. 所有代码至少敲一遍