Scala

Scala

// 重点讲述的是与java不同的地方。

一.基本介绍

1.第一个Scala程序

1：object:关键字，声明一个单利对象（伴生对象，跟自己的同名类相伴相生），解决静态功能。 

2.变量和数据类型

2.1 常量和变量

        // 类型可以推断的时候可以省略，声明的时候就要有初始值。
var 变量名[:变量类型] = 初始值 //可变
val 常量名[:常量类型] = 初始值 //不可变              

2.2 标识符命名规范

// Scala中标识符分为两部分
// 1.普通起名和java一样。
// 2.scala中的运算符都可以自己起名
        ----总结，报错就改。尽量别用$开头
// 3.如何在java中访问scala对象？
    ---直接对象.方法调用即可。
// 4.非要使用关键字命名的时候，可以加飘号。

2.3 字符串

// scala中没有字符串，使用的就是java中的字符串，所以可以直接使用java中字符串的方法。
​
// 补充：什么叫Json?
    --javaScript object notition。对象字符串。
    --一个{}就代表一个对象，里面就是属性和属性值，如果有多个对象的话，可以用[]括起来所有的{}。
    --在网络中传输对象需要序列化，太麻烦了，所以可以把对象包装为Json格式，就可以直接传输了。
    ---所以把数据转化为Json字符串是一个重要操作。
​
//字符串输出
    
    ---------------用这个--------------
    （1）插值字符串：通过$获取变量值 
            // 前面要加s
        println(s"${age}岁的${name}在学校复习")
        
    （2）多行字符串
            ---主要用于封装Json或者SQL命令
        S"""
            |select *
            |from
            |   student
            |where
            |   name=${name}
            |and
            |   age > ${age}
            |""".stripMargin            

2.5 IO

// 标准化屏幕输入
val age:Int = scala.io.StdIn.readInt()//阻塞，直到控制台有输入、回车。读一个整数
println(age)
    
StdIn.readline()//读一行。
​
// 从文件中获取输入
​
    1.从文件中读取数据，并按原格式打印出来。
        //IDea中的取的是相对路径，相对的是当前的project而言。
            // 绝对路径：不可改变的路径
                    --协议：//地址(路径)，有的没写会默认补全。
                    //网络：http://www.baidu.com:8/test/test.html
                    //本地：file://c:/test/test.html
            // 相对路径：可以改变的路径，应该存在一个基准路径
                    --idea中默认的基准路径就是项目的根路径。
                
    Source.fromFile("路径").foreach(print)
    
    2.将数据写入文件
     val writer = new PrintWriter(new File("output/test.txt" ))
      writer.write("Hello Scala")
      writer.close()
​
// 网络中的IO
    //先定义server
object Scala_IO_Server{
    def main(args:Array[String]):Unit = {
        val server = new ServerSocket(9999) 
        println("服务器启动成功....等待客户端连接")   
        val client:Socket = server.accept() // 阻塞       
        println("服务器已经连接，等待客户端传送的数据")
        val in:InputStream = client.getInputStream
        val data:Int = in.read()
        println("获取客户端发送的数据" + data)
        in.close()
        client.close()
        server.close()      
    }    
}
    //再定义client
object Scala_IO_Server{
    def main(args:Array[String]):Unit = {
        val client = new Socket("localhsot",9999)
        println("服务器连接成功")
        val out:OutputStream = client.getOutputStream
        out.write(1)// 300
        out.close()
        println("向服务器发送数据成功")
        client.close()
    }    
}
// 测试时，先启动服务器，然后启动客户端。
// 这里传输的是ASC码，不能传输数字。ASC码的范围
​
​
// 网络IO-对象输出流
    //先定义server
object Scala_IO_Server_Obj{
    def main(args:Array[String]):Unit = {
        val server = new ServerSocket(9999) 
        println("服务器启动成功....等待客户端连接")   
        val client:Socket = server.accept() // 阻塞       
        println("服务器已经连接,等待接收客户端传送的数据")
        val objIn = new ObjectInputStream(client.getInputStream)
        val obj = objIn.readObject()
        println("获取客户端发送的数据" + data)
        in.close()
        client.close()
        server.close()      
    }    
}
    //再定义client
object Scala_IO_Server_Obj{
    def main(args:Array[String]):Unit = {
        val client = new Socket("localhsot",9999)
        println("服务器连接成功")
        val user = new User();
        user.age = 20
        val objOut = new ObjectOutputStream(client.getOutputStream)
        objOut.writeObject(user)
        objOut.close()
        println("向服务器发送数据成功")
        client.close()
    }    
}
    //定义一个对象,并且序列化
public class User implements Serializable{
    
    public static int age;
    @override
    public String toString(){
        return "User["+age+"]";
    }
    
}
// 测试时，先启动服务器，然后启动客户端。

2.6 数据类型概述

1. Scala中一切的数据都是对象，都是Any的子类。
2. Scala中数据类型分为两大类：数值类型 AnyVal,引用类型AnyRef，不管是值类型还是引用类型都是对象。
3. Scala数据类型仍然遵守，低精度的值类型向高精度值类型自动转换（隐式转换）。
4. Scala中的StringOps是对java中的string的增强。
5. Unit 对应java在的void,只有一个对象，就是（）
6. Null是一个类，只有一个对象就是null,是所有引用类型的子类。
7. Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值的时候使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。（比如一个函数在运行的时候，抛出了异常，根本就不考虑他的返回值。） 

2.7 强制类型转换

val n2:Int = (2.9 + 3.7).toInt
  --强转会造成精度损失,因为是截断。
  
    程序中输入的数字到底层的时候会以补码的形式存储，正数的补码就是自己，负数的补码就是自己全部取反再+1。在补码中，整数的符号位是0，负数的符号位是1，强转就是在补码上直接截断。
  
  
数值类型和String类型的转换。
    //（1）数值转换String
    val n:Int = 27
    val s:String = n +""
    //（2）String转数值
    val m:Int = "12".toInt
    val f2:Int = "12.3".toDouble.toInt运算符

3.运算符

逻辑运算符
    --在java中==判断地址，object.equals()判断值。
    --在scala中，==和.equals()被统一为判断值。用.eq()判断引用地址。
        在scala中，==底层调用了.equals()。
        
赋值运算符
    在scala中是没有 ++ --的，避免产生歧义。
    --在java中
        x=23
        x=x++会被分解为 tmp = x++ ，x = tmp
                    tmp=23,x++后x变为24，但是x=24后又被tmp=23覆盖为23   
                    
                    
// Scala运算符是一种方法，只是省略成为了计算形式。
// 字符串也可以有乘法。
 // n + m 等价 n.+(m)
    -----这也解释了为什么 +等可以作为标识符。
    在scala中调用方法可以用空格代替.
        n +(m)
        进一步的，（）里面只有一个m，可以把（）去掉变为n + m
    
    java:7.5.toString()
    scala:7.5 toString
    连续调用的时候更明显
    scala:7.5 toInt toString

4.流程控制

// Scala中的表达式都是有返回值的，每一个分支都有返回值。
	-----就是该分支最后一行表达式的值。

for循环

// 1.增强for循环，常使用，先准备一个集合、
	//for循环里面的数据集可以是任意类型的数据集合，比如字符串（视为字符数组）、集合、数组等。
val list = 1 to 5 // 1.to(5)
val list = 1 until 5 // 1,2,3,4
val list = range(1,5) // 1,2,3,4,默认步长为1，第三个参数可以设置步长。
val list = range(1,5,2)
    for(num <- list){
        println(num)
    }

val s = "zhangsan"
    for(c <- s){
        println(c)
    }
// 循环守卫（增加的判断条件）
for(i <- Range(1,5) if i != 3){
    println(i)
}
// 循环步长
for(i <- 1 to 5 by 2){
    println(i)
}
// 嵌套循环
	//每次i和j同时进入一次。
for(i <- Range(1,5);j <- Range(1,4)){
    println("i = " + i + ",j = " + j)
}
	-------------这里的代码块会在两个循环中都使用到

for(){
	// 如果在这个位置写代码，就要用这种循环。
	
    for(){
    
    }
}

// 循环的返回值
//循环的默认返回值为Unit，但可以利用yield关键字可以返回每一步的执行结果。
val result = for(i <- 1 to 4)yield{
	i*2
}
println(result) // vector(2,4,6,8)

// 循环跳出
breakable{
	for(i <- 1 to 5){
    	if(i == 3){
    		break
    	}
    	println(i)
	}
}

二、函数式编程

2.1 函数和方法？

如何区分函数和方法？

1.简单理解：方法也是函数。函数声明在类中称方法，其他场合是函数。方法有重写、重载，函数没有这些。但函数可嵌套声明使用，方法不行。

2.scala 方法是类的一部分，而函数是一个对象，可以赋值给一个变量。

3.Scala中函数会编译为方法，且改了方法名字，方法名字后增加$1,嵌套的同名方法会变加上$2……，而且增加了private final static。调用时会自动更改为变了名字和修饰符的方法。

4.Scala语言不关心函数的实现方式，只关心如何调用。

2.2 函数基本声明和调用

对一个Scala函数来讲，最重要的是IO,即需要传入什么，需要返回什么。


1.无参无返回值
  // 声明，右侧是一个代码块，代码块是有返回值的，相当于赋值操作。
	def fun1():Unit = {
        
	}
 // 调用
 	fun1()
        --无参的时候可以省略（），变为fun1,所以单独出现一个函数名fun1的时候，就是认为在调用和执行该函数。如果fun1_则考虑为一个静态对象，如果是fun1()则考虑为调用或者静态对象。
        	
2.无参有返回值

	// 声明
    def fun2():String = {
 		return "zhangsan"
    }
   // 调用
   val str:String = fun2()
       --无参的时候可以省略（），变为val str:String = fun2
       println(str)
       
3.有参无返回值
	// 声明
    def fun3(s:String):Unit = {
    	println(s)
    }
	// 调用，必须传参。
	fun3("zhangsan")
        --可以传递子类对象类型。

4.有参有返回值
	// 声明
    def fun4(name:String):Unit = {
    	return "Name:" + name	
    }
    //调用
    val name:String = fun4("zhangsan")
        println(name)
5.多参无返回值
	// 声明  
    def fun5(name:String,age:Int):Unit = {
    	println(s"Name:${name},Age:${Age}")
    }
    // 调用
    fun5("zhangsan",10)
        	--传参必须按顺序按类型。    
6.多参有返回值
	// 声明
    def fun6(name:String,age:Int):String = {
    	// 这里将属性封装到json中。
    	val json = 
    		s"""
    			|{"name":"${name}","age":${age}}// json里面的属性名和属性值都需要用双引号包起来，但是如果属性名不是字符串类型时，可以省略双引号。
    			|""".stripMargin
    			return json
    }
    
	// 调用
	val json = fun6("zhangsan",10)
        println(json)
        
 
        
        
 7.可变参数
 	// 声明
 def fun7(age:Int，name:String*):Unit={
 	println(name)
 }
 		--如果参数不确定，且参数之间含义相同，可以使用可变参数。
 		--参数类型后面使用*，表示可变参数，调用时可以传递参数，也可以不传。
 		--可变参数要放到参数列表的最后面。（所以不可能有两个可变参数。）
 	
 	// 调用
 	fun7()
        --不传参数的时候，不可以省略小括号，此时打印获取的结果是一个空集合List()。
    fun7("zhangsan")
        --传值后，打印输出的结果会被包装为一个集合WrapperArray(zhangsan)

8.带默认值的参数
	// 声明
def fun8(password:String = "000000"):Unit = {
	println(password)
}
		--默认值放在类型的后面。
		--带默认值的参数不允许和可变参数一起使用。
	// 调用
	fun8()
        --不传参的时候，会使用默认值
	fun8("123123")

9.带名传参
   // 声明
 def fun9(password:String = "000000",name:String) = {}
   // 调用
   fun9(name="zhangsan")
       	---遇到这种比较棘手的情况的时候，可以使用 形参名=值的方式传参调用。

2.3 函数声明时的至简原则

// 能省则省
1. return 可以省略
def test():String = {
    return "zhangsan"
}

2.函数体只有一行，可以省略{}
def test():String = "zhangsan"

3.如果根据返回结果可以推断返回值类型，那么返回值类型可以省略。
	---如果出现选择结构，可能有多个分支返回不同的类型，那么返回值类型会向高级自动推断。
def test()="zhangsan"

4.如果该函数没有参数，参数列表小()可以省略。
def test = "zhangsan"
    ----如果声明的时候没加小括号，那么使用的时候也不能加小括号。

5.如果函数明确声明返回值类型为Unit,那么函数体中仍然可以声明return,但是无法起作用，主要目的是为了改变分支。
  
  	如果函数体中使用return返回结果(虽然不起作用)，那么返回值类型必须声明。  
def test()：Unit = {
	return "zhangsan"
}
 	如果我们希望省略Unit,也要让return失效，那么可以省略Unit和=
def test(){
    return "zhangsan"
}

6.def和函数名也可以省：匿名函数，但需要转换格式。
(s:String) => {
	println("zhangsan")
}

2.4 高阶函数编程

1.将函数对象赋值给一个变量，那么这个变量的类型就是函数类型in => out, x∈【0,22】
	// 这里声明一个函数，等于声明一个函数对象。即对象。
def fun():Unit = {return "zhangsan"}
	// 将函数对象赋值给一个变量。
val ff:    () => Unit    = fun         // 也可以 val ff = fun_
	// 怎么使用这个变量呢?一旦加上（）,就表示执行了该函数，即加括号表示调用该函数，不加括号表示函数对象。
		ff()---调用函数
		ff ----函数对象
	
    ---引入匿名函数：
    	// 直接在等号右侧给一个匿名参数，避免先声明再赋值。
    val ff:() => Unit =       ()=>{return "zhangsan"}

1.1 将函数返回值赋给一个变量。
 def fun():Unit = {}
	而调用fun()时，因为没有参数，可以直接使用fun
	// 这里判定为将函数返回值赋给一个变量
  		val f = fun()
   // 如果仍然只是想用函数对象，而不是返回值，则在函数名后加上下划线。
   		val f = fun_
   		// 或者
   		val f:()=>Unit = fun
1.2 函数类型的in => out中，如果in的参数只有一个，小括号可以省略。

2.将函数对象作为参数传递给另一个函数。
	def fun1():Unit = {}
	def fun2(fun1:() => Unit):Unit = {f()}
	
	fun2(fun1)
        
    def sum(a:Int,b:Int):Int = {a + b}
	def fun(f:(Int,Int) => Int):Int = {
    	val r = f(10,20)
        println(r)
	}
	fun(sum)
        ---将传入参数转变为匿名参数，以匿名参数作为参数传入。
     	fun(
        (a:Int,b:Int) => {
            a - b
        }
    )  
        	---引入匿名参数的至简原则，把匿名函数也能省则省。
        	fun((a:Int,b:Int) =>{a - b}) 
        	fun(a:Int,b:Int) =>a - b)
        			---只有一行，可以省略{}
			fun(a,b) =>a - b)
                	---参数类型在传参后可以推断出来，可以省略参数类型
            fun(_-_)
                	---参数按顺序只访问了一次，那么参数列表可以省略，表达式中的参数可以用下划线代替。
  
  
  例：
  def fun(s:String):Unit = {
  	println(s)
  }
  def test(f:String => Unit):Unit ={
  	f()
  }
  test(fun)
      
      test(
      (s:String)=> {println(s)}  
  )
      ---test((s:String)=>println(s))
      ---test((s)=>println(s))
      ---test(println(_))
      
      还可以继续，但这里已经不是函数至简原则了，相当于回到了最开始，在一个函数中传入另一个函数对象。
      ---test(println)

3.将函数作为返回值使用
def test():Unit = {}
def fun():Unit = {
	test //这里是执行了test，所以返回Unit。
}
def fun1() = {
    test_ //这里没有执行test,而是将test作为一个函数对象返回。返回值类型就是test函数的类型。
}
	val f = fun()

        
        
       // 在实际使用中：
        def outer():Unit={
        	def inner():Unit={
        		println("inner....")
        	}
        	inner_
        }
        
		// 调用
		outer(外层参数)(内层参数)
4.闭包
	// 在上面，内层函数是没有使用到外层函数的参数的，那如果内层函数运用到外层函数的参数呢，函数就是方法，外层方法结束后会弹栈，也会带走自己这一层的参数。所以需要闭包。
	// 闭包的意思就是将外层的参数打包保存到heap中下来，防止外层函数执行结束后弹栈，带走了参数。相当于延长了外层参数的生命周期。
	// 闭包的应用场景：大数据场景下，固定相同的数，然后改变其他加数。
  // 将固定的加数作为另一个参数传入，但是是作为”第一层参数传入“
  
5.控制抽象
	// 如果函数声明时，有一个参数是函数对象，且这个函数对象的参数列表没有写，就是抽象。
	// 调用的时候不可以增加参数列表的小括号。只需要传递逻辑代码，传递多行逻辑代码的时候（）要变为{}
	// 应用场景：模板设计模式
    def test(f: =>Unit):Unit={
    	f //使用该不完整参数时，也要保持没有参数列表。
    }
	
	// 调用test时，只需要传递逻辑代码。
	test(println("zzzzz"))
        
     object Function_Desigh{
        def main(args:Array[String]):Unit={
            // 声明规范
        	def operationDB(op:=>Unit):Unit={
            	println("init connection...")
                op
                println("close connection....")
        	}
        	// 使用时传入逻辑。
        	operationDB{
            	println("operation db......")
        	}
    	}
	}
6.函数科里化
	// 将无关的参数给分离开，形成多个参数列表
    def test(i:Int)(j:Int):Unit={
    	for(a <- 1 to i){
    		println(a)
    	}
        for(a <- 1 to j){
        	println(a)
        }
    }
    // 使用,有的参数列表可以根据场景省略。
    test(i)(j)
7.递归
// 下面是正常的递归。
	// 方法自己调用自己，需要有跳出逻辑(但仍可能栈溢出，递归此处太多。)
			--递归在IDEA中有一个回环图标就表示递归。
	// 递归函数中不可以省略返回值类型
	
    def test(num:Int):Int={
    	if(num <= 1){
			1    
        }else{
        	num * test(num - 1)    
        }
    }
    
	----引入尾递归,尾递归在scala中执行完方法体后，会立即弹栈，然后去递归执行下一个函数，因为一直弹栈，所以不会栈溢出。
    def test():Unit={
    	println("abc")
    	test()
    }

8.惰性函数
	// lazy修饰，可以使函数的执行会被推迟，知道我们首次用上这个函数的返回值的时候，该函数才会执行。
	def fun():String={}
	lazy val f = fun() // 暂时不执行，等到打印f时才执行。
        println("zhangsan")
        println(f)

2.5 函数体现分布式计算

// 定义Master对象，所有的slaver节点都需要向master注册，让master知道集群里有多少个节点。另外Master可以把自己的元数据交给Zookeeper,可以做成高可用。
object Scala_Function_Master{
    def main(args:Array[String]):Unit = {
        // 准备数据
        val num = 4
        // 准备逻辑
        val logic = (num:Int) => {println(num)}
        // 调度（按特定方式，切分任务）
        val task1 = new Task()
        task1.start = 1
        task1.end = num/2
        task1.logic = logic
            
        val task2 = new Task()
        task2.start = num/2 + 1
        task2.end = num + 1
        task2.logic = logic
       
        // 给节点发送切分完成的任务
        val slaver1 = new Socket("localhost",9999)
        val objOut1 = new ObjectOutputStream(slaver1.getOutputStream) 
        objOut1.writeObject(task1)
        objOut1.flush()// flush的作用是清空缓存区的数据，使缓存区的数据写出去，避免close时有数据丢失
        objOut1.close() 
           
            
        
        val slaver2 = new Socket("localhost",8888)
        val objOut2 = new ObjectOutputStream(slaver2.getOutputStream) 
        objOut2.writeObject(task2)
        objOut2.flush()// flush的作用是清空缓存区的数据，使缓存区的数据写出去，避免close时有数据丢失
        objOut2.close()
            
        //  
        slaver1.close()
        slaver2.close() 
    }
}

// 定义一个类封装计算任务，任务对象要从master发往slaver,涉及到传输对象，所以需要序列化。
class Task extends Serializable{
    val start:Int = 0
    val end:Int = 0
    val logic :(Int) => Unit = null
    
    def run():Unit = {
        for(i <- start to end){
            logic(i)
        }    
    }
        
}

// 定义slaver1,slaver可以动态扩容，每个节点的逻辑都是一样的，所以只需要外面动态的传递端口号就行了。
object Scala_Function_Slaver1{
    def main(args:Array[String]):Unit = {
        val server = new ServerSocket(9999)
        println("slaver[9999]服务启动，等待master连接")
        val master:Socket = server.accept()
        println("slaver[9999]等待master传输数据")
            
        val objIn = new ObjectInputStream(master.getInputStream)
        val obj = objIn.readObject()
        val task:Task = obj.asInstanceOf[Task]
        
        // 执行任务
        task.run()
        objIn.close()
        
        // 一般是不需要停止的，这里是演示而已。
        master.close()
        server.close() 
    }
}

// 定义slaver2
object Scala_Function_Slaver1{
    def main(args:Array[String]):Unit = {
        val server = new ServerSocket(8888)
        println("slaver[8888]服务启动，等待master连接")            
        val master:Socket = server.accept()
        println("slaver[8888]等待master传输数据")
            
        val objIn = new ObjectInputStream(master.getInputStream)
        val obj = objIn.readObject()
        val task:Task = obj.asInstanceOf[Task]
        
        // 执行任务
        task.run()
        objIn.close()
        
        // 一般是不需要停止的，这里是演示而已。
        master.close()
        server.close() 
    }
}

测试的时候，需要先启动slaver1和slaver2，然后启动master。

2.6 下划线的作用

//1.可以声明变量，但是不能使用
val _ = "zhangsan"
//2.将函数作为对象来使用。
val f = test_
//3.在匿名函数中可以代替参数,但是不可以嵌套使用。另外如果参数给定什么，就返回什么的场合，是不可以使用下划线代替的，如word => word是不可以的。
test(_+_)
//4.导入类时，可以代替*
import java.util._
//5.属性的默认初始化
var name:String = _
//6.模式匹配中，作为任意值进行匹配，类似于java中国switch中的default操作。
case_ => xxxxx
//7.泛型中，下划线表示任意类型。

三、面向对象编程

3.1 package

// 1.同一个源码文件中子包（内包）可以直接访问父包（外包），而无需import
// 2.外包访问内包，需要导包。
// 3.package也可以看作对象，并声明属性和函数，作为其对应包下的所有class和object的共享变量，可以直接被访问。

3.2 import

// 1.import关键字可以声明在任何要用的地方
// 2.同一个包中的类可以简化为一行，用一个花括号括起来，用逗号隔开。
	import java.util.{ArrayList,HashMap}
// 3.导包。包是个对象，那么包里面的东西都可以使用了。
	import java.util
    	new util.ArrayList()
// 4.屏蔽类
    import java.util._
    import java.sql.{Data =>_,_}
// 5.改类名
	import java.util.{HashMap=>JavaHashMap}

3.3 类的声明和使用

// class声明类， new构建对象。

3.4 类的属性

// scala中所谓类的属性其实就是类中声明的变量
	//但是作用域不一样
class User{
    val name = "zhangsan"
    var age = 30
        // var email : String是错的，因为scala中变量必须使用显示初始化。可以用下划线代替，但是val不可以这么使用，因为val后续不许更改，占位没有意义。
    var email : String = _    
}
// scala给类声明属性，在编译后，这个属性是私有的，但是同时编译出了两个公共方法（不是java中的那种setXXX和getXXX方法），用于set/get属性。

// java中很多的框架要求bean对象必须符合bean规范(属性私有化，并提供标准get/set方法)。scala做出的处理是在var属性前面加上一个注解：@BeanProperty,这样属性就具有了set/get方法。

3.5 访问权限

// scala权限
1.private    同类
2.private[包名] 同类、同包
3.protected 同包 同类 子类
4.（public，默认）公共

3.6 方法

// 方法就是函数，只不过是声明在类中。
	//对象.eq()方法可以直接使用，比较内存地址
	//对象.isInstanceOf()方法可以直接使用，表示是否为每个类型的实例。
	//对象.asInstanceOf()可以直接使用，表示将对象作为某个类型的实例来使用。

3.7 构造方法

// 万物皆函数，类其实就是函数。scala中的构造方法分为两大类
	//1.完成类的初始化：主构造方法
	//2.辅助操作：辅助构造方法，用this关键字声明的构造方法
		---辅助构造方法必须要首先完成类的初始化操作，然后再进行辅助操作，所以必须在代码中首先调用主构造方法。
		---辅助构造方法之间可以相互调用，调用前必须声明过。

class User{ // 主构造函数
    var username : String = _ 
    def this( name:String ) { // 辅助构造函数，使用this关键字声明
        this() // 辅助构造函数应该直接或间接调用主构造函数
        username = name
	}
	def this( name:String, password:String ) {
    	this(name) // 构造器调用其他另外的构造器，要求被调用构造器必须提前声明
	}
}

3.8 继承/封装

// 与java一致

3.9 抽象

// 如果一个类中有抽象方法，那么这个类需要用abstract修饰为抽象类。
// 抽象方法直接写出声明，不用方法体。
// 抽象类中完整的方法也可以被实现类重写，但是要在方法前加上关键字override，跟java的@Override注解不一样。
// 声明属性而没有初始化，称之为抽象属性。重写抽象属性补充完整即可。重写完整val属性，需要在属性前面增加override关键字。
abstract class User{
    def test():Unit
}

3.10 单例对象/伴生对象

// Scala如果想使用到单例模式，直接在类的前面使用object关键字就行。
object User{
}

//若单例对象名与某个类的类名相同，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明，然后通过伴生对象名称直接调用

// 一般会将成员方法和属性声明在伴生类中。
// 一般会将模拟静态方法和静态属性声明在伴生对象中。伴生对象可以访问半生类中的所有内容。

3.11 Apply

// scala中为了方便构建对象，如果构建对象的方法名是一个特殊的名称的话，那么这个方法名可以不用写。

// 伴生类 
class User{
    
}
// 伴生对象
object User{
    // apply可以给不同参数，重载。
    def apply():User = {
        new User()
    }
}

  // 构建对象
 val user2 : User = User.apply()
     // apply 可以省略,集合中常用 
 val user1 : User = User()
     // 通过调用伴生类的构造方法来new。如果伴生类声明的时候加上了private，这种方法就没法使用了。
 val user3 : User = new User()
     // 单例对象，即本省就是一个对象（User$）
 val user4 : User = User

3.12 特质

// 将多个对象中相同的特征剥离出来，形成一个独立的语法结构，称之为特质(特征)
// 如果有一个类符合这个特征，那么可以将这个特征混入到这个类中。
// 如果一个类可以混入多个特征，第一个特征使用extends，后续使用with连接。
// 如果一个类既有父类，同时还混入了特征，那么父类使用extends关键字，所有特征都使用with连接。
		---scala中用trait统一了java抽象类和接口。java中的所有接口在scala中都是特质。
trait Runable{
    def run()
}

class Person extends Runable{
    override def run():Unit = {
        println("person runnning..........")
    }
}


// 特质的动态混入:在new对象的时候混入新功能，可以避免修改源码。
val user = new User() with Runable


// 特质初始化顺序
	1.如果类和特质同一个级别，那么特质先初始化
	2.如果多个特质混入，那么初始化顺序是从左到右
	3.初始化只会执行一次。

// 特质功能叠加
	从右到左。super【父类名】可以指定跳跃到某个父类特质。

四、集合

不可变与可变

// 不可变 scala.collection.immutable 方法尽量使用运算符，默认情况下，scala中的集合都是不可变的。
// 可变 scala.collection.immutable 方法使用英文单词

//分可变集合和不可变集合的意义

// 在数仓中，我们会将原始数据保留住，对原始数据进行一些数据清洗的操作，然后把清洗的结果发送的另一个地方去。如果下次我们仍然想使用原始数据，就应该将原始数据保存在一个不可变集合中。（重点是强调不可变，因为java中是可变的。）

4.1 Array

4.1.1 不可变数组Array

// 数组的声明方式2，声明的同时赋值。----这是最常见的方式。   
    val arr:Array[Int] = Array(1,2,3)
1. 访问、赋值、修改元素（通过索引）
	arr(0)=3	
2. 遍历
// 遍历方式1
arr.mkString(",")
// 遍历方式2
arr.foreach(println)
        
 // Scala中的集合默认是不可变的。如果运算符使用冒号结尾，那么运算规则从右向左。
         // 增加元素+。(冒号的位置就是原集合的位置)
       val ints:Array[Int] = arr :+ 4  //（1,2,3,4）
       val ints1:Array[Int] = 5 +: arr //（5,1,2,3）
         // 把另一个集合的元素链接过来++,记一个就行，自己更改朝向。
           // array={4,5,6},array1={1,2,3}
         val ints2:Array[Int] = arr ++: arr1，//{4,5,6,1,2,3}
         val ints3:Array[Int] = arr1 :++ arr //{1,2,3,4,5,6}

    
    // 多维数组(数组里面有数组) 3*3二维数组。
    var myMatrix = Array.ofDim[Int](3,3)
    // 二维数组遍历，这里的list只是一个变量名,完全可以使用arr。
    myMatrix.foreach(List=>println(List.mkString(",")))

    // 合并数组
        val arr1 = Array(1,2,3)
        val arr2 = Array(4,5,6)
        val arr3:Array[Int] = Array.concat(arr1,arr2)
            
    // 创建指定范围的数组
        val arr7:Array[Int] = Array.range(0,2) // [0.2)
            
    // 创建并以指定元素填充数组,下面是以-1填充长度为5的数组。常用于状态监测。
        val arr8:Array[Int] = Array.fill[Int](5)（-1）
    

4.1.2 可变数组ArrayBuffer

// new 一个空的
val buff = new ArrayBuffer[String]()
// 赋值构建
val buff1 = ArrayBuffer("1","2","3")   
    // 追加元素,后面是可变参数
    buff.append("a","b","c")
    // 追加集合
    buff.appendAll(buff1) 
     
     // 遍历方式1,可变的数组直接打印。
        println(buff)        
     
     // 更改元素,更改自身
        buff.update(index,element)<=> buff(index) = element        
     // 更改元素生成新的集合，不改变原来的集合
        val ints:ArrayBuffer[Int] = buff.updated(index,element)
    
     // 插入元素，在index处，插入指定数量的元素(可变参数)
        buff.insert(index,ele1,ele2,........)
     
     // 删除元素
        buff.remove(index)
     // 从index处，删除count个元素，注意不要越界。
        buff.remove(index,count)           

4.1.3 Array <=> ArrayBuffer

val array = Array(1,2,3,4)
val buffer = ArrayBuffer(1,2,3,4)
// 不可变转换 => 可变
array.toBuffer
// 可变 => 不可变
buffer.toArray

4.2 Seq-List(有序可重)

4.2.1 不可变序列List

// 不可变的Seq特质，使用List最多。
val list = List(1,2,3,4，1,4)
val list1 = List(1,3,2,4)        
    // 思考，为什么Java中要这么写？
    	List list = new ArrayList()
     // 而不是这么写
    	ArrayList list = new ArrayList()
    // 当考虑拓展性后，后面无论是哪个类实现了List接口，只要左边是List接口，list.add()都是可以使用的。
    // 当使用ArrayList特有的方法，用Arraylist类。        
    
    // 增加数据::
    val 1ist2 = 1::2::3::list::List(1) //把1,2,3和list集合都加入到List中。
   	val list3 = 1::2::3::Nil // 增加数据到空集合
    val list4 = 1::2::3::list:::Nil // 将整体的list拆分为个体，放入到新集合中（叫做扁平化）

4.2.2 可变序列ListBuffer

val buffer = ListBuffer(1,2,3,4)
buffer.append()
buffer.appendAll()
buffer.insert()
buffer.update()
buffer.updated()
buffer.remove()

4.2.3 List <=> ListBuffer

val list = List(1,2,3,4)
val buffer = ListBuffer(1,2,3,4)
// 不可变转换 => 可变
list.toBuffer
// 可变 => 不可变
buffer.toList

4.3 Set（无序不重）

// 因为set是无序的，所以就没有了索引操作。

4.3.1 不可变Set

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

4.3.2 可变mutable.Set

	// 创建
	val set = mutable.Set(1,2,3,4)
   //增加数据，没有索引、顺序，所以是单纯的增加。
    set.add(5)
    //修改集合，true就是使集合包含该元素，fasle就是使集合不包含该元素。 
    set.update(element,false)
    // 删除元素
    set.remove(2)
    // 遍历
    println(set.mkString(","))
    set.foreach(println)

4.4 Map

4.4.1 不可变的Map

// 键值对
val kv = "a" -> 1
    
// 无序，kv键值对，k不可重复，v可以重复。a指向3，后者将前者覆盖了。
val map = Map("a"->1,"b"->2,"c"->3,"d"->3,"a"->3)  

4.4.2 可变mutable.Map

// 创建
val map = mutable.Map("a"->1,"b"->2,"c"->3,"d"->3,"a"->3)
val map = mutable.Map(("a",1),("b",2),("c",3))
// 删除
	map.remove("c")
// 遍历
    map.mkString(",")
    map.foreach(println)

    // 如果元组中的元素只有两个，称之为对偶元组，也称之为键值对对象
    "a"->1，等价于 ("a",1) 
    // map遍历
    map.foreach(
    kv =>{
        println(kv._1 + "=" + kv._2)
    }

// 增加/修改
    map.update("a",5) 
    map("a") = 5    
    map.put("a",4)//返回值类型为Option

// 如果有该key,就返回value,如果没有改key,就返回默认值。
    map.getOrElse("a",0)
// 如果有该key,就返回value,否则将该key和value增加进map。
    map.getOrElseUpdate("a",1)

            // 单独取出所有的key
            val keys:Iterable[String] = map.keys
            // hashmap是可以放空key,空null的
            map.put(null,null)
              //hashtable是不可以放空key，空null的。  

// 排序,因为map没有索引的概念，所以没有sort方法，要先转化为List
  val list1 = map.toList
  list1.sort()
    ----当List中有kv时，也可以转换为Map。

4.5 Tuple

// scala将无关的数据作为整体使用的时候，形成一个元素的组合，简称为元素，称之为元组Tuple
 
//声明
val tuple = (1,"zhangsan",30)
    //因为数据无关，所以一般通过位置编号进行访问。
    println(tuple._1)
    
    // 遍历
    tuple.productElement(index)
    tuple.Iterator
    
    // 迭代（套娃）
    t->2->3->4->5

4.6 队列

//Scala也提供了队列（Queue）的数据结构，队列的特点就是先进先出。进队和出队的方法分别为enqueue和dequeue。
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val que = new mutable.Queue[String]()
        // 添加元素
        que.enqueue("a", "b", "c")
        val que1: mutable.Queue[String] = que += "d"
        println(que eq que1)
        // 获取元素
        println(que.dequeue())
        println(que.dequeue())
        println(que.dequeue())
    }
}

4.7 并行集合

// Scala为了充分使用多核CPU，提供了并行集合（有别于前面的串行集合），用于多核环境的并行计算。
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val result1 = (0 to 100).map{x => Thread.currentThread.getName}
        	//par就是并行的意思。
        val result2 = (0 to 100).par.map{x => Thread.currentThread.getName}

        println(result1)
        println(result2)
    }
}

4.8 常用方法

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val list = List(1,2,3,4)

        // 集合长度
        println("size =>" + list.size)
        println("length =>" + list.length)
        // 判断集合是否为空
        println("isEmpty =>" + list.isEmpty)
        // 集合迭代器
        println("iterator =>" + list.iterator)
        // 循环遍历集合
        list.foreach(println)
        // 将集合转换为字符串
        println("mkString =>" + list.mkString(","))
        // 判断集合中是否包含某个元素
        println("contains =>" + list.contains(2))
        // 取集合的前几个元素
        println("take =>" + list.take(2))
        // 顺序取集合的后几个元素
        println("takeRight =>" + list.takeRight(2))
        // 查找元素
        println("find =>" + list.find(x => x % 2== 0))
        // 丢弃前几个元素
        println("drop =>" + list.drop(2))
        // 丢弃后几个元素
        println("dropRight =>" + list.dropRight(2))
        // 反转集合
        println("reverse =>" + list.reverse)
        // 去重
        println("distinct =>" + list.distinct)
    }
}
2)	衍生集合
object ScalaCollection{
def main(args: Array[String]): Unit = {
    	val list = List(1,2,3,4)
        val list1 = List(1,2,3,4)
        val list2 = List(3,4,5,6)

        // 集合头
        println("head => " + list.head)
        // 集合尾
        println("tail => " + list.tail)
        // 集合尾迭代
        println("tails => " + list.tails)
        // 集合初始值
        println("init => " + list.init)
        // 集合初始值迭代
        println("inits => " + list.inits)
        // 集合最后元素
        println("last => " + list.last)

// 双集合操作
        // 集合并集
        println("union => " + list.union(list1))
        // 集合交集（如果是set，会去重）
        println("intersect => " + list.intersect(list1))
        // 集合差集，哪个集合调用方法，就以哪个集合为中心。
        println("diff => " + list.diff(list1))
        // 切分集合
        println("splitAt => " + list.splitAt(2))
        	// 按条件将集合切分为两个符合条件的集合。
        list.partition(_>3)
        // 滑动窗口，每次滑动一步（窗口大小）
        println("sliding => " + list.sliding(2))
        // 多步长滑动,(窗口大小，滑动步长）
        println("sliding => " + list.sliding(2,2))
        
        // 拉链，将相同位置上的元素连接再一次，谁调用谁在左边，拉不上的就舍弃。
        println("zip => " + list.zip(list1))
        // 数据索引拉链，将数据和索引构建在一起。
        println("zipWithIndex => " + list.zipWithIndex)
    }
}

3)	计算函数
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val list = List(1,2,3,4)
        val list1 = List(3,4,5,6)

        // 集合最小值
        println("min => " + list.min)
        // 集合最大值
        println("max => " + list.max)
        // 集合求和
        println("sum => " + list.sum)
        // 集合乘积
        println("product => " + list.product)
        // 聚合（两两计算）
        println("reduce => " + list.reduce(_+_))
        // 聚合(左)，从左边开始迭代加括号
        println("reduceLeft => " + list.reduceLeft(_+_))
        // 聚合(右)，从右边开始迭代加括号
        println("reduceRight => " + list.reduceRight(_+_))
        
        // 折叠，fold方法存在函数柯里化，第一个参数列表表示集合之外的计算初始值，第二个参数列表表示计算规则：两两计算。要求计算初始值和集合原始值类型相同
        println("fold => " + list.fold(0)(_+_))
        // 折叠(左)，内外类型可以不一样，以外为主。从左开始，迭代加括号。
        println("foldLeft => " + list.foldLeft(0)(_+_))
        // 折叠(右)，先reverse.foldleft,然后把外面元素放在前面，然后左右交换位置上括号。
        println("foldRight => " + list.foldRight(0)(_+_))
        
        
        // 扫描，将每一步的计算结果保留下来。
        println("scan => " + list.scan(0)(_+_))
        // 扫描(左)
        println("scanLeft => " + list.scanLeft(0)(_+_))
        // 扫描(右)，结果从右向左保存为一个List
        println("scanRight => " + list.scanRight(0)(_+_))
    }
}

4)	功能函数
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val list = List(1,2,3,4)

        // 映射map,将每一条数据转换映射，产生新的集合,能改变结构
        println("map => " + list.map(_*2))
        // 扁平化，整体拆成个体
        val list1 = List(
            List(1,2),
            List(3,4)
        )
        println("flatten =>" + list1.flatten)
        // 自定义扁平化
        println("flatMap =>" + list1.flatMap(list=>list))
        
        val list = List(
        	"hello Scala","hello Spark"
        )
        val list2 = list.flatMap(
        	s => s.split(" ") // 这里的s指的是，list中的每一个值。
        )
        
        // 过滤，根据指定条件对集合每一个元素进行筛选
        println("filter =>" + list.filter(_%2 == 0))
        val list1 = List("Hadoop","Hive","Scala","Spark")
        list1.filter(
        	s => { 
        	s.starsWith("S")//每一个值都判断一下是否以S开头。	
        	}
        )
        
        // 分组，根据指定规则进行分组，，返回结果为Map类型，其中的key就是分组的表示，value就是相同标识的数据集合。
        println("groupBy =>" + list.groupBy(_%2))
        
        // 排序，默认为升序（如果是字符串排序的话，按字典序。）
        	//单关键字排序
        println("sortBy =>" + list.sortBy(num=>num)(Ordering.Int.reverse)
        val list1 = List("1","2","3","11","22")
    	val sortList1 = list1.sortBy(s => s)// 按字典序
    	val sortList2 = list1.sortBy(s => s.toInt)// 按数值大小	
        	// 多关键字默认升序
        	//使用元组排序，元组在排序时，会先按照第一个元素排，然后按第二个元素排....（）
        println("sortWith =>" + list.sortWith((left, right) => {left < right}))
    		// 自定义多关键字排序,将自己真实想要的排序结果返回为true
    	val sortList1 = list.sortWith(
        	(a,b) => {
        		//将预期结果返回为true
                if(a.age < b.age){
                	true
                    }else if(a.age == b.age){
                    	a.salary > b.salary
                    }else{
                   	false
                }
        	}
    	)

    	
    	// 改变value
    	val list = List(
    		("hello",2),("hello",4),("hello",6)
    	)
    	val mapList = list.toMap.mapValues(_*2)
    	println(mapList)
    }
}

4.9 wordcount topN

4.9.1 粗糙版

object SelfScalaTest {

    def main(args: Array[String]): Unit = {
      //1.获取文件原始数据
      val source: BufferedSource = Source.fromFile("data/word")
        //返回每行的迭代器
      val strings: Iterator[String] = source.getLines()
        //可以将全部迭代结果(每一行的所有元素)，返回到一个list中
      val list: List[String] = strings.toList
      source.close()
      //2.将原始数据分解为一个一个的单词
      val strings1: List[String] = list.flatMap(_.split(" "))
      //3.将单词分组
      val stringToStrings: Map[String, List[String]] = strings1.groupBy(s => s)

      //4.对分组后的单词进行统计
      val stringToInt: Map[String, Int] = stringToStrings.map(
        kv => (kv._1, kv._2.size)
      )
      //5.对分组统计完成之后的touple排序降序
      val tuples: List[(String, Int)] = stringToInt.toList.sortBy(
        t => t._2
      )(Ordering.Int.reverse)
      //6.将排序结果输出到打印台
      println(tuples)
}
}

4.9.2 精简版

// 初学的时候最好把类型带出来.
object ScalaWordCount{
    def main(args: Array[String]): Unit = {
		// 将文件中的数据读取出来，放到list中
        val lineList: List[String] = Source.fromFile("input/word.txt").getLines().toList
        
        source.close()

		val top3 = 
			LineList
			.flatMap(_.split(" "))
			.groupBy(word=>word)//不可以简化，简化会报错。
			.mapValues(_.size)//mapValues返回的是一个map
			.toList
			.sortBy(t => t._2)(Ordering.Int.reverse)
			.take(3)
		
		println(top3)
    }
} 

4.10 集合的小练习(2种思路)

// 工作中要先写出来。
object Scala_Collection_Test{
    def main(args:Array[String]):Unit={
        val list = List(
            ("hello",4),
            ("hello spark",3),
            ("hello spark scala",2),
            ("hello spark scala hive",3)
        )
        // 将上面的数据进行WordCount后排序取前三名
        	//方法1
        val mapList = list.map(
        	t => (t._1 + " ") * t._2
        )
               
       val top3 = 
			LineList
			.flatMap(_.split(" "))
			.groupBy(word=>word)
			.mapValues(_.size)
			.toList
			.sortBy(t => t._2)(Ordering.Int.reverse)
			.take(3)
        	
        // 方法2
        	//拆分为局部WordCount
       val flatList = list.flatMap{
            t => {
                val str = t._1
                val cnt = t._2
                val words = str.split(" ")
                word.map((_,cnt))
            }
        }
        	//分组
       val groupMap:Map[String,List[(String,Int)] = flatList.groupBy(_._1) 
            //局部统计
      val sumMap = groupMap.mapValues(list.list.map(_._2).sum)
        	//排序
       val top = sumMap.toList.sortBy(t => t._2)(Ordering.Int.reverse)                  
                        
    }
}

五、模式匹配

// Scala中的模式匹配类似于Java中的switch语法 
// 顺序匹配分支，成功则执行分支代码，不成功，继续下一个分支判断。case _分支兜底（一般放到最后，在前面就顺序执行）。无法匹配成功会报错

		var a: Int = 10
        var b: Int = 20
        var operator: Char = 'd'
        var result = operator match {
            case '+' => a + b
            case '-' => a - b
            case '*' => a * b
            case '/' => a / b
            case _ => "illegal"
        }
        println(result)

// 1.匹配常量
// 2.匹配类型
	---匹配类型时，类型前要加临时变量名，后续的计算要使用该变量名参与计算。
	---忽略泛型（你写不写都没用）。
	---数组需要考虑泛型（转化为字节码的时候不是泛型，泛型就是数组的元素类型）。
// 3.匹配数组
for (arr <- Array(Array(0), Array(1, 0), Array(0, 1, 0), Array(1, 1, 0), Array(1, 1, 0, 1), Array("hello", 90))) { // 对一个数组集合进行遍历
    val result = arr match {
        case Array(0) => "0" //匹配Array(0) 这个数组
        case Array(x, y) => x + "," + y //匹配有两个元素的数组，然后将将元素值赋给对应的x,y
        case Array(0, _*) => "以0开头的数组" //匹配以0开头和数组
        case _ => "something else"
    }
    println("result = " + result)
}

// 4.匹配列表
for (list <- Array(List(0), List(1, 0), List(0, 0, 0), List(1, 0, 0), List(88))) {
    val result = list match {
        case List(0) => "0" //匹配List(0)
        case List(x, y) => x + "," + y //匹配有两个元素的List
        case List(0, _*) => "0 ..."
        case _ => "something else"
    }
    println(result)
}

val list: List[Int] = List(1, 2, 5, 6, 7)
list match {
    	// 看集合能否分为三个部分。 ：：是连接，空集合也是一个部分。
    case first :: second :: rest => println(first + "-" + second + "-" + rest)
    case _ => println("something else")
}
// 5.匹配元组
for (tuple <- Array((0, 1), (1, 0), (1, 1), (1, 0, 2))) {
    val result = tuple match {
        case (0, _) => "0 ..." //是第一个元素是0的元组
        case (y, 0) => "" + y + "0" // 匹配后一个元素是0的对偶元组
        case (a, b) => "" + a + " " + b
        case _ => "something else" //默认
    }
    println(result)
}
---------------------------使用场景---------------------
///过滤
val (id,name,age,_) = (1,"zhangsan",30,100)

// 6.样例类(比较类的内容)
case class User(name: String, var age: Int)
object ScalaCaseClass {
    def main(args: Array[String]): Unit = {
        val user: User = User("zhangsan", 11)
        val result = user match {
            case User("zhangsan", 11) => "yes"
            case _ => "no"
        }
        println(result)
    }
}
// 7.匹配偏函数，只对集合中的部分数据进行处理。
	//将该List(1,2,3,4,5,6,"test")中的Int类型的元素加一，并去掉字符串。
List(1, 2, 3, 4, 5, 6, "test").collect { case x: Int => x + 1 }.foreach(println)