学习Scala 进击大数据Spark生态圈
总结：
第一章：
简单讲解了一下Scala的优劣势
第二章：
val：常量(值) 会自动生成get方法
var: 变量 自动生成get/set方法
lazy属性是遇到Action操作才会执行
优点：大数据需要提前加载的时候不会占用整个系统很多资源
缺点：不判断程序或加载数据的对错，只有在Action运行时才发现
IDEA开发工具的使用：
1、windows下载maven，配置环境变量
2、plugins 可以手动添加Scala包，也可以idea下载
第三章：
def 函数名(可以无参数，也可以有参数): 返回类型(Unit无返回类型) {
//函数体
如果有返回类型，最后一行被当做是返回类型，不需要return
}
如果函数名(无参数) 调用时可以直接函数名
默认参数：可以写一个默认参数函数名(a:Int = 3)，如果没有赋予其它参数，默认a=3
命名参数：参数名对应好了，顺序可以错乱
循环：
1 to 10 （1,2,3,4,5,6,7,8,9,10） 1.to（10）
1 until 10 （1,2,3,4,5,6,7,8,9） 1.until（10）
Range(1,10) （1,2,3,4,5,6,7,8,9）
for(变量 <- 要遍历的数据)
for(变量 <- 要遍历的数据 条件)
x.foreach()等价于for循环
while(循环条件)
根据输入的数据不定参数进行计算
例：
println(num(1,2,3))
println(num(1,2,3,4))
def num(no:Int*) = {
var result = 0
for(i <- no){
result += i
}
result
}
第四章
封装：属性、方法封装到类中（类是被抽象出来的）
属性：person
private int id, String name, date birthday geter/seter
方法：eat sleep run
继承：
父类和子类之间的关系
子类继承父类，并且还可以重写override
子类继承父类，如果父类有的属性，子类可以不加var/val，父类的方法会执行
重写：子类需要修改父类的方法、属性时需要进行重写 override xxx
抽象类：类的一个或者多个方法、属性没有实现（只有定义）
想要调用，必须实现所有的类、方法，否则不能被调用
多态：父类的引用指向子类
Person person = new Person()
User user = new User()
val p = new User() //父类接口，子类实现功能
类的定义：
private 只在当前类中调用
_ 占位符，使用占位符必须指定var的数据类型
构造器：
主构造器：
跟在类名后面的属性叫主构造器 class Person（val name:String, val age:Int）
附属构造器:
def this(name:String, age:Int, gender:String){
this(name,age) //附构造器第一句话必须调用主构造器或者其它附属构造器
this.gender=gender
}
伴生类、伴生对象：
如果有一个class，还有一个和class同名的object， class是object的伴生类，object是class的伴生对象
object类可以直接val p = Person()
APPLY方法：
在object的apply方法中new class
类名() 调用的object.apply
对象() 调用的class.apply
case class：通常用在模式匹配中，调用时不用new，直接调用即可
trait：需要多个继承的时候with链接
第五章
Array 定长数组，定义以后数组长度不能改变
可变数组：scala.collection.mutable.ArrayBuffer +增加数据，++需要加入Array
不可变数组：scala.collection.immutable._
List: Nil 是一个不可变的空集合List，是有序的可以重复的 :_* 可以将Seq转化为list
Buffer：ListBuffer、ArrayBuffer 带Buffer都是可变的
Set：数据是不能重复的
Map:(key-value）键值对操作
第六章
匹配模式：
变量 match{
case x => xxx
case _ => xxx //相当于java的 default
}
条件模式匹配：
变量 match{
case x => xxx
case _ if(xxx) => xxx //注意执行的先后顺序
case _ => xxx //相当于java的 default
}
数组匹配：
def NameScore(array: Array[String]): Unit ={
array match{
case Array("zhangsan") => println("zhangsan")
case Array(x,y) => println("x,y")
case Array("zhangsan", _*) => println("Hi:zhangsan other one") // _* 无限匹配
case _ => println("erveryone")
}
}
NameScore(Array("zhangsan"))
NameScore(Array("zhangsan","lisi", "wangwu"))
NameScore(Array("zhangwu"))
List匹配
def NameScroe(list: List[String]): Unit ={
list match{
case "zhangsan"::Nil => println("zhangsan")
case x::y::Nil => println("x,y")
case "zhangsan":: tail => println("Hi:zhangsan other one")
case _ => println("erveryone")
}
}
NameScroe(List("zhangsan","wangwu"))
NameScroe(List("zhangsan","lisi", "wangwu"))
NameScroe(List("zhangwu"))
类型匹配：
def ObjType(obj: Any){
obj match{
case x:Int => println("Int")
case x:String => println("String")
case x:Map[_,_] => x.foreach(print)
case _ => println("other")
}
}
ObjType(1)
ObjType("1")
ObjType(Map("key"->"value"))
异常处理：
try{
//要执行的代码
}catch{
//可以代码执行错误后，要进行提示或其它信息写到这里
}finally{
//一定会执行，记得要把资源关闭
}
case class 对类进行模式匹配，必须要定义一个顶级的类
Some&None 模式匹配：
val b = Map("PK" -> 18, "zhangsan" -> 12, "lisi" -> 20)
def gredeTest(name:String): Unit ={
val getGred = b.get(name)
getGred match{
case Some(getGred) => println("this some")
case None => println("this None")
}
}
gredeTest("PK")
gredeTest("lisi")
gredeTest("wangwu")
第七章
字符串高级操作：
多行：借助于s"$常量或$变量" 进行打印
val a = "Hello"
val b = "World"
val c = s"$a $b!"
println(c)
使用""""""进行多行打印 Shift + "" 按3次
val a1 =
"""
|Hello
|Wolrd
|!
""".stripMargin
println(a1)
匿名函数：匿名函数没有函数名，可以赋值给变量或常量或匿名函数
val a = (x:Int) => x+1 a(10) 结果：11
val add = (x:Int, y:Int) => x + y add(2,3) 结果：5
柯里化：将原来接收多个参数的函数变换成接收一个单一的参数
高阶函数：
Map：Map(x => （x,1）) 可以把数据进行Tuple（key-value）操作、柯里化
filter:根据条件过滤数据
faltten:将数据进行shuffle，
val l = List(List(1,2), List(3,4))
l.flatten
结果：List[Int] = List(1, 2, 3, 4)
FlatMap：结合了flatten和map的特点
reduce：数据进行计算，例如加法：reduce(_+_)
reduceLeft、reduceRight 从左或右开始计算
fold: 数据进行计算，可以再进行单独加一些数据，例如加法，累加后额外再加1：reduce(1)(_+_)
foldLeft、foldRight 数据进行计算，例如加法：reduce(_+_)
foreach：循环遍历与for循环类似
偏函数：{}内的没有match的一组case语句可以进行模式匹配
//PartialFunction[String, String] 偏函数特征[输入参数,输出参数]
def moshi:PartialFunction[String, String] = {
case "wangwu" => "王五"
case "lisi" => "李四"
case _ => "None"
}
println(moshi("wangwu"))
第八章
隐士转换：通过implicit进行隐士转换，最好把隐士转换都放到一个类里面，方便调用------------面试重点
implicit def manToSuperMan(man: Man):SuperMan = new SuperMan(man.name)
val superMan = new SuperMan("lisi")
superMan.fly()
class Man(val name:String){
def eat(): Unit ={
println(s"$name is eat.....")
}
}
class SuperMan(val name:String){
def fly(): Unit ={
println(s"$name is fly ......")
}
}
隐士参数：对参数增加implicit
def testParam(implicit name:String){
println(name + "====================")
}
implicit val name = "zhangsan"
testParam
隐士类：对类增加implicit
implicit class classTest(x:String){
def add(a:Int) = a + x
}
println("12345".length)
第九章
读取文件：Source.fromFIle(文件路径)(文件编码可以不写)，getLines整行读取
读取MySQL数据：classOf[com.mysql.jdbc.Driver]
读取XML：this.getClass.getClassLoader.getResource("xml文件")
\ 某一层
\\ 所有