2021-03-19~20 大数据课程笔记 day58day59

@R星校长

1 Scala

1.1 【重点】Scala六大特性

 1) 与java无缝整合
 2) 类型自动推断
 3) 并发和分布式
 4) Trait特质特性
 5) Match模式匹配
 6) 高阶函数

1.2 【重点】Scala & Java异同？

 1) 类型定义声明不同，Scala ：val/var Java强类型定义。
 2) Scala中有类和对象，Java中有类。
 3) Scala、java都是是基于Jvm,scala面向对象+面向函数编程，java面向对象编程。
 4) Scala语言对于java语言简化。
 5) 语法使用不同：例如for,没有break,java中有swith,Scala中有match。

1.3 Scala类和对象、基本操作

 1) val定义常量，var定义变量，常量不可变，变量可变。
 2) Scala中自动推断类型,类型可以省略，每行后面都有分号，分号自动推断，分号可以省略。
 3) Scala类可以传参，类有了参数就有了默认的构造。object不能传参。class重写构造，this中的第一行需要先调用默认的构造。
 4) Scala类中的属性有getter setter方法。
 5) 当new一个类时，类中除了方法不执行，其他都执行。
 6) 一个scala文件中不能有重名的类和对象。
 7) 如果一个scala文件中类和对象的名称相同，这个类叫做这个对象的伴生类，这个对象叫做这个类的伴生对象，可以访问私有变量。
 8) Scala object对象相当于java中的单例，object中定义的都是静态的。
 9) 可以在object中使用applay方法实现类似object传参功能。
 10) 流程控制if…else…与java if… else…一样。
 11) 流程控制 for :

1 to 10 //1 到10 包含10
1 until (10,3)//1 到10，步长为3，不包含10
for(i <- 1 to 10){
   ...}
for(i <- 1 to 10 ;j <- 1 to 20){
   ...}
for(i <- 1 to 100 ;if (i%10==0))
val vector = for(i <- 1 to 100 if(i%20 ==0)) yield i 

 12) 流程控制 while… do…while…

i += 1
i = i+1

1.4 函数和方法

1.4.1 方法定义

 1) 使用def定义方法。
 2) 方法参数必须指定类型。方法体的返回值类型可以省略。
 3) 默认方法将方法体中最后一行的计算结果当做返回值返回。
 4) 可以使用return返回值，但是一定要指定方法体的返回值类型。建议不需要写return。
 5) 如果方法名和方法体之间的“=”省略，无论方法最后一行返回值是什么，都会返回unit。对应的返回值会被丢弃。
 6) 如果方法体中的逻辑可以一行搞定，可以直接去掉方法的“{… …}”

1.4.2 递归方法

 1) 必须显式的指定方法的返回值类型。

1.4.3 参数有默认值的方法

 1) 参数类型后面跟上默认的值。

def fun(a:Int = 100,b:Int = 10) = {
   .. ...}

 2) 如何使用方法，传参时直接指定对应的变量值,例如：fun(a = 200,b=20)

1.4.4 参数可变长的方法

 1) 参数可变长方法定义：

  def fun(s:String*) = {
   ... ...}

1.4.5 【重点】匿名函数

 1) 匿名函数定义：() => {},(a:Int,b:Int)={a+b}
 2) => :匿名函数
 3) 可以将匿名函数赋值给一个变量，下次直接调用这个变量传参后就是使用匿名函数。

1.4.6 嵌套方法

 1) 嵌套方法是方法中有方法。

1.4.7 偏应用表达式

//偏应用表达式可以使用在频繁调用一个方法，每次调用方法中大部分参数不变，少量参数改变的场景：
def showLog(date:Date,log:String) = {
   ....}
val date = new Date()
val fun = showLog(date,_:String)
fun(“a”)
fun(“b”)

1.4.8 【重点】高阶函数

 1) 【重点】方法的参数是函数。
 2) 【重点】方法的返回是函数。
 3) 方法的参数和返回都是函数。就是前两个的合并。

1.4.9 柯里化函数

 1) 高阶函数的简化版

def fun(a:Int,b:Int)(c:Int,d:Int)={
   a+b+c+d}
fun(1,2)(3,4)

1.5 Scala String

 1) Scala中的String就是java中的String

1.6 Scala集合

1.6.1 Array

 1) 定义：

val array = new Array[String](长度) 
val array = Array[Int](......)

 2) 遍历：for，foreach
 3) 方法：Array.concat(array*),map,flatMap,filter…
 4) 可变长：

val array = new ArrayBuffer[String]()
array.append(... ...)

1.6.2 List

 1) 定义：val list = ListString,有序不去重
 2) 遍历：for，foreach
 3) 方法：map[一对一],flatMap[一对多]
 4) 可变长：

val list = ListBuffer[String](...)
list.append(... ...)

1.6.3 Set

 1) 定义：val set = SetString，无序，去重。
 2) 遍历：for，foreach
 3) 方法：flatMap,map,fitler…
 4) 可变长：

val set = scala.collections.mutable.Set[String]()
set.add(... ...)

1.6.4 Map

 1) 定义:两种初始化值方式。

val map = Map[(String,Int)]("xx"->10,("xs",200))

 2) 遍历：

for,foreach,map.keys,map.values

 3) 方法：

val option:Option[Int] = map.get(key)
val value = option.getOrEles(xxx)
faltMap,map,filter,

 4) 可变长：

val map = scala.collections.mutable.Map[(String,Int)]()
map.put(k,v)

1.6.5 【重点】tuple

 1) tuple与集合一样，但是tuple中每个元素都有一种类型。
 2) tuple最多支持22位。最常用的是tuple2,二元组。
 3) tuple遍历：tuple.productIterator。
 4) 每个tuple都有toString方法，tuple2有swap方法。
 5) tuple取值：tuple._1/tuple._2/tuple._x
 6) tuple定义可以new,可以不new 还可以直接(xx),tuple中的每个位置都是一种类型。

1.7 【重点】Trait特质特性

 1) Trait相当于Java中的抽象类和接口整合。
 2) Trait 中可以定义常量变量，方法的实现和方法的不实现。
 3) Trait 继承多个类时，第一个关键字使用extends,之后使用with。
 4) 一个类如果继承多个Trait，Trait中有相同的方法名和变量名，需要在类中重新定义覆盖。

1.8 【重点】Match模式匹配

 1) 模式匹配格式

xx match {
   
	case i:Int =>{
   ... }
	case “hello” =>{
   ... ..}
	case _ =>{
   .... ...}
}

 2) Match不仅可以匹配值还可以匹配类型。
 3) Match从上往下匹配，匹配上之后，自动停止。
 4) Match匹配过程中有数据类型转换。
 5) case _ =>{xxx} 什么都匹配不上才匹配，放在最后一行。
 6) 方法体中只有match模式匹配，可以将xx match {xxx} 整体看成一行

1.9 偏函数

 1) 类似于java中的switch … case … ,是模式匹配的特殊情况，只能匹配一种类型，对应出来一种类型。

def  fun:PartialFunction[Int,String] = {
   
   case 1 =>{
   ... ...;“hello”}
   case 2 =>{
   ... ...;“scala”}
   case _ =>{
   “default”}
}

1.10 【重点】样例类

 1) 使用关键字case修饰的类就是样例类
 2) 样例类可以new 可以不用new。
 3) 样例类实现了toString，equles,hash…方法
 4) 样例类参数默认就是类的属性，自带getter，setter方法。

1.11 【重点】隐式转换

1.11.1 隐式值和隐式参数

 1) 使用关键字implicit修饰的值就是隐式值。
 2) 方法中参数使用implicit修饰，这个参数就是隐式参数。