第七章集合相关学习总结

最新推荐文章于 2024-09-15 17:14:23 发布

材料狗转行ing

最新推荐文章于 2024-09-15 17:14:23 发布

阅读量122

点赞数

分类专栏： scala 文章标签： scala

本文链接：https://blog.csdn.net/qq_32565167/article/details/125135863

版权

scala 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

第七章集合

1、集合种类

1、可变集合：可以在原来的集合中对元素增删改查

创建方式：1、通过new方法 new ArrayBuffer[元素类型]（数组长度）

2、通过apply方法 ArrayBuffer[元素类型]（初试元素）

获取数组的指定元素：数组名[角标]

修改指定元素的值

2、不可变集合：长度不可变，不能对原集合增删改查

创建方式：1、通过new方法 new Array[元素类型]（数组长度）

2、通过apply方法 Array[元素类型]（初试元素）

获取数组的指定元素：数组名[角标]

修改指定元素的值

2、数组

2.1不可变数组注意的点：

1、带=与不带=的方法区别

不带=：是添加、删除元素的时候,原集合不变,生成新集合
带=：是向原集合中添加、删除元素

2、打印数组需要 println(arr.toList)，否则打印地址值

3、创建数组方式2 ：使用伴生对象的 apply 方法（可省略apply）

object $01_immutableArray {
  def main(args: Array[String]): Unit = {

    //todo 方式1
    val arr1 = new Array[Int](5)
    println(arr1.toList)

    //todo 方式2 也可以使用伴生对象的 apply 方法, 源码如下，
    //  def apply(x: Int, xs: Int*): Array[Int] = {
    //    val array = new Array[Int](xs.length + 1)
    //    array(0) = x                                      -----给第一个元素赋值
    //    var i = 1
    //    for (x <- xs.iterator) { array(i) = x; i += 1 }    --内部进行迭代器循环赋值
    //    array
    //  }
    val arr2 = Array.apply(1,2,3)
    println(arr2.toList)


    println()
    println()

    //todo 测试不可变的数组以及单个+，多个++的区别
    val arr3: Array[Int] = arr1.+:(1)
    println(arr3.toList) //List(1, 0, 0, 0, 0, 0)
    println(arr1.toList) //List(0, 0, 0, 0, 0)

    println()
    println()

    //todo 测试++的添加其他数组
    val arr4: Array[Int] = arr1.++:(arr2)
    println(arr4.toList)
    val arr5: Array[Int] = arr4.++:(Array(4,5,6))
    println(arr5.toList)
    println(arr1.toList)

    //todo 给数组指定的角标赋值，没有破坏不可变的规则，并且在array的apply的方法内，也使用了赋值的方法
    //    println(arr5.toList)
    //    println(arr5)
    arr5(0)=999
    println(arr5.toList)

    println()
    println()

    //todo 不可变转可变
    //  带=与不带=的方法区别
    //   不带=是添加、删除元素的时候,原集合不变,生成新集合
    //   带=是向原集合中添加、删除元素
    var arr6: mutable.Buffer[Int] = arr5.toBuffer
    println(arr6)

    arr6.++(arr5)
    println(arr6)

    // 冒号在前、冒号在后以及不带冒号的区别
    // 冒号在前、不带冒号是将元素添加在集合最后面
    println(arr6)
    arr6.+=:(100)
    arr6.:+=(99)
    println(arr6) 
    //ArrayBuffer(100, 999, 5, 6, 1, 2, 3, 0, 0, 0, 0, 0, 99)

    //冒号在后是将元素添加在集合最前面,屁股前面
    arr6.++=:(arr2)
    println(arr6) //ArrayBuffer(1, 2, 3, 100, 999, 5, 6, 1, 2, 3, 0, 0, 0, 0, 0, 99)

	//arr6.:++=(arr3)
    arr6.++=(arr3) //这里使用++=直接放到最后，加:反而会报错
    println(arr6)
   //ArrayBuffer(1, 2, 3, 100, 999, 5, 6, 1, 2, 3, 0, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 0)
  }
}

2.2可变数组注意的点：

object $02_mutableArray {
  def main(args: Array[String]): Unit = {

    //todo 方式1
    var arr1 = new ArrayBuffer[Int](3)
    println(arr1)

    //todo 方式2
    var arr2 = ArrayBuffer.apply(1, 2, 6, 5)
    println(arr2) //可以直接打印，说明重写了toString方法

    //todo 添加元素 4中添加 以及带等号与不带等号
    //不带=，就只能重新创建新的数组看结果
    var ints1: ArrayBuffer[Int] = arr2.+:(100)
    var ints2: ArrayBuffer[Int] = arr2.:+(100)
    println(ints1)
    println(ints2)

    println("------------------------------------------------")
    var ints3: ArrayBuffer[Int] = arr2.++:(Array(100,200))
    var ints4: ArrayBuffer[Int] = arr2.++(Array(100,200))
    println(ints3)
    println(ints4)

    println("------------------------------------------------")
    //带= 的+=
    arr2.+=:(77)
    arr2.:+=(88)
    println(arr2) //ArrayBuffer(77, 1, 2, 6, 5, 88)
    println("------------------------------------------------")

    //带= 的++=
    arr2.++=:(Array(-120,200))
    arr2.++=(Array(100,9998))
    println(arr2) //ArrayBuffer(-120, 200, 77, 1, 2, 6, 5, 88, 100, 9998)

    //todo 删除元素 --与-
    //不带=，就只能重新创建新的数组看结果
    var ints5: ArrayBuffer[Int] = arr2.-(100)
    println(ints5)
    var ints6: ArrayBuffer[Int] = arr2.--(Array(200,2))
    println(ints6)

    println("------------------------------------------------")

    //带=，
    println(arr2) //ArrayBuffer(-120, 200, 77, 1, 2, 6, 5, 88, 100, 9998)
    arr2.-=(77)
    arr2.--=(Array(6,5))
    println(arr2) //ArrayBuffer(-120, 200, 1, 2, 88, 100, 9998)

    //todo 获取角标元素
    println(arr2(3))
    println(arr2(0))
    println("------------------------------------------------")

    //todo 修改元素
    arr2(0) = 120
    println(arr2)

    //todo 转换成不可变
    var arr3: Array[Int] = arr2.toArray
    println(arr3) //[I@2812cbfa
    println(arr3.toList)

  }
}

3、List

1、不可变List

注意点：

1、 +:= 相当于 list = list.+：(100) 已经生成了新的对象，list已经不是原来的list，前后的hashcode已经变化了

2、 :::相当于将添加一个集合的所有元素，等价于++

3、 Nil相当于是空的不可变list

4、 updated不改变原来的list

5、list添加元素使用 ::

6、list添加集合使用 :::

object $03_immutableList {

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

    //todo 不可变List创建方式，List[元素类型](初试元素,.....)
    // list不具备去重的功能
    var list = List[Int](1,1, 2, 34, 4, 5)
    println(list) //List(1, 1, 2, 34, 4, 5)
    println("------------------------------------------------")

    //todo 添加元素
    // todo :: 等价于在最前面添加元素，等价于+,要加个.
    val list2 = list.::(30)
    println(list)
    println(list2)
    println("------------------------------------------------")

    // todo :: 等价于在最前面添加元素40，30
    val list3 = 40 :: 30 :: list
    println(list)
    println(list3)
    println("------------------------------------------------")

    //todo Nil是空的,不可变list,可以加元素，可以加集合
    val list4 = 40 :: 30 :: Nil
    val l4: List[Int] = list3:::Nil
    println(list4)
    println(l4)
    println(list3)
    println("------------------------------------------------")

    //todo :::相当于将添加一个集合的所有元素，等价于++
    val list5 = List(1, 2, 3) ::: List(22, 22, 556)
    println(list5)
    println("------------------------------------------------")

    //todo 获取角标元素
    println(list4(0))
    println("------------------------------------------------")

    //todo 修改指定角标元素,实际就是在第一个位置加入了元素,并且要重新赋值
    var list6 = list.updated(0, 100)
    println(list6)
    println(list)
    println("------------------------------------------------")

    //todo +:= 相当于 list = list.+：(100) 已经生成了新的对象，前后的hashcode已经变化了
    //已经上=号了，发生了赋值操作
    println(list.hashCode()) //-1134771035
    println(list) //List(1, 2, 34, 4, 5)
    list.+:= (100)
    list = list.+:(100) //有=号，发生赋值操作
    println(list) //List(100, 100, 1, 2, 34, 4, 5)
    println(list.hashCode())//-563473480
    println("------------------------------------------------")
    
    //todo updated改变了一个元素，但是要生成一个新的集合才能看到变化
    // updated不影响原来的list
    var list8 = list3.updated(0, 98)
    println(list3) //List(40, 30, 1, 1, 2, 34, 4, 5)
    println(list8) //List(98, 30, 1, 1, 2, 34, 4, 5)
  }
}

2、可变list

注意点：

1、todo +:=方法等价于list = list.+:(40),可变list，前后对象不一样,在最前面加元素

2、listBuffer的删除元素与可变数组完全一样：-=、–=、-、–

object $04_MutableList {
  def main(args: Array[String]): Unit = {

    // todo apply 方法 (完整版)
    var list0 = ListBuffer.apply[Int](1, 2, 3, 4)
    var list = ListBuffer(1, 2, 3, 4)
    println(list)

    // todo new 方法
    val list1 = new ListBuffer[Int]()
    println(list1)
    println("-------------------------------------------")

    //todo 获取指定元素
    println(list(0))

    //todo 修改指定角标的元素
    list(0) = 200
    println(list)

    println("-------------------------------------------")

    //todo 添加删除元素与可变数组一样
    list.-(200)
    println(list)
    list.--(List(3,4))
    println(list)

    println("-------------------------------------------")
    //带=号可以对可变list进行删除
    println(list)
    list.-=(200)
    println(list)
    list.--=(List(3,4))
    println(list)
  }
}

4、set

1、不可变set（去重，无序）

注意点：

1、添加某个集合，该集合进入set后，元素顺序会改变，set是无序的,在:前后不受影响

object $05_immutableSet {
  def main(args: Array[String]): Unit = {

    //todo 不可变,去重,无序的set
    val set1 = Set(1,1,1,1,2,2,3,44,55,77,-1)
    val set: Set[String] = Set("123","skk","555")
    println(set1) //Set(1, 77, 2, 44, 3, -1, 55)
    println(set)
    println("-------------------------------------------------")

    //todo 添加元素
    var set2 =set1.+(100)
    println(set2)
    println(set1)
    println("-------------------------------------------------")

    //todo 添加集合 由于加入后是无序的,在:前后不受影响
    var set3 =set1.++(List(100,1,2,3,4))
    var set5 =set1.++:(List(3,6,8,-2,88))
    println(set3) //Set(1, 77, 2, 44, 3, -1, 55, 4, 100)
    println(set5) //Set(1, 77, 2, 44, 3, -1, 55, 4, 100)
    println("-------------------------------------------------")

    //todo 删除元素
    var set4 =set3.-(1)
    var set6 =set3.--(List(4,55,100))
    println(set4)//Set(77, 2, 44, 3, -1, 55, 4, 100)
    println(set6)//Set(1, 77, 2, 44, 3, -1)
    println(set3)//Set(1, 77, 2, 44, 3, -1, 55, 4, 100)
    //todo 不能根据角标获取元素
//    println(set(0))

  }
}

2、不可变set

object $06_mutableSet {
  def main(args: Array[String]): Unit = {

    // todo 去重,无序,可变,set
    val set1 = mutable.Set(1,2,2,2,3,4,5,6,7,999,-1)
    val set: mutable.Set[Int] = mutable.Set(1,2,2,3,3,4,4,5,9,-1)
    println(set1) //Set(999, 1, 5, 2, -1, 6, 3, 7, 4)
    println(set) //Set(9, 1, 5, 2, -1, 3, 4)
    println("-------------------------------------------------")

    //todo 添加元素(无序添加，:在哪都无所谓) .+=体现在可变，set1多了个1000
    // 添加了元素成功后（如果添加的重复元素不会改变hashcode），前后hashCode发生变化
    println(set.hashCode()) //-626535885
    println(set) //Set(9, 1, 5, 2, -1, 3, 4)
    set.+=(1000)
    println(set) //Set(9, 1, 1000, 5, 2, -1, 3, 4)
    println(set.hashCode())// -188546816
    println("-------------------------------------------------")

    set.++=(List(1000,1,99,2))
    println(set.hashCode())// -228787844
    println(set)

    set.++=(List(1000,1,99,2))
    println(set.hashCode())// -228787844
    println(set)

    set.++=(List(1000,1,99,2,-65))
    println(set.hashCode())// -1082369235
    println(set)
    println("-------------------------------------------------")

    //TODO 删除元素,注意带=号与不带=号
    set.-(1000)
    println(set) //Set(9, 99, 1, 1000, 5, 2, -1, 3, -65, 4)

    set.--(List(1,2))
    println(set) //Set(9, 99, 1, 1000, 5, 2, -1, 3, -65, 4)


    set.-=(1000)
    println(set) //Set(9, 99, 1, 5, 2, -1, 3, -65, 4)

    set.--=(List(1,2))
    println(set) //Set(9, 99, 5, -1, 3, -65, 4)
  }
}

5、Tuple–元组（重点）

object $07_Tuple {

  class Region(val name:String,val school:School)

  class School(val name:String, val clazz:Clazz)

  class Clazz(val name:String, val stu:Student)

  class Student(val name:String,val age:Int)

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

    /**
      *   （重点）元组的创建：
      *   1、通过()创建 （初始元素）
      *   2、通过->创建 只能创建二元元组 K->V
      *   元组的属性：
      *   1、元组创建了之后就不可变，元素个数，元素内容不可变
      *   2、元组最多存放22个元素
      *   3、将list内取出来的元素，封装到元组内,但是嵌套的集合，可读性差，
      */

    //todo 通过括号进行创建
    val t1 =("jack",20,"man")
    println(t1)
    println(t1._1)
    println(t1._2)
    println(t1._3)
    println("---------------------------------------")

    //todo 通过 -> 的方式创建二员元组：K-V
    val t2 = "tom" -> List(20,"man")
    println(t2)
    println(t2._1)
    println(t2._2)
    println("---------------------------------------")

    //todo 元组用来封装返回值的对象
    val list = List("1 张三 20 北京","2 李四 33 深圳","3 王五 40 深圳","4 赵六 50 北京")
    val list2 = for(element <- list) yield{
      val arr: Array[String] = element.split(" ")
      val age = arr(2)
      val city = arr(3)
      val name = arr(1)
      (age,city,name) //List((20,北京,张三), (33,深圳,李四), (40,深圳,王五), (50,北京,赵六))
    }
    println(list2)
    println("---------------------------------------")

    val list3 = List(
      new Region("宝安区",new School("宝安中学", new Clazz("王者峡谷班",new Student("安其拉",18)))),
      new Region("宝安区",new School("宝安中学", new Clazz("王者峡谷班",new Student("甄姬",18)))),
      new Region("宝安区",new School("宝安中学", new Clazz("王者峡谷班",new Student("妲己",18)))),
      new Region("宝安区",new School("宝安中学", new Clazz("王者峡谷班",new Student("王昭君",18)))),
      new Region("宝安区",new School("宝安中学", new Clazz("王者峡谷班",new Student("扁鹊",18)))),
      new Region("sss",new School("一中",new Clazz("一班",new Student("小明",age = 20))))
    )

    val l1: List[String] = for(region <- list3) yield{
      region.school.clazz.stu.name
    }
    println(l1)

    val l2: List[Int] = for(region <- list3) yield{
      //这些事外面class定义的参数名，用参数名进行调用
      region.school.clazz.stu.age
    }
    println(l2) //List(18, 18, 18, 18, 18, 20)
    println("---------------------------------------")

    //todo 元组的用法
    val list4 = List(
      ("宝安区",("宝安中学", ("王者峡谷班",("安其拉",18)))),
      ("宝安区",("宝安中学", ("王者峡谷班",("甄姬",18)))),
      ("宝安区",("宝安中学", ("王者峡谷班",("妲己",18)))),
      ("宝安区",("宝安中学", ("王者峡谷班",("王昭君",18)))),

      ("china",("一中",("1班",("风景",12))))
    )

    val nameList = for(tuple <- list4) yield{
      //第一个._2是("一中",("1班",("风景",12)))
      //第二个._2是("1班",("风景",12))
      //第三个个._2是("风景",12)
      //第四个个._1是"风景"
      //循环获取list4的内容
      tuple._2._2._2._1
    }

    println(nameList) //List(安其拉, 甄姬, 妲己, 王昭君, 风景)
  }
}

6、map

1、不可变map

object $08_immutableMap {
  def main(args: Array[String]): Unit = {

    //todo 不可变的map创建， Map[K的类型，V的类型]（k->V,k->V,k->V）
    //todo key去重,无序
    val map1 = Map[String,Int]("jack"->1,"dd"->1,"cc"->1,"jack"->1,"tom"->1)
    println(map1)

    val map: Map[Int, String] = Map(1 -> "tom",1 -> "tom",1 -> "tom",2 -> "tom",3 -> "jack")
    println(map) //Map(1 -> tom, 2 -> tom, 3 -> jack)
    println("-------------------------------------------------")

    //todo 添加元素
//    val map2 = map1.+("jia"->12)
    val map2 = map.+(4 -> "kilr")
    println(map2)//Map(1 -> tom, 2 -> tom, 3 -> jack, 4 -> kilr)
    println("-------------------------------------------------")

    //todo 添加集合
    val map3 = map1.++(List("op"->12,"ee"->1,"fc"->1))
    val map4 = map1.++:(List("op"->12,"ee"->99,"fc"->1))
    println(map3) //Map(jack -> 1, fc -> 1, tom -> 1, cc -> 1, ee -> 1, dd -> 1, op -> 12)
    println(map4)

    val m1 = map.++(List(4 -> "kilr",5 -> "kilr",6 -> "kilr"))
    println(m1) //Map(5 -> kilr, 1 -> tom, 6 -> kilr, 2 -> tom, 3 -> jack, 4 -> kilr)
    println("-------------------------------------------------")

    //todo 删除元素,指定key删除
    val map5 = map4.-("op")
    println(map5)
    val map6 = map4.--(List("op","fc"))
    println(map6)
    println("-------------------------------------------------")

    println(m1)
    val m2: Map[Int, String] = m1.-(1)
    println(m2)
    val m3: Map[Int, String] = m1.--(List(1,2))
    println(m3)
    println("-------------------------------------------------")

    //todo getOrElse()方法实现，根据key获取value存在key就返回value，不存在返回0
    println(m1.getOrElse(1,0)) //tom
    println(m1.getOrElse(100,0)) //0

    //todo 修改map指定的key下的value值
    val m4: Map[Int, String] = m1.updated(1,"klit")
    println(m4)
  }
}

2、可变map

要注意的地方：

1、添加元素不是用+，而是用put方法

2、添加集合使用++=

object $09_mutableMap {
  def main(args: Array[String]): Unit = {

    //todo map创建， Map[K的类型，V的类型]（k->V,k->V,k->V）
    //todo 去重,无序
    val map1 = mutable.Map[String, Int](
      "jack" -> 1,
      "dd" -> 1,
      "cc" -> 1,
      "jack" -> 1,
      "tom" -> 1
    )

    println(map1) //Map(jack -> 1, tom -> 1, cc -> 1, dd -> 1)
    val map: mutable.Map[Int, String] = mutable.Map(1 -> "tom", 1 -> "tom", 2 -> "tom", 3 -> "jack")
    println(map)
    println("-----------------------------------")

    //todo 添加元素 -- put方法，效果和+=类似
    map1.put("asdasd", 1200)
    map1.put("asd3", 110)
    map1.put("as2", 199)
    println(map1) //Map(as2 -> 199, jack -> 1, tom -> 1, cc -> 1, asdasd -> 1200, dd -> 1, asd3 -> 110)
    println("-----------------------------------")

    println(map)
    map.put(4,"jack")
    map.put(5,"jack")
    println(map)
    println("-----------------------------------")
    
    //todo 删除元素，remove(key)方法与-=类似
    println(map)
    map.remove(1)
    println(map)
  }
}

7、队列

1、不可变队列

注意的点：

1、添加元素enqueue

2、删除元素dequeue

object $10_immutableQueue {
  def main(args: Array[String]): Unit = {

    //todo 不可变队列：Queue[元素类型](初试元素)
    val queue: Queue[Int] = Queue[Int](1,2,3,4,5)
    println(queue)

    val q1 = Queue(9,8,7,6,5,4)
    println(q1)
    println("------------------------------------")

    //todo 添加元素
    val queue1: Queue[Int] = queue.enqueue(111)
    println(queue1)

    val q2: Queue[Int] = q1.enqueue(10)
    println(q1) //Queue(9, 8, 7, 6, 5, 4)
    println(q2) //Queue(9, 8, 7, 6, 5, 4, 10)
    println("------------------------------------")

    //todo 删除元素 由于是不可变的，所以原来的队列没变
    val dq1: (Int, Queue[Int]) = q1.dequeue
    println(dq1) //(9,Queue(8, 7, 6, 5, 4))
    println(q1.dequeue) //(9,Queue(8, 7, 6, 5, 4))
    println("------------------------------------")

    //todo 根据角标获取值
    println(q1(0))
    println("------------------------------------")

    //todo 修改角标对应的值，但是原来的q1没变
    println(q1.updated(0, 99)) //Queue(99, 8, 7, 6, 5, 4)
    println(q1)
  }
}

2、可变队列

object $11_mutableQueue {

  def main(args: Array[String]): Unit = {
    //todo 不可变队列：Queue[元素类型](初始元素)
     val q: mutable.Queue[Int] = mutable.Queue[Int](1,2,3,4,5)
    println(q)
    println("------------------------------------")

    //todo 添加元素
    println(q)
    q.enqueue(11,22,44,67,1100)
    println(q)
    println("------------------------------------")

    //todo 删除元素第一个进入的元素，相当于fifo先进先出
    println(q) //Queue(1, 2, 3, 4, 5, 11, 22, 44, 67, 1100)
    q.dequeue()
    println(q) //Queue(2, 3, 4, 5, 11, 22, 44, 67, 1100)
    println("------------------------------------")

    //todo 获取角标元素
    println(q(1))
    println("------------------------------------")

    //todo 修改角标元素
    println(q)
    q(2) = 1000
    println(q)
    println("------------------------------------")
  }
}

8、集合的属性

注意的点：

1、一次性迭代器：list2.toIterator

2、重复使用迭代器：list.toIterable

object $12_collectionField {
  def main(args: Array[String]): Unit = {


    val list = List[Int](1,2,3,4,-1,6,9)
    val list2 = List[Int](1,2,3,4,-1,6,9)

    //获取集合的长度
    println(list.size)
    println("--------------------------------")

    //判断集合是否为空
    println(list.isEmpty)
    println("--------------------------------")

    //判断集合是否包含某个元素
    println(list.contains(3))
    println(list.contains(5)) //false
    println("--------------------------------")

    //将集合元素按照符号，拼接成字符串
    println(list.mkString("-"))
    println(list.mkString("--"))
    println("--------------------------------")

    //迭代器1:Iterator一次性迭代器,单词程序运行只能被调用一次
    val it1: Iterator[Int] = list2.toIterator
    while(it1.hasNext){
      print(it1.next()+" ")
    }
    //下面这个迭代器没有打印任何结果
    while(it1.hasNext){
      print(it1.next()+" ")
    }

    println()
    println("--------------------------------")


    //迭代器1:Iterable重复使用迭代器
    val it = list.toIterable

    for(i <- it){
      print(s"${i} ")
    }

    println()

    for(i <- it){
      print(s"${i} ")
    }
  }
}

9、操作集合（重点）

注意的点：

1、滑窗方法

object $13_1 {
  def main(x : Array[String]):Unit={

    val list = List[Int](1,1,2,3,4,-1,6,9)
    println(list) //List(1, 1, 2, 3, 4, -1, 6, 9)

    //todo 去重 ******
    println(list.distinct) //List(1, 2, 3, 4, -1, 6, 9)

    //todo 获取指定范围的所有元素，前闭区间，后开区间 ******
    println(list)
    println(list.slice(0, 4)) // List(1, 1, 2, 3)

    //todo 获取第一个元素 ******
    println(list.head) //1

    //todo 获取最后一个个元素 ******
    println(list.last) //9

    //todo 翻转集合 ******
    println(list.reverse) //List(9, 6, -1, 4, 3, 2, 1, 1)
    
//todo 滑窗方法，按照3个元素一组，一次滑动两个元素的距离 ******
    val iterator: Iterator[List[Int]] = list.sliding(3,2)
    println(list) //List(1, 1, 2, 3, 4, -1, 6, 9)
    println(iterator.toList) //List(List(1, 1, 2), List(2, 3, 4), List(4, -1, 6), List(6, 9))
  }
}

10、初级集合方法

object $14_CollectionLowerFunction {
  def main(args: Array[String]): Unit = {

    val list = List[Int](1,1,2,3,4,-1,6,9)

    //todo 获取最大值
    println(list.max)
    println("--------------------------------")

    //todo 获取最小值
    println(list.min)
    println("--------------------------------")

    //todo 求和
    println(list.sum)
    println("--------------------------------")

    //按照string的字典序排序,d显然是list中最大的
    val list1 = List(("age",16,1),("b",18,19000),("c",199,1000),("d",16,1000))
    println(list1.max) //(d,16,1000)
    println("--------------------------------")

    //todo 指定函数的类型位三元元祖，函数的本体为x._3,取元组的第三个值
    var func = (x:(String,Int,Int)) => x._3
    //todo maxBy(func)根据func指定的值的最大值
    println(list1.maxBy(func)) //(b,18,19000)
    println("--------------------------------")

    //todo minBy 根据func指定的值的计算最小值
    println(list1.minBy(func)) //(age,16,1)
    println("--------------------------------")

    //todo 排序 默认升序
    println(list.sorted)
    println("--------------------------------")

    //todo 降序,翻转升序的结果就是降序
    println(list.sorted.reverse)
    println("--------------------------------")

    //todo 对元组构成的集合，使用sortBy ******

    val list2 = List(("age",16,1),("b",18,19000),("c",199,1000),("d",16,1000))
    println(list1.sortBy((x:(String,Int,Int)) => x._3)) //根据指定元素排序

    println(list1.sortBy(x=>x))//根据元组自身排序

    println(list1.sortBy(func).reverse) //将排序结果翻转

    println(list.sortBy(x => x))
    println("--------------------------------")

//todo sortWith ,x>y ，则x>y升序
println(list)
println(list.sortWith((x,y) => x>y))//List(9, 6, 4, 3, 2, 1, 1, -1)
println(list.sortWith((x,y) => y>x))//List(-1, 1, 1, 2, 3, 4, 6, 9)
  }
}

11、高级集合方法

1、map方法，可以将数据进行转换，例如，扩大10倍，集合个数不变

2、flatMap = map + flatten 先进行map操作，返回集合元素，再进行压平，从数据的特征观察到，使用这个方法的前提是，数据能够在内部进行切割，切割完成后组装成一个两层结构，压第二层才能产生结果

3、groupBy：经过groupBy处理的list，转换为，k为分组参照，v为整个元组的内容，其结构就是二元元组的结构

4、filter：传进去的func的返回值类型必须是boolean

object $15_CollectionHightFunction {
  def main(args: Array[String]): Unit = {

    //todo map 生成一个新集合，新集合的个数 = 原集合元素个数
    //todo map 一般用于数据类型/值的转换（一对一转换）
    //todo map 类似于sql的select
    //todo map 类似带有yield的for循环
    val list = List[Int](1,1,2,3,4,-1,6,9)
    val list2: List[Int] = list.map(x=>{
      println(s"x=${x}")
      x*10
    } )
    println(list2)
    println("--------------------------------")

    val l1 = List(2,3,5,80,9,-1)
    val l2 = l1.map(x => {
      print(s"x=${x} ")
      x*100 //返回值，说明map自带yield
    })
    println()
    println(l2)
    println("--------------------------------")

    //todo foreach 用于集合的遍历
    //todo foreach(func:集合类型=> Unit) 用于集合的遍历
    //todo foreach不带有yield的for循环
    list.foreach(x => print(x+" "))
    list.foreach(x => print(s"${x} "))
    println()
    println("--------------------------------")

    //todo flatten 类似于sql的explode
    //todo flatten 只能作用于嵌套的集合，
    //todo flatten 只能压第二层
    val list3 = List(List[Int](1,1,2,3,4,-1,6,9),
                                  List[Int](22,2,3,4,-1,6,9))
    val flatten: List[Int] = list3.flatten
    println(flatten) //List(1, 1, 2, 3, 4, -1, 6, 9, 22, 2, 3, 4, -1, 6, 9)
    println("--------------------------------")


    //todo map + flatten操作：数据转换 + 数据压平
    val list4 = List("hello java spark","hello java hadoop","hello java java")
    val list5: List[Array[String]] = list4.map(x => x.split(" "))

    //List(hello, java, spark) List(hello, java, hadoop) List(hello, java, java)
    list5.foreach(x=> print(x.toList+" ")) //结果在上面的注释

    println()
    println(list5.flatten) //List(hello, java, spark, hello, java, hadoop, hello, java, java)
    println("--------------------------------")

    //todo flatMap = map + flatten 先进行map操作，返回集合元素，再进行压平
    // 从数据的特征观察到，使用这个方法的前提是，数据能够在内部进行切割，切割完成后组装成一个两层结构，压第二层才能产生结果
    println(list4.flatMap(x => x.split(" "))) //List(hello, java, spark, hello, java, hadoop, hello, java, java)
    println("--------------------------------")

    //todo filter 按照指定条件过滤
    //todo filter func:集合元素类型=>Boolean
    //todo filter 类似sql的where
    val list6 = List(1,2,3,4,5,9,10)
    println(list6.filter(x => x % 2 == 0))
    println(list6.filter(x => x % 3 == 0))
    println("--------------------------------")

    //todo group by 按照指定的字段分组
    //todo group by(func:集合元素类型 => key)
    //todo group by 生成了Map集合，K是函数的返回值，V是对应值
    val list7 = List(("sss",123),("jack",90),("tom",102),("tom",103))
    val list8: Map[String, List[(String, Int)]] = list7.groupBy(x=>x._1)
    val map: Map[String, Int] = list8.map(x => {
      (x._1, x._2.size)
    })
    println(map)
    println("--------------------------------")

    val l7 = List(("sss",123),("jack",90),("tom",102),("tom",103))

    //由于list内部是元组结构，所以指定其第一个值作为分组的参考，k为分组参照，v为整个元组的内容
    val m1 = l7.groupBy(x=>x._1)
    m1.foreach(x=> {
      println(x._1)
      println(x._2)
    })
    //遍历结果如下：
    //jack
    //List((jack,90))
    //sss
    //List((sss,123))
    //tom
    //List((tom,102), (tom,103))
    println("--------------------------------")

    //todo reduce 聚合函数
    //todo reduce 第一个参数代表上一次聚合的结果，第一次聚合的时候，参数初始值= 集合第一个元素
    //todo reduce 第二个参数为待聚合的参数
    println(list)

    val r1 = list.reduce((t, c) => {
      println(s"t=${t} c=${c}")
      t + c
    })
    println(r1)
    //List(1, 1, 2, 3, 4, -1, 6, 9)
    //t=1 c=1
    //t=2 c=2
    //t=4 c=3
    //t=7 c=4
    //t=11 c=-1
    //t=10 c=6
    //t=16 c=9
    //25
  }
}

12、word count案例

hello java python hadoop kafka scala hello java python hadoop
flume scala hello java python hadoop kafka scala hello java python hadoop
hadoop flume scala hello java python kafka scala hello java python
scala hello java python hadoop kafka scala hello java python hadoop
python hadoop kafka scala hello java python hadoop
kafka scala hello java python hadoop kafka scala hello java python hadoop

object $16_1 {
  def main(args: Array[String]): Unit = {
      //1、读取文件
      val list: List[String] = Source.fromFile("data/hello.txt").getLines().toList
      println(list)

      //2、切割炸开
      val list1: List[String] = list.flatMap(x=>x.split(" "))
      println(list1)

      //3、分组,结果会转换成map结构，k是分组参考，v是内容,结构就是二元元组结构
      val mapGB: Map[String, List[String]] = list1.groupBy(x=>x)
      println(mapGB)

      //4、统计，map转换
    val map: Map[String, Int] = mapGB.map(x => {
      //将分组后的结果封装成如下的k-v结构的二元元组，
      (x._1, x._2.size)
    })
      //5、遍历
      map.foreach(x => println(s"${x._1} = ${x._2}") )
  }
}