Scala知识点

一变量和数据类型

数据类型

Scala是完全面向对象的语言，只有任意值对象（AnyVal）和任意引用对象（AnyRef）

类型转换

强制类型转换

var a : Int = 10
Var b : Byte = a.toByte

二流程控制

for循环

1，基本语法

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for ( i <- Range(1,5) ) { // 范围集合
            println("i = " + i )
        }
        for ( i <- 1 to 5 ) { // 包含5
            println("i = " + i )
        }
        for ( i <- 1 until 5 ) { // 不包含5
            println("i = " + i )
        }
    }
}

2，循环守卫

for (i <- Range(1,9) if i !=2){
  println("i="+i)
}

3，步长

for(i <- Range(1,5,2)){
  println("i="+i)
}
for(i <- 1 to 10 by 2){
  println("i="+i)
}

4，返回值
scala所有的表达式都有返回值，for循环要返回具体值，需要使用关键字yield

循环中断

scala.util.control.Breaks.breakable(
      for(i <- 1 to 5){
        if(i==3){
          scala.util.control.Breaks.break()
        }
        println(i)
      }
    )

三函数式编程

面向对象编程：
分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题
函数式编程：
将问题分解成一个一个步骤，将每个步骤封装，通过调用这些封装好的步骤，解决问题

基本语法

[修饰符] def 函数名 ( 参数列表 ) [:返回值类型] = {
    函数体
}

private def test( s : String ) : Unit = {
    println(s)
}

函数至简原则

1，省略return关键字

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun1(): String = {
            return "zhangsan"
        }
        def fun11(): String = {
            "zhangsan"
        }
    }
}

2，省略花括号

当代码只有一行的时候

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun2(): String = "zhangsan"
    }
}

3，省略返回值类型

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun3() = "zhangsan"
    }
}

4，省略参数列表

没有参数的时候，调用的时候不能使用小括号

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun4 = "zhangsan"
    }
}

5, 省略等号
6，省略名称和关键字

没def和函数名叫匿名函数，需要一个变量赋值才能使用
过程函数：没有返回值类型和等号的函数

val s = () => {println("cat is ugly")}
    s()

四高阶函数编程

1，函数作为值

变函数的结构赋值给变量，可以是使用下划线，也可以使用 String=>String

object ScalaOut {
  def main(args: Array[String]): Unit = {

    def fun1(): Unit ={
      "cat is ugly!"
    }
    val a = fun1
    val b = fun1 _
    // val b:String=>String = fun1
    println(a)
    println(b)
  }
}

2，函数作为参数

（参数列表）=> 返回值

object ScalaOut {
  def main(args: Array[String]): Unit = {

    def first(i:Int,j:Int): Int ={
      i * j * 2
    }
    def second(f:(Int,Int)=>Int): Int ={
      f(10,20)
    }

    println(second(first))
  }
}

3，函数作为返回值

object ScalaOut {
  def main(args: Array[String]): Unit = {

    def first(i:Int,j:Int): Int ={
      i * j * 2
    }
    def second() ={
      first _
    }

    val  s = second()
    println(s(10,30))
    println(second()(10,20))
  }
}

4，匿名函数

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun4( f:Int => Int ): Int = {
            f(10)
        }
        println(fun4((x:Int)=>{x * 20}))
        println(fun4((x)=>{x * 20}))
        println(fun4((x)=>x * 20))
        println(fun4(x=>x * 20))
        println(fun4(_ * 20))
    }
}

5，闭包

我们的一个变量在函数执行完后被其他的函数包含使用，改变了这个变量的声明周期
一个函数使用了外部的变量，但外部的变量不能被回收调，包含在当前函数形成闭合的效果，称之为比闭包。
形成的条件：嵌套函数的使用就有闭包；将函数复制给变量来使用

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun5() = {
            val i = 20
            def fun55() = {
                i * 2
            }
            fun55 _
        }
    }
}

6，函数柯里化
将复杂的函数参数列表变得简单化
将多个参数的参数列表变成多个参数列表

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun6(i:Int)(j:Int) = {
            i * j
        }
    }
}

7.控制抽象

将函数作为参数，但是这个函数没有输入参数，也无需返回结果

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun7(op: => Unit) = {
            op
        }
        fun7{
            println("xx")
        }
    }
}

8，递归函数

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun8(j:Int):Int = {
            if ( j <= 1 ) {
                1
            } else {
                j * fun8(j-1)
            }
        }
        println(fun8(5))
    }
}

9，惰性函数
函数的执行将推迟，直到我们首次对此取值

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun9(): String = {
            println("function...")
            "zhangsan"
        }
        lazy val a = fun9()
        println("----------")
        println(a)
    }
}

五面向对象编程

基础面向对象编程

1 包

基本的语法和java的package包语法一致
扩展语法

Scala中的包和类的物理路径没有关系
package关键字可以嵌套声明使用
子包可以直接访问父包内容
package也可以看作对象

2导入

Scala中基本的import导入语法与Java完全一致
import java.util._
// Scala中使用下划线代替Java中的星号
扩展语法：

import语法可以在任意位置使用
可以导包，不是导类
一行可以导多个类
可以屏蔽某个包中的类

import java.util._
import java.sql.{ Date=>_, Array=>_, _ }

给类起别名，简化使用
可以使用类的绝对路径而不是相对路径

3 类和属性

Scala中的属性其实在编译后也是方法

4 构造方法

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

高阶面向对象编程

1 继承

和Java一样，Scala的继承也是单继承，使用extends关键字

class Person {
}
class User extends Person {
}

封装

把抽象的数据和对数据的操作封装在一起，数据保护在内部，通过调用来访问

抽象

将一个不完整的类称为抽象类
如果一个方法只有声明而没有实现，那么是抽象方法
属性只有声明没有初始化，为抽象属性
子类继承父类，必须实现抽象方法或者补全抽象属性，否则也为抽象

单例对象

指定类的对象只能创建一个
伴生对象本身就是单例对象

如果方法名交apply方法，那么就可以省略方法名称
构造对象的两种方式：
使用new 关键字，等同于调用类的构造方法
使用伴生对象构造对象，等同于调用伴生对象的apply方法（不能省略参数列表）

class User { // 伴生类
}
object User { // 伴生对象
    def apply() = new User() // 构造伴生类对象
}
...
val user1 = new User()// 通过构造方法创建对象
val user2 = User() // 通过伴生对象构建伴生类对象

特质

将多个类相同特征剥离出来，形成一个独立的语法结构
trait：特质，可以看成是抽象类或者是接口
*OCP原则：开闭原则（扩展开发，修改关闭）

动态混入

object ScalaTrait{
    def main(args: Array[String]): Unit = {
        val mysql = new MySQL with Operator
        mysql.insert()
    }
}
trait Operator {
    def insert(): Unit = {
        println("insert data...")
    }
}
class MySQL {

}

扩展

1 类型检查

class Person{
}
object Person {
    def main(args: Array[String]): Unit = {

        val person = new Person

        //（1）判断对象是否为某个类型的实例
        val bool: Boolean = person.isInstanceOf[Person]

        if ( bool ) {
            //（2）将对象转换为某个类型的实例
            val p1: Person = person.asInstanceOf[Person]
            println(p1)
        }

        //（3）获取类的信息
        val pClass: Class[Person] = classOf[Person]
        println(pClass)
    }
}

2 枚举和应用类

object Test {
    def main(args: Array[String]): Unit = {
        println(Color.RED)
    }
}

// 枚举类
object Color extends Enumeration {
    val RED = Value(1, "red")
    val YELLOW = Value(2, "yellow")
    val BLUE = Value(3, "blue")
}

// 应用类
object AppTest extends App {
    println("application");
}

3 type定义新类型

相当于重命名类型名

object Test {
    def main(args: Array[String]): Unit = {
        type S =String
        var v : S = "abc"
    }
}

六集合

有三大类：序列Seq，集合Set，映射Map

1 数组

1.1，不可变数组（Array）

基本语法

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        //（1）数组定义
        val arr01 = new Array[Int](4)
        println(arr01.length) // 4

        //（2）数组赋值
        //（2.1）修改某个元素的值
        arr01(3) = 10
        val i = 10
        arr01(i/3) = 20
        //（2.2）采用方法的形式修改数组的值
        arr01.update(0,1)

        //（3）遍历数组
        //（3.1）查看数组
        println(arr01.mkString(","))

        //（3.2）普通遍历
        for (i <- arr01) {
            println(i)
        }

        //（3.3）简化遍历
        def printx(elem:Int): Unit = {
            println(elem)
        }
        arr01.foreach(printx)
        arr01.foreach((x)=>{println(x)})
        arr01.foreach(println(_))
        arr01.foreach(println)
    }
}

基本操作
如果运算符使用冒号结尾，那么运算规则为从右向左

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        // 创建数组的另外一种方式
        val arr1 = Array(1,2,3,4)
        val arr2 = Array(5,6,7,8)
        // 添加数组元素，创建新数组
        val arr3: Array[Int] = arr1 :+ 5
        println( arr1 == arr3 ) // false

        val arr4: Array[Int] = arr1 ++: arr2
        // 添加集合
        val arr5: Array[Int] = arr1 ++ arr2

        arr4.foreach(println)
        println("****************")
        arr5.foreach(println)
        println("****************")
        // 多维数组
        var myMatrix = Array.ofDim[Int](3,3)
        myMatrix.foreach(list=>list.foreach(println))
        // 合并数组
        val arr6: Array[Int] = Array.concat(arr1, arr2)
        arr6.foreach(println)

        // 创建指定范围的数组
        val arr7: Array[Int] = Array.range(0,2)
        arr7.foreach(println)
    }
}

1.2 可变数组（ArrayBuffer）

import scala.collection.mutable.ArrayBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val buffer = new ArrayBuffer[Int]
        // 增加数据
        buffer.append(1,2,3,4)
        // 修改数据
        buffer.update(0,5)
        buffer(1) = 6
        // 删除数据
        val i: Int = buffer.remove(2)
        buffer.remove(2,2)
        // 查询数据
        println(buffer(3))
        // 循环集合
        for ( i <- buffer ) {
            println(i)
        }
    }
}

基本操作：

import scala.collection.mutable.ArrayBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val buffer1 = ArrayBuffer(1,2,3,4)
        val buffer2 = ArrayBuffer(5,6,7,8)

        val buffer3: ArrayBuffer[Int] = buffer1 += 5
        println( buffer1 eq buffer3 ) // true

        // 使用 ++ 运算符会产生新的集合数组
        val buffer4: ArrayBuffer[Int] = buffer1 ++ buffer2
        // 使用 ++= 运算符会更新之前的集合，不会产生新的数组
        val buffer5: ArrayBuffer[Int] = buffer1 ++= buffer2
        println( buffer1 eq buffer4 ) // false
        println( buffer1 eq buffer5 ) // true
    }
}

可变数组和不可变数组的转换

// 将不可变数组转换为可变数组
val buffer1: mutable.Buffer[Int] = array.toBuffer
// 将可变数组转换为不可变数组
val array1: Array[Int] = buffer.toArray

2 Seq集合

2.1 不可变List

基本语法：

object ScalaCollection{
    def main(args: Array[String]): Unit = {

        // Seq集合
        val list = List(1,2,3,4)

        // 增加数据
        val list1: List[Int] = list :+ 1
        println(list1 eq list)
        list1.foreach(println)
        val list2: List[Int] = 1 +: list
        list2.foreach(println)
        println("*****************")
        val list3: List[Int] = list.updated(1,5)
        println(list eq list3)
        List3.foreach(println)
    }
}

基本操作：

object ScalaCollection{
    def main(args: Array[String]): Unit = {

        // Seq集合
        val list1 = List(1,2,3,4)
        // 空集合
        val list2: List[Nothing] = List()
        val nil  = Nil
        println(list2 eq nil)

        // 创建集合
        val list3: List[Int]  = 1::2::3::Nil
        val list4: List[Int] = list1 ::: Nil

        // 连接集合
        val list5: List[Int] = List.concat(list3, list4)
        list5.foreach(println)

        // 创建一个指定重复数量的元素列表
        val list6: List[String] = List.fill[String](3)("a")
        list6.foreach(println)
    }
}

2.2 可变List（ListBuffer）

基本语法：

import scala.collection.mutable.ListBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        // 可变集合
        val buffer = new ListBuffer[Int]()
        // 增加数据
        buffer.append(1,2,3,4)
        // 修改数据
        buffer.update(1,3)
        // 删除数据
        buffer.remove(2)
        buffer.remove(2,2)
        // 获取数据
        println(buffer(1))
        // 遍历集合
        buffer.foreach(println)
    }
}

基本操作：

import scala.collection.mutable.ListBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        
        // 可变集合
        val buffer1 = ListBuffer(1,2,3,4)
        val buffer2 = ListBuffer(5,6,7,8)

        // 增加数据
        val buffer3: ListBuffer[Int] = buffer1 :+ 5
        val buffer4: ListBuffer[Int] = buffer1 += 5
        val buffer5: ListBuffer[Int] = buffer1 ++ buffer2
        val buffer6: ListBuffer[Int] = buffer1 ++= buffer2

        println( buffer5 eq buffer1 )
        println( buffer6 eq buffer1 )

        val buffer7: ListBuffer[Int] = buffer1 - 2
        val buffer8: ListBuffer[Int] = buffer1 -= 2
        println( buffer7 eq buffer1 )
        println( buffer8 eq buffer1 )
    }
}

转换：

import scala.collection.mutable
import scala.collection.mutable.ListBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val buffer = ListBuffer(1,2,3,4)
        val list = List(5,6,7,8)
 
        // 可变集合转变为不可变集合
        val list1: List[Int] = buffer.toList
        // 不可变集合转变为可变集合
        val buffer1: mutable.Buffer[Int] = list.toBuffer
    }
}

3 Set集合

3.1 不可变Set

基本语法：

object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val set1 = Set(1,2,3,4)
        val set2 = Set(5,6,7,8)

        // 增加数据
        val set3: Set[Int] = set1 + 5 + 6
        val set4: Set[Int] = set1.+(6,7,8)
        println( set1 eq set3 ) // false
        println( set1 eq set4 ) // false
        set4.foreach(println)
        // 删除数据
        val set5: Set[Int] = set1 - 2 - 3
        set5.foreach(println)

        val set6: Set[Int] = set1 ++ set2
        set6.foreach(println)
        println("********")
        val set7: Set[Int] = set2 ++: set1
        set7.foreach(println)
        println(set6 eq set7)
    }
}

基本操作

object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val set1 = Set(1,2,3,4)
        val set2 = Set(5,6,7,8)

        // 增加数据
        val set3: Set[Int] = set1 + 5 + 6
        val set4: Set[Int] = set1.+(6,7,8)
        println( set1 eq set3 ) // false
        println( set1 eq set4 ) // false
        set4.foreach(println)
        // 删除数据
        val set5: Set[Int] = set1 - 2 - 3
        set5.foreach(println)

        val set6: Set[Int] = set1 ++ set2
        set6.foreach(println)
        println("********")
        val set7: Set[Int] = set2 ++: set1
        set7.foreach(println)
        println(set6 eq set7)
    }
}

3.2 可变Set

基本语法

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val set1 = mutable.Set(1,2,3,4)
        val set2 = mutable.Set(5,6,7,8)

        // 增加数据
        set1.add(5)
        // 添加数据
        set1.update(6,true)
        println(set1.mkString(","))
        // 删除数据
        set1.update(3,false)
        println(set1.mkString(","))

        // 删除数据
        set1.remove(2)
        println(set1.mkString(","))

        // 遍历数据
        set1.foreach(println)
    }
}

基本操作

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val set1 = mutable.Set(1,2,3,4)
        val set2 = mutable.Set(4,5,6,7)

        // 交集
        val set3: mutable.Set[Int] = set1 & set2
        println(set3.mkString(","))
        // 差集
        val set4: mutable.Set[Int] = set1 &~ set2
        println(set4.mkString(","))
    }
}

4 Map集合

4.1 不可变Map

基本语法

object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val map1 = Map( "a" -> 1, "b" -> 2, "c" -> 3 )
        val map2 = Map( "d" -> 4, "e" -> 5, "f" -> 6 )

        // 添加数据
        val map3 = map1 + ("d" -> 4)
        println(map1 eq map3) // false

        // 删除数据
        val map4 = map3 - "d"
        println(map4.mkString(","))

        val map5: Map[String, Int] = map1 ++ map2
        println(map5 eq map1)
        println(map5.mkString(","))

        val map6: Map[String, Int] = map1 ++: map2
        println(map6 eq map1)
        println(map6.mkString(","))

        // 修改数据
        val map7: Map[String, Int] = map1.updated("b", 5)
        println(map7.mkString(","))

        // 遍历数据
        map1.foreach(println)
    }
}

4.2 不可变Map

基本语法

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val map1 = mutable.Map( "a" -> 1, "b" -> 2, "c" -> 3 )
        val map2 = mutable.Map( "d" -> 4, "e" -> 5, "f" -> 6 )

        // 添加数据
        map1.put("d", 4)
        val map3: mutable.Map[String, Int] = map1 + ("e" -> 4)
        println(map1 eq map3)
        val map4: mutable.Map[String, Int] = map1 += ("e" -> 5)
        println(map1 eq map4)

        // 修改数据
        map1.update("e",8)
        map1("e") = 8

        // 删除数据
        map1.remove("e")
        val map5: mutable.Map[String, Int] = map1 - "e"
        println(map1 eq map5)
        val map6: mutable.Map[String, Int] = map1 -= "e"
        println(map1 eq map6)
        // 清除集合
        map1.clear()
    }
}

基本操作

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val map1 = mutable.Map( "a" -> 1, "b" -> 2, "c" -> 3 )
        val map2 = mutable.Map( "d" -> 4, "e" -> 5, "f" -> 6 )

        val set: Set[(String, Int)] = map1.toSet
        val list: List[(String, Int)] = map1.toList
        val seq: Seq[(String, Int)] = map1.toSeq
        val array: Array[(String, Int)] = map1.toArray

        println(set.mkString(","))
        println(list.mkString(","))
        println(seq.mkString(","))
        println(array.mkString(","))

        println(map1.get("a"))
        println(map1.getOrElse("a", 0))

        println(map1.keys)
        println(map1.keySet)
        println(map1.keysIterator)
        println(map1.values)
        println(map1.valuesIterator)
    }
}

七元组

将多个无关的数据元素封装为一个整体，最多能容纳22个

object ScalaCollection{
    def main(args: Array[String]): Unit = {

        // 创建元组
        val tuple = (1, "zhangsan", 30)

        // 根据顺序号访问元组的数据
        println(tuple._1)
        println(tuple._2)
        println(tuple._3)
        // 迭代器
        val iterator: Iterator[Any] = tuple.productIterator

        // 根据索引访问元素
        tuple.productElement(0)
        // 获取整体
        println(tuple.x)

        // 如果元组的元素只有两个，那么我们称之为对偶元组，也称之为键值对
        val kv: (String, Int) = ("a", 1)
        val kv1: (String, Int) = "a" -> 1
        println( kv eq kv1 )
    }
}

八队列

进队：enqueue
出队：dequeue

import scala.collection.mutable
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())
    }
}

九并行

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val result1 = (0 to 100).map{x => Thread.currentThread.getName}
        val result2 = (0 to 100).par.map{x => Thread.currentThread.getName}

        println(result1)
        println(result2)
    }
}

十常用方法

1 常用方法

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(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))
        // 集合交集
        println("intersect => " + list.intersect(list1))
        // 集合差集
        println("diff => " + list.diff(list1))
        // 切分集合
        println("splitAt => " + list.splitAt(2))
        // 滚动
        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((x:Int,y:Int)=>{x+y}))
        println("reduce => " + list.reduce((x,y)=>{x+y}))
        println("reduce => " + list.reduce((x,y)=>x+y))
        println("reduce => " + list.reduce(_+_))
        // 集合简化规约(左)
        println("reduceLeft => " + list.reduceLeft(_+_))
        // 集合简化规约(右)
        println("reduceRight => " + list.reduceRight(_+_))
        // 集合折叠
        println("fold => " + list.fold(0)(_+_))
        // 集合折叠(左)
        println("foldLeft => " + list.foldLeft(0)(_+_))
        // 集合折叠(右)
        println("foldRight => " + list.foldRight(0)(_+_))
        // 集合扫描
        println("scan => " + list.scan(0)(_+_))
        // 集合扫描(左)
        println("scanLeft => " + list.scanLeft(0)(_+_))
        // 集合扫描(右)
        println("scanRight => " + list.scanRight(0)(_+_))
    }
}

4 功能函数

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

        // 集合映射
        println("map => " + list.map(x=>{x*2}))
        println("map => " + list.map(x=>x*2))
        println("map => " + list.map(_*2))
        // 集合扁平化
        val list1 = List(
            List(1,2),
            List(3,4)
        )
        println("flatten =>" + list1.flatten)
        // 集合扁平映射
        println("flatMap =>" + list1.flatMap(list=>list))
        // 集合过滤数据
        println("filter =>" + list.filter(_%2 == 0))
        // 集合分组数据
        println("groupBy =>" + list.groupBy(_%2))
        // 集合排序
        println("sortBy =>" + list.sortBy(num=>num)(Ordering.Int.reverse))
        println("sortWith =>" + list.sortWith((left, right) => {left < right}))
    }
}

十一案例实操（WordCount）

object ScalaWordCount{
    def main(args: Array[String]): Unit = {

        val list: List[String] = Source.fromFile("d:\user.json").getLines().toList

        val wordList: List[String] = list.flatMap(_.split(" "))

        val word2OneList: List[(String, Int)] = wordList.map((_,1))

        val word2ListMap: Map[String, List[(String, Int)]] = word2OneList.groupBy(_._1)

        val word2CountMap: Map[String, Int] = word2ListMap.map(
            kv => {
                (kv._1, kv._2.size)
            }
        )
        println(word2CountMap)
    }
}

十二模式匹配

执行匹配语句，所有的case都不匹配，执行case _分支

object ScalaMatch{
    def main(args: Array[String]): Unit = {
        var a: Int = 10
        var b: Int = 20
        var operator: Char = '+'
        var result = operator match {
            case '+' => a + b
            case '-' => a - b
            case '*' => a * b
            case '/' => a / b
            case _ => "illegal"
        }
        println(result)
    }
}

十三应用场景

变量应用

object ScalaMatch { 
    def main(args: Array[String]): Unit = {
        val (x, y) = (1, 2)
        println(s"x=$x,y=$y")

        val Array(first, second, _*) = Array(1, 7, 2, 9)
        println(s"first=$first,second=$second")

        val Person(name, age) = Person("zhangsan", 16)
        println(s"name=$name,age=$age")
    }
    case class Person(name: String, age: Int)
}

循环匹配

object ScalaMatch {
    def main(args: Array[String]): Unit = {
        val map = Map("A" -> 1, "B" -> 0, "C" -> 3)
        for ((k, v) <- map) { //直接将map中的k-v遍历出来
            println(k + " -> " + v) //3个
        }
        println("----------------------")
        //遍历value=0的 k-v ,如果v不是0,过滤
        for ((k, 0) <- map) {
            println(k + " --> " + 0) // B->0
        }
        println("----------------------")
        //if v == 0 是一个过滤的条件
        for ((k, v) <- map if v >= 1) {
            println(k + " ---> " + v) // A->1 和 c->33
        }
    }
}

函数参数

object ScalaMatch {
    def main(args: Array[String]): Unit = {
        val list = List(
            ("a", 1), ("b", 2), ("c", 3)
        )
        val list1 = list.map {
            case ( k, v ) => {
                (k, v*2)
            }
        }
        println(list1)
    }
}

偏函数

对数据进行筛选，符号条件的数据才会进行相应的处理

List(1, 2, 3, 4, 5, 6, "test").collect { case x: Int => x + 1 }.foreach(println)

异常

object ScalaException {
    def main(args: Array[String]): Unit = {
        try {
            var n= 10 / 0
        }catch {
            case ex: ArithmeticException=>{
                // 发生算术异常
                println("发生算术异常")
            }
            case ex: Exception=>{
                // 对异常处理
                println("发生了异常1")
                println("发生了异常2")
            }
        }finally {
            println("finally")
        }
    }
}

隐式转换

泛型

正则表达式

基本语法

object ScalaRegex {
    def main(args: Array[String]): Unit = {
        // 构建正则表达式
        val pattern = "Scala".r
        val str = "Scala is Scalable Language"

        // 匹配字符串 - 第一个
        println(pattern findFirstIn str)

        // 匹配字符串 - 所有
        val iterator: Regex.MatchIterator = pattern findAllIn str
        while ( iterator.hasNext ) {
            println(iterator.next())
        }

        println("***************************")
        // 匹配规则：大写，小写都可
        val pattern1 = new Regex("(S|s)cala")
        val str1 = "Scala is scalable Language"
        println((pattern1 findAllIn str1).mkString(","))
    }
}

一 变量和数据类型

数据类型

类型转换

二 流程控制

for循环

循环中断

三 函数式编程

基本语法

函数至简原则

四 高阶函数编程

五 面向对象编程

基础面向对象编程

1 包

2导入

3 类和属性

4 构造方法

高阶面向对象编程

1 继承

封装

抽象

单例对象

特质

扩展

六 集合

1 数组

1.1，不可变数组（Array）

1.2 可变数组（ArrayBuffer）

2 Seq集合

2.1 不可变List

2.2 可变List（ListBuffer）

3 Set集合

3.1 不可变Set

3.2 可变Set

4 Map集合

4.1 不可变Map

4.2 不可变Map

七 元组

八 队列

九 并行

十 常用方法

1 常用方法

2衍生集合

3 计算函数

4 功能函数

十一 案例实操（WordCount）

十二 模式匹配

十三 应用场景

变量应用

循环匹配

函数参数

偏函数

异常

隐式转换

泛型

正则表达式

基本语法

一变量和数据类型

二流程控制

三函数式编程

四高阶函数编程

五面向对象编程

六集合

七元组

八队列

九并行

十常用方法

十一案例实操（WordCount）

十二模式匹配

十三应用场景