完整代码示例-Scala 基础集合计算函数

Scala 基础集合计算函数代码示例

详细总结查看本文

package collectionsdemo

import scala.collection.mutable
import scala.collection.mutable.{ArrayBuffer, ListBuffer}

object NormalCollectionFunctionDemo {
  def main(args: Array[String]): Unit = {
    //常见集合 Array, List, Set, Map

    //可变和不可变的Array
    val arr = new Array[Int](5)
    val arr1: Array[Int] = Array(1,3,5,7,9)
    val arr2: Array[Int] = Array(1,3,5,7,9)

    val arrBuf1 = ArrayBuffer(11,33,55,77,99)
    val arrBuf2 = ArrayBuffer(22,44,66,88,1010)

    //可变和不可变的List
    val list1 = List(1,3,5,7,9)
    val list2 = List(2,4,6,8,10)

    val listBuf1 = ListBuffer(11,33,55,77,99)
    val listBuf2 = ListBuffer(22,44,66,88,1010)

    //可变和不可变的Set
    val set1 = Set(1,3,5,7,9)
    val set2 = Set(2,4,6,8,10)

    val mutableSet1: mutable.Set[Int] = mutable.Set(11, 33, 55, 77, 99)
    val mutableSet2: mutable.Set[Int] = mutable.Set(22,44,66,88,1010)

    //可变和 不可变的map
    val map1: Map[String, Int] = Map(("abc", 1), ("def", 3), ("ghi", 5), "jkl" -> 7, "mno" -> 9)
    val map2: Map[String, Int] = Map(("pqr", 2), ("stu", 4), ("vwx", 6), "z" -> 8, "bc" -> 10)

    val mutableMap1: mutable.Map[String, Int] = mutable.Map("xiaowang" -> 11, "xiaowu" -> 33, "xiaogou" -> 55,
                "xiaozhou" -> 77, ("xiaochen", 99))

    val mutableMap2: mutable.Map[String, Int] = mutable.Map("wang" -> 22, "wu" -> 44, "gou" -> 66,
      "zhou" -> 88, ("chen", 1010))

    //常见函数
    //1. 获取集合长度 xx.length xx.size
    // (Array, List均有length, size方法,  而Set, Map只有 size方法)
    println(arr1.length + list1.length + set1.size + map1.size)

    println(arrBuf1.length + listBuf1.length + mutableSet1.size + mutableMap1.size)

    //2. 循环遍历,  xx.foreach(println) 均可使用
    arr1.foreach(println)
    list1.foreach(println)
    set1.foreach(println)
    map1.foreach(println)

    arrBuf1.foreach(println)
    listBuf1.foreach(println)
    mutableSet1.foreach(println) //set 无序不可重复
    mutableMap1.foreach(println) // 按key排序, key唯一, value可重复,

    //3. 迭代器, xx.iterator 均可使用
    arr1.iterator
    list1.iterator
    set1.iterator

    val it =  map1.iterator
    while(it.hasNext){
      println(it.next() + "aaaa")
    }

    //4. mkString(连字符), xx.mkString 均可使用
    println( map1.mkString("; "))

    //5. 是否包含某key, xx.contains(k), 均可使用
    println(arr1.contains(1) + " " + list1.contains(1) + " " + set1.contains(1) + " " + map1.contains("abc"))

    //6. 获取集合的第一个元素, xx.head, 均可使用, map.head是第一个值对
    println(arr1.head + " " + list1.head + " " + set1.head + " " + map1.head)


    //7. 获取集合的尾部, xx.tail, 注意这里的尾部是指除了头部第一个值的部分, 均可使用, Array.tail返回的是地址值
    // 不是头的均是尾
    //[I@42e26948 List(3, 5, 7, 9) Set(1, 9, 7, 3) Map(mno -> 9, jkl -> 7, def -> 3, ghi -> 5)
    //加上mkString后,Array(3, 5, 7, 9) List(3, 5, 7, 9) Set(1, 9, 7, 3) Map(mno -> 9, jkl -> 7, def -> 3, ghi -> 5)
    println(arr1.tail.mkString("Array(", ", ", ")") + " " + list1.tail + " " + set1.tail + " " + map1.tail)

    //8.获取集合的最后一个元素, xx.last, 均可使用, Array.tail返回的是地址值
    println(arr1.last + " " + list1.last + " " + set1.last + " " + map1.last)

    //9. 反转, xx.reverse,  Set和Map不可使用
    println(arr1.reverse.mkString("Array(", ", ", ")") + " " + list1.reverse + " ")

    //10, 取前(后)n个元素, xx.take(n) xx.takeRight(n) , 均可使用, Array.take(n) 返回的是地址值
    println(arr1.take(2).mkString("Array(", ", ", ")") + " " + list1.take(2) + " " + set1.take(2) + " " + map1.take(2))
    println(arr1.takeRight(2).mkString("Array(", ", ", ")") + " " + list1.takeRight(2) + " " + set1.takeRight(2) + " " + map1.takeRight(2))

    //11. 去除前(后)n个元素, xx.drop(n) xx.dropRight(n) , 均可使用, Array.take(n) 返回的是地址值
    val ints: Array[Int] = arr1.drop(2)
    println(ints.mkString("Array(", ", ", ")") + " " + list1.drop(2) + " " + set1.drop(2) + " " + map1.drop(2))

    //12.并集, xx.union(yy), map使用 ++ 合并不可变map, 没有union方法, 但是 并集一般需要去重, 即把array, list转为Set 或者 使用 distict方法
    println(" 并集" + arr1.union(arr2).mkString("Array(",",",")") + " " + list1.union(list2) + " " + set1.union(set2) + " " + map1. ++(map2))
    println(mutableMap1 ++ mutableMap2)

    //13.差集, xx.diff(yy), 返回的是xx中与yy不同的数据, map不可用
    println(arr1.diff(arr2).mkString("Array(",",",")")+ " " + list1.diff(list2) + " " + set1.diff(set2) + " ")

    //14. 拉链, xx.zip(yy),  把xx和yy中的数两两结合, 多出的数据直接省略
    println(arr1.zip(arrBuf1).mkString("Array(",",",")"))
    println(list1.zip(listBuf1))
    println(set1.zip(mutableSet1))
    println(map1.zip(mutableMap1))

    //15. 滑窗, xx.sliding(窗口长度, 步长),  返回的是一个迭代器对象, 需要用迭代器或者增强for循环遍历出结果
    // 步长是指窗口每次滑动的距离, 即每个窗口之间的距离
    // 均可使用
    println( "滑动窗口" + map1.sliding(3))

//    while(map1.sliding(3).hasNext){
//      println(map1.sliding(3).next())
//    }

    //或者这样遍历
    map1.foreach(print)
    println
    for (elem <- map1.sliding(3,3)) {
      println(elem)
    }

    //当滑动窗口大小跟步长一样是时, 各个窗口之间就不会有交集 !!



    
    /// 集合常用函数 sum, min, max, sortBy(sortWith)
    println(arr1.sum)
    println(list1.sum)
    println(set1.sum)
   // map1.sum
    //println(map1.sum())   ??

    //1. min,max
    println(arr1.min + " ;" + arr1.max)
    println(list1.min+ " ;" + list1.max)
    println(set1.min+ " ;" + set1.max)

    //1.1 minBy, maxBy
    // 对待复合数据类型进行排序(元组)
    val list: List[(String, Int, Double)]= List(("小狗", 18, 172.5), ("小周", 13, 168.2), ("小陈", 23, 188), ("王二", 48, 156))

    println(list.minBy(tuple => tuple._2)) //最低年龄 (小周,13,168.2)
    println(list.maxBy(tuple => tuple._3)) //最高身高 (小陈,23,188.0)

    println(list.minBy(_._3)) //对函数进行最简化, 最低身高 (王二,48,156.0)

    println("map 比较" + map1.minBy((tuple:(String, Int)) => tuple._2))
    //2 sorted 自然排序
    println("sorted 自然排序: " + list1.sorted)
    传入隐式参数, 倒序排序
    println("sorted+ 隐式参数, 自然排序: " + list1.sorted(Ordering[Int].reverse))

    //2.1 sortBy(f) 默认顺序排序
    println(list.sortBy((tuple: (String, Int, Double)) => tuple._2)) //按照元组的第二个元素排序
    println(list.sortBy(tuple => tuple._2)) //简化
    println(list.sortBy(_._2)) //进一步简化

    
    //2.2 借助隐式参数(? 柯里化)
    println(list.sortBy(_._2)(Ordering[Int].reverse))

    //2.3 sortWith 自定义排序, sortWith(lt: (A, A) => Boolean)
    println("自定义排序" + list.sortWith((tuple1, tuple2) => tuple1._2 > tuple2._2))

    println("自定义排序: " + list.sortWith(_._2 > _._2)) //简化

    println(map1)

  }
}