Scala

1.初识scala
scala：面向对象，面向函数，静态类型语言
可在scala中直接调用java的Api和方法，与java互通

代码优雅，开发速度快，能融合到生态圈

java:
public class HelloWord{
public static void main(String[] args){
System.out.println("Hello Word");
}
}

scala:
object HelloWord{
def main(args:Array[String]){
println("Hello Word")
}
}

2.scala入门

2-1 val 和 var
val 最常用，值不能变，
var 值可变
定义格式：val 值名称：类型=xxx
val a:int =2 或者 val a =2 scala可自动识别2为int，则此处可省略:int

2-2 基本数据类型
Byte/Char
Short/Int/String/Long/Float/Double
Boolean

val a=10.asInstanceOf[Double] 类型转换
isInstanceOf:判断值是否某种数据类型

2-3 Lazy在scala中的使用
lazy val a=1
结果: a:Int=<lazy> 主要用作延时加载功能，，但不常用

2-4 scala常用开发工具：IDEA

3.scala函数

3-1 方法的定义和使用
def add(a:Int,b:Int):Int={
x+y
}

def 方法名（参数名：参数类型,参数名：参数类型）：函数返回值类型={
//括号内的叫做方法体
...
//方法体的最后一行为返回值，不需要使用return

}

如果没有入参的函数，调用时括号可以省略

3-2 默认参数的使用
默认参数：在函数定义时，允许指定参数的默认值
def sayName(name:String="chen"){}
调用时：sayName()
结果: 若不穿参数，则为默认值，传了参数，就为传的参数

3-3 命名参数的使用
在函数调用时可以不按照函数定义的顺序来传递，但需要带上参数名称。一般不推荐使用

3-4 可变参数的使用参数的个数可以变化
def sum(numbers:Int*){
val result=0
for(number<-numbers){
result+=number
}
result
}

3-5 条件表达式
if(){
}else{
}

3-6 循环表达式
to,Range,Until

1 to 10 类似于 1.to(10) ---->(1,2...10)
Range(1,10) ----->(1,2...9)
1 until 10 类似于 1.until(10) ----->(1,2...9)

for(i <- 1.to(10)){}
for(course <- courses){}
courses.foreach(course => println(course))

4.scala面向对象

4-1 面向对象的概述
封装：把属性，方法封装到类里面
继承：父类和子类之间的关系
多态：父类的引用指向子类的对象
Person person=new User();

4-2 类的定义和使用

class People{
//定义属性
//定义方法
}
使用时： val person=new People()
person.xxx

4-3 构造器

class People(val name:String,val age:Int){}
即:跟在类名后的叫做主构造器

def this(name:String,age:Int,gender:String){
//附属构造器的第一行代码必须要调用主构造器或者其他附属构造器
this(name,age)
this.gender=gender
}

即：调用this主构造器的叫做附属构造器

4-4 继承和重写

class Student(name:String,age:Int,var major:String) extends PerSon(name,age){}
当父类中有该参数时，不需要加val ,若没有，则必须使用var，否则访问不到

重写
override val school="xxx"
对父类的属性和方法进行重写，一定要使用override关键字

4-5 抽象类

类的一个或者多个方法没有完整的实现（只有定义，没有实现）
abstract class Person{}
若要 new Person()，则需要实现这个抽象类中的方法和属性，即重写方法和属性

4-6 伴生类和伴生对象

class ApplyTest{}
object ApplyTest{}

如果有一个class,还有一个和他同名的object，则class是object的伴生类，object是class的伴生对象，两者必须同时存在

4-7 Apply

val b=ApplyTest() //默认会调用Object.apply()方法

即：类名（）默认调用Object中的apply()
对象（）调用的是Class中的apply()
最佳实践：在object 的apply方法中去new class
使用时直接类名()，不需要New

4-8 case class

case class Dog(name:String)
//case class不需要new 一般用在模式匹配中

4-9 Trait

xxx extends ATrait with BTrait with CTriait{}
只有第一个用extends,其他的都用with

5 scala集合

5-1 定长数组
val a= new Array[String](5)
val a =new Array("hadoop","spark","storm")
//默认调用Array中的 apply方法
val c= new Array(2,3,4,5,6)
数组转换为字符串时用 c.mkString(",") ==>2,3,4,5,6

5-2 可变数组
val a=scala.collection.mutable.ArrayBuffer[Int]()

可变数组赋值：d+=1 d+=2 d+=(3,4,5) d++=Array(6,7,8)
d.insert(0,0) 在第一个位置加个0
d.remove(1) 把第二个位置的值删除
d.remove(0,3)从第一个开始删掉3个

d.toArray 由可变数组转换为定长数组

for( ele <- d){ println(ele)} 取出数组中的元素

5-3 List 有序可重复
Nil:不可变的List,是一个空集合
val l=List(1,2,3,4,5)

l.head=1 l.tail=(2,3,4,5)

head是第一个元素，tail是剩下的元素组成的新List

val l2=1 :: Nil ==> List(1)
val l3=2 :: l2 ==> List(2,1)

5-4 Set 无序不可重复

val set=Set(1,2,2,3,4) ==>Set(1,2,3,4)

6.模式匹配

基本语法：
变量 match {
case value1 => 代码1
case value2 => 代码2
...
case _ =>代码N
}

7.scala函数高级操作

7-1 字符串高级操作
插值：
val name="chen"
println(s"Hello: $name") ==> Hello chen

三次 shift + “” 即可输入多行字符串

7-2 匿名函数
函数是可以命名的，也可以不命名

（参数名：参数类型）=>函数体
map(x=>(x,1))

7-3 curry函数颗粒化
将原来接收的两个参数的一个函数转换为两个
def sum(a:Int,b:Int)=a+b
def sum(a:Int)(b:Int)=a+b

7-4 高阶函数
val l=list(1,2,3,4,5,6,7)

7-4-1 map :逐个去操作集合中的所以元素
l.map((x:Int)=>x+1)
l.map((x)=>x+1)
l.map(x=>x+1)
l.map(_+1)
结果： l=list(2,3,4,5,6,7,8)
l.foreach(println)

7-4-2 filter 过滤器

l.map(_+1).filter(_<8)
l=list(2,3,4,5,6,7)

7-4-3 take 取前几个元素

l.take(2) ==>list(1,2)

7-4-4 reduce,reduceLeft,reduceRight
l.reduce(_+_)
l中的元素两两相加，即求和两个进去，出来一个

7-4-5 max,min,sum,foreach

7-4-6 flatten 展开铺平，压扁
flatMap flatten+map 先flatten ,再map
l.flatMap(_.map(_ * 2))

7-5 偏函数
被包在花括号内，没有match的一组case 语句。主要用在模式匹配
def say:PartialFuction[A:String,B:String]{}
A:输入参数类型, B:输出参数类型

8.scala 隐式转换
8-1 隐式转换概述

为一个与存在的类添加一个新的方法：（第三方，无法更改的类）
//定义一个隐式转换函数即可

进来一个普通的，出来一个牛逼的=new 牛逼的（传入普通的）

implicit def man2superman(man:Man):Superman = new Superman(man.name)
增强一个类中的方法，即可以调用另一个类中的方法

8-2 隐式参数，隐式类，，了解

9.scala操作外部数据
9-1 操作文件
val file=source.fromFile("文件路径") 其中source为io中的类
val lines=file.getLines() 一行行的读
lines.foreach(line => println(line))

val file=source.fromURL("网址")

9-2 操作Mysql

9-3 读取xml文件
XML.load(this.getClass.getClassLoader.getResource("test.xml"))

9-4 读取xml文件中的属性

10.项目实战
10.1 项目概述
Spring Boot + Spring Data JPA +Scala + Java 混编
10.2 项目需求
10.2.1 论统一元数据管理在大数据平台中的重要性（SparkSQL/Hive）
元数据管理MetaStore
采集
维护：******
稽查
分析
10.2.2 构建大数据统一的元数据管理
10.3 项目需求分析
1.数据库管理: db1,db2
id name location:数据库存放在HDFS等文件系统上的牡目录
2.表管理 table1,table2 表时要属于某一个数据库