1.集合常用方法

class Test_Func {

}
object Test_Func{
  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3, 4, 5)//定义一个List集合
    val set = Set(6, 7, 8, 9)//定义一个Set集合

    //1.获取集合长度，length方法
    val lengthList = list.length
    //2.获取集合大小,size方法
    val sizeList = list.size
    println(lengthList)
    println(sizeList)

    //3.循环遍历 foreach
    list.foreach(println)

    //4.迭代器遍历 iterator
    val iterator = list.iterator
    while (iterator.hasNext){
      val i = iterator.next()
      println(i)
    }

    //5.生成字符串方法 
    //mkString
    val string = list.mkString

    //6.是否包含元素contains
    val bool = list.contains(2)
    println(bool)
  }
}

2.衍生集合

衍生集合，顾名思义，在scala中，调用一个方法，原集合保持不变，生成一个新的集合。

   class Test_Change {

}
object Test_Change
{
  def main(args: Array[String]): Unit = {
    val list1 = List(1, 2, 3, 4)
    val list2 = List(4, 5, 6, 7)

    //获取集合的头
    //即获取第一个元素
    val head = list1.head
    println(head)

    //获取集合的尾部
    val tail = list1.tail
    println(tail)

    //获取集合的最后一个元素
    val last = list1.last
    println(last)

    //获取集合初始数据(不包含最后一个)
    val init = list1.init
    println(init)

    //反转
    val reverse = list2.reverse
    println(reverse)
    val reverse1 = (1 to 5).reverse
    println(reverse1)

    //取前(后)n个元素
    val left1 = list2.take(2)//从左边拿2个元素
    println(left1)
    val right1 = list2.takeRight(2)//从右边拿2个元素
    println(right1)

    //去掉前(后)n个元素
    val left2 = list2.drop(2)//从左边拿
    val right2 = list2.dropRight(2)//从右边拿
    
    //并集
    val unionList = list2.union(list1)
    println(unionList)
    
    //交集
    val intersectList = list2.intersect(list1)
    println(intersectList)
    
    //差集
    val diffList = list2.diff(list1)
    println(diffList)

	    //拉链
    //两个集合进行拉链的时候，如果有一个集合元素过多的话，会被扔掉
    val zipList = list2.zip(list1)
    println(zipList)

    //滑窗
    //给定一个数组(-200,50,-10,30,0,-88)求出任意相邻的三个数，乘积最大的是哪三个
    //根据题，以三个元素为一个窗口
    //sliding函数第一个参数为窗口大小，这里为3
    val list3 = List(-200, 50, -10, 30, 0, -88)
    val iterator:Iterator[List[Int]] = list3.sliding(3)
    var result=0;
    for(item<-iterator)
      {
        //product方法是用于算出集合的乘积
        if(item.product>result)
          {
            result=item.product
          }
      }
      println(result)
  }
}

滑窗运行结果：

可以看到sliding函数将list3集合分成了四个有三个元素的集合，之后通过product方法对每个集合求乘积，由此来将最大的乘积算出。

3.集合的常用函数

    val list4 = List(1, 2, 3, 4, 5)
    //求和
    val sum = list4.sum
    //求乘积
    val product = list4.product
    //最大值
    val max = list4.max
    //最小值
    val min = list4.min

过滤
所有的高级函数，都有一个默认的foreach逻辑将集合中的元素作为填写函数的传入参数，得到返回结果。如果为true则保留，如果为false，则删除

    val list = List(1, 2, 3, 5, 6, 8, 9, 10)
    val reList = list.filter((i: Int) => i % 2 == 0)
    println(reList)

map转化结构
可以在map中设定输出结构，来对集合进行转化

 val list2 = list.map((i: Int) => i * 2)
    println(list2)
    val list3:List[(String,Int)] = list.map((i: Int) => ("我是", i))
    println(list3)

扁平化
对于集合嵌套的情况下，使用炸裂函数来将嵌套的集合打散。即将嵌套的集合转换为一个集合。

    val list4 = List(List(1, 2, 3), List(1, 5, 6), List(2, 3, 6))
    val flatten:List[Int] = list4.flatten
    println(flatten)
    //元素必须是可以拆分的集合才能使用扁平化
    //字符串可以看作为char的数组
    val list5 = List("Hello", "王总")
    val flatten1 = list5.flatten
    println(flatten1)
    //将长字符串打散为多个单词
    val list6 = List("hello world", "hello scala", "hello spark")
    //需要将"hello world"转换为List("Hello","world")
    val list8 = list6.map((line: String) => {
      val strings: Array[String] = line.split(",")
      strings.toList
    })
    println(list8)
    val flatten2 = list8.flatten
    println(flatten2)

flatMap
flatMap方法就是map+flatten方法的结合，先将结合转换为设定的结构，之后再通过flatten来对集合进行打散。

    val list9 = list6.flatMap((line: String) => {
      val strings: Array[String] = line.split(",")
      strings.toList
    })
    println(list9)

分组函数group by
将多条数据聚合成一条数据，以groupby函数中的返回值的类型为key的类型

    val list10: List[(Int, Int)] = List((1, 10), (2, 30), (3, 30),(1,11),(2,32))
    val map: Map[Int, List[(Int, Int)]] = list10.groupBy((tuple: (Int, Int)) => tuple._1)

    println(map)

    //以奇偶数来进行分组
    val list11 = List(1, 2, 3, 4, 5, 6)
    val groupByOdd = list11.groupBy((i: Int) => i % 2)
    println(groupByOdd)

归约
归约的用法和mapreduce中的reduce方法大致相同。将集合中的元素进行累加操作。

    //reduce方法返回结果的类型和当前元素的类型一致
    val list12 = List(1, 5, 6, 7, 8)
    //如下函数就是一个归约
    var sum=0
    for(elem<-list12)
      {
        sum+=elem
      }
      println(sum)
    //可以使用reduce方法来实现上述代码的逻辑
    //res表示结果，elem表示当前元素
    val i = list12.reduce((res: Int, elem: Int) => res + elem)
    println(i)
    //reduce方法将第一个元素作为初始值进行累加即1+5*2+6*2......
    list12.reduce((res: Int, elem: Int) => res + elem*2)