19.集合常用方法

集合常用方法

基本属性和操作

是否包含

list.contains()

反转

list.reverse()

从左取前面n个元素

list.take()

从右取前面n个元素

list.takeright

根据条件取元素，与模式相关，之后补充。。。。。

list.collect

获取长度

list.length

生成迭代器

list.iterator

生成字符串

list.mkString(",")

list.map()

代码

        // 集合的常用方法
        val list = List(1, 2, 3, 4)

        println(s"list = ${list}")
        //长度
        println(s"list.length = ${list.length}")
        println(s"list.size = ${list.size}")

        //组成部分
  //      list :+5
//        5+:list
        // 头
        println(s"list.head = ${list.head}")
        // 尾 一个集合不是头就是尾
        println(s"list.tail = ${list.tail}")
        println(s"list.tail.tail = ${list.tail.tail}")
        // 最后一个
        println(s"list.last = ${list.last}")
        // 除了最后一个前面的
        println(s"list.init = ${list.init}")

        // 循环遍历，每个集合都有
        // list.iterator
        // list.foreach()

        println(list.mkString(","))

               val list = List(1, 2, 3, 4)

        // 功能
        println(s"list.sum = ${list.sum}")
        println(s"list.max = ${list.max}")
        println(s"list.product = ${list.product}")
        
        
        // 简单 功能 
        
        // 是否包含指定元素
        list.contains()
        println(s"list.contains(2) = ${list.contains(2)}")
        // 反转
        list.reverse
        println(s"list.reverse = ${list.reverse}")
        // 取数据
        println(s"list.take(2) = ${list.take(2)}")
        println(s"(list.takeRight()) = ${(list.takeRight(2))}")
        // 去重
        println(s"list.distinct = ${list.distinct}")
        
        // 根据条件采集数据
       // println(s"list.collect() = ${list.collect()}")

集合的计算函数

求和

list.sum

最大值

list.max

最小值

list.min

乘积

list.product

排序简单

list.sortBy

排序高级

list.sortWith

衍生集合

对一个或多个集合操作后返回一个集合

取头，返回一个元素

list.head

取尾巴，返回一个集合，该集合和原集合相比无头

list.tail

取最后一个元素

list.last

取初始数据，对应tail

list.init

交集,将两个集合中的所有元素放在一起，不去重

list.union(list1)

差集

list1.diff(list2)

zip,拉链，相同位置的组合在一起

list1.zip(list2)

滑动,连续两个元素的sum值

list1.sliding(2)

        val list1 = List(1, 2, 3, 4,3)

        val list2 = List(4, 5, 6, 7)


        // 并集

        println(s"list1.union(list2) = ${list1.union(list2)}")

        // 交集
        println(s"list1.intersect(list2) = ${list1.intersect(list2)}")

        // 差集   左边减去右边
        println(s"list1.diff(list2) = ${list1.diff(list2)}")
        
        // zip, 拉链,相同位置组合到一起
        println(s"list1.zip(list2) = ${list1.zip(list2)}")

        // 滑动，连续的三个数据的sum值, 集合的一部分当成一个整体=>窗口, sliding=>滑动窗口
        println(s"list1.sliding(2) = ${list1.sliding(2)}")

      //  println(s"list1.sliding(2,2) = ${list1.sliding(2, 2)")
        

计算高级函数

过滤,返回值为boolean的函数，为true就保存

list.filter()

转化/映射map(函数=>)对集合中的每一个元素做操作，返回一个新的集合

list.map()

扁平化,将一个集合中的小集合进行扁平化操作

list.flatten()

扁平化+映射 注：flatMap相当于先进行map操作，在进行flatten操作

list.flatMap()

分组(groupBy)，分组后为一个key value的形式

list.groupBy(x => x % 2)

简化（规约）

reduce

折叠 折叠， 将集合中的数据和集合外的数据进行聚合，结果类型为集合外的数据类型

list.fold(1)(_ + _)

看到中间值的折叠

list.scan(1)(_ + _)

        // 计算

        val list = List(1, 2, 3, 4)

        // 简化，规约，集合
        // 采用自定义的计算规则，对集合的数据进行聚合操作
        // 采用递归的运算
        println(s"list.reduce((x,y)=>{}) = ${list.reduce((x, y) => {x*y})}")
        // reduce方法要求返回值和参数类型保持一致
        println(s"  list.reduce(_-_) = ${list.reduce(_-_)}")
        println(s"list.reduce((x,y)=>{}) = ${list.reduce((x, y) => {x*10+y})}")
        // 从左往右聚合
        println(s"list.reduceLeft(_-_) = ${list.reduceLeft(_-_)}")
        // 从从右往左聚合
        // 底层是reversed.reduceLeft((x,y)=>option(y,x))
        // (1-(2-(3-(4-5))))
        println(s"list.reduceRight(_-_) = ${list.reduceRight(_-_)}")
        // 如果想要按照字符串相加呢？

 def main(args: Array[String]): Unit = {
        val list = List(1, 2, 3, 4)
        val list2 = List(5, 6, 7, 8)
        val list3 = List(list,list2)

        list.map()

        // 映射,将指定的数据转换为其他的数据
        def tansForm(i : Int): Int ={
            // 集合的map方法会将集合的每一个元素都执行map方法中的逻辑
            i*2
        }






       // println(s"list.map() = ${list.map(tansForm)}")
//        println(s"list.map（_*2） = ${list.map（_*2)}")


        // 扁平化,将一个整体拆分为一个一个的个体，
        println(s"list3.flatten = ${list3.flatten}")
      //  list3.map(list => list.map(_*2).flatten)
        list3.flatten.map(_*2)
        // 扁平映射
        // flatMap等同于将map和flatten融合在一起实现功能
        // 输入的参数为集合中的每一个数据
        // 输出的结果为扁平化的数据集合
        println(s" list3.flatMap(list=>list.map(_*2)) = ${ list3.flatMap(list=>list.map(_*2))}")

        // 过滤,将集合中所有的元素进行逻辑判断，如果为true，保留，false就舍弃
        println(s"list.filter(num=>num%2==0) = ${list.filter(num=>num%2==0)}")
        val list4 = List("spark","Scala","Hadoop")
        println(list4.filter(s=>s.startsWith("S")))
        // 分组
        // 通过指定的规则分组
        // 指定的规则的返回值作为分组的key
       println( list.groupBy(num=>num%2))
        println(list4.groupBy(_.substring(0,1)))

        // 排序,默认为升序
    //    println(list.sortBy(_.))
        // 降序
        //println(list.sortBy(_)(Ordering.Int.reverse))
        val list5 = List("1","2","11","3","22")
        println(list5.sortBy(_.toInt))

        // sortWith
        val student1 = new Student()
        val student2 = new Student()
        student1.id=1
        student2.id=2

        val students = List(student2, student1)

        println(students.sortBy(_.id))

        // 元组可以进行比较，先比较第一个再比较第二个，一次类推
        println(students.sortBy(stu=>(stu.id,stu.id)))

        // 排序复杂
        students.sortWith(
            (left,Right) =>{
                if (left.id<Right.id){
                    true
                }else if (left.id<Right.id){
                    left.name<Right.name
                }else{
                    false
                }

            }
        )

    }