Scala 容器

1.列表 

不可变List

（1）List默认为不可变集合

（2）创建一个List（数据有顺序，可重复）

（3）遍历List

（4）List增加数据

（5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化

（6）取指定数据

（7）空集合Nil

部分常用操作 

package com.bigdata.scala

object DemoList {
  def main(args: Array[String]): Unit = {
    //列表:列表中元素可以重复，不需要唯一，有序
    //创建列表
    val list01: List[Int] = List[Int](1, 2, 3, 4, 5, 6, 2, 3, 1)
    println(list01.head)
    println(list01.tail)
    println(list01.take(2))
    println(list01.min)
    println(list01.sum)
    println(list01.distinct) //去重
    println(list01.sorted)
    println(list01.contains(3))

    //list常用操作：map，flatMap，filter，groupby，sort相关，foreach

    //map：对List的每一条数据进行处理，传入一条，返回一条
    println(list01.map(i => i * i))

    //filter:过滤得到偶数
    println(list01.filter(int => int % 2 == 0))

    //flatMap：对数据进行扁平化处理，传入一条数据，返回一个集合
    val list02: List[String] = List("python,mysql,java", "hadoop,redis,clickhouse", "hbase,hive,flink")
    list02.flatMap(line=>line.split(",").toList).foreach(println)

    //groupby,分完组后返回map类型
    val list03: List[List[String]] = List(
      List("01", "zs1", "20", "文科一班")
      , List("02", "zs2", "20", "文科一班")
      , List("03", "zs3", "22", "理科一班")
      , List("04", "zs4", "22", "理科一班")
    )

    list03.groupBy(list => list(3)).map(kv=>{
      val clazz=kv._1
      val num=kv._2.length
      println(clazz,num)
    })

    // sort相关的
    /**
     * sorted：对List中所有的元素按照从小到大的顺序进行排列
     * sortBy：按照指定的字段进行排序
     * sortWith：按照指定的规则进行排序
     *
     */

    case class SortStu(id:String,name:String,age:Int)
    val stuList: List[SortStu] = List[SortStu](
      SortStu("001", "zs", 20)
      , SortStu("003", "ls", 22)
      , SortStu("002", "ww", 21)
      , SortStu("004", "ww", 20)
      , SortStu("005", "ww", 20)
    )
    // 按照age进行排序
    stuList.sortBy(s => s.age).foreach(println) // 从小到大
    stuList.sortBy(s => -s.age).foreach(println) // 从大到小

    println("=" * 50)
    // 先按照age从小到大进行排序，如果age相同 再按照id从大到小进行排序
    stuList.sortWith((stu01,stu02)=>{
      if(stu01.age==stu02.age){
        if(stu01.id>stu02.id){
          true
        }else{
          false
        }
      }else{
        stu01.age<stu02.age
      }
    }).foreach(println)

  }

}

可变list

    val lb: ListBuffer[Int] = ListBuffer[Int](1, 2, 4, 3, 4, 3)
    println(lb)
    lb.append(7)
    lb.append(8)
    lb+=9 //将9添加进去
    lb.insert(2,3) //在第二个位置加3
    lb-=3 //删除第一个出现的3
    lb.remove(4) //删除第几个位置
    lb(4)=100//修改
    lb.update(4,1000) //修改
    println(lb)

2.Tuple元组

不可变，有序，元素不唯一可以重复 最大长度22

package com.bigdata.scala

object DemoTuple {
  def main(args: Array[String]): Unit = {
    /**
     * Tuple:元组
     * 不可变，有序，元素不唯一可以重复
     * 最大长度22
     * */

    //创建元组
    val tuple: (Int, Int, Int, Int, Int) = Tuple5(1, 2, 3, 4, 5)
    println(tuple._3)

    val tuple1: (Int, Int, Int) = (1, 2, 3)

    //一元组的创建，只能用Tuple1
    val tuple2: Tuple1[Int] = Tuple1(1)
  }

}

 3.Set集合

元素是唯一的不会重复，会自动进行去重

不可变，无序的

import scala.collection.mutable

object Demo16Set {
  def main(args: Array[String]): Unit = {
    /**
     * Set：集合
     * 元素是唯一的不会重复，会自动进行去重
     * 不可变，无序的
     */

    // 定义一个Set
    val s1: Set[Int] = Set[Int](1, 2, 2, 2, 2, 4, 4, 4, 3, 5, 4, 0)
    println(s1)

    // 集合的运算
    val set01: Set[Int] = Set[Int](1, 2, 3, 4, 5, 6)
    val set02: Set[Int] = Set[Int](4, 5, 6, 7, 8, 9)

    // 交集、并集、差集等等
    println(set01 & set02)
    println(set01 | set02)
    println(set01.diff(set02))
    println(set02.diff(set01))

    // 可变的Set：
    val mSet01: mutable.Set[Int] = mutable.Set[Int](1, 2, 2, 2, 2, 4, 4, 4, 3, 5, 4, 0)
    println(mSet01)

    // 增加
    mSet01.add(5)
    mSet01.add(6)
    mSet01.add(-1)
    mSet01 += 7
    println(mSet01)
    // 删除
    mSet01.remove(-1)
    mSet01.remove(2)
    mSet01 -= 1
    println(mSet01)

    // 修改：无直接修改的方法，可以先remove再add来实现修改
    mSet01.remove(7)
    mSet01.add(8)
    println(mSet01)


  }

}

 4.map字典

1、不可变

2、Map中的每个元素都是KV形式

3、Map中的Key是不会重复的

4、无序的

适用于需要查询的场景

package com.bigdata.scala

import scala.collection.mutable

object DemoMap {
  def main(args: Array[String]): Unit = {
    //key值唯一
    val map: Map[String, Int] = Map[String, Int](("k1", 1), ("k2", 2), ("k3", 3), "k4" -> 4)

    //过滤
    map.filter(kv => {
      val value: Int = kv._2
      value > 2
    }).foreach(println)

    //通过key获取Value,获取不到返回-1
    println(map.getOrElse("k1", -1))
    println(map.getOrElse("kk1", -1))

    /**
     * get方法会返回一个Option类型的对象
     *
     * Option类型就两个子类：Some、None
     * 有值的情况下就将值包装成Some对象进行返回
     * 无值的情况就返回None
     *
     * 一般用于处理模棱两可的情况，有可能有值，也有可能没值
     * 所以就返回一个Option类型引起开发者注意
     * 否则就容易引起空指针异常的问题
     */
    println(map.get("k1"))
    println(map.get("kk1"))

    val maybeInt: Option[Int] = map.get("kk1")

    // 结合Scala中模式匹配match进行后续处理
    maybeInt match {
      case Some(v) =>
        println(v)
      case None =>
        println("Key不存在")

    }

    //可变的map
    val mMap01: mutable.Map[String, Int] = mutable.Map[String, Int](("k1", 1), ("k2", 2), ("k3", 3), "k4" -> 4)

    //增
    mMap01.put("k5", 5)
    mMap01.put("k2", 22) //存在即覆盖，相当于修改
    mMap01 += Tuple2("k6", 6)
    println(mMap01)

    //删
    mMap01-="k2"
    mMap01.remove("k1")
    println(mMap01)

    //改
    mMap01("k3")=33
    println(mMap01)
  }


}