scala集合常用函数

1、创建集合

map：Map(a -> 1, b -> 2)
map1：Map(a -> 1, b -> 2, c -> 3)
list：List(1, 2, 3, 4)
list1：List(5, 2, 3, 6, 7)
set：Set(1, 3, 5, 6)
set1：Set(5, 9, 3, 8, 4)
arr：a,b,c
arr1：d,b,c,e

object Main extends App {
    val map = Map("a" -> 1,"b" -> 2)
    val map1 = Map("a" -> 1,"b" -> 2,"c" -> 3)
    val list = List(1,2,3,4)
    val list1 = List(5,2,3,6,7)
    val set = Set(1,3,5,6)
    val set1 = Set(8,3,5,4,9)
    val arr = Array("a","b","c")
    val arr1 = Array("d","b","c","e")
    //获取集合
    println("map：" + map)
    println("map1：" + map1)
    println("list：" + list)
    println("list1：" + list1)
    println("set：" + set)
    println("set1：" + set1)
    println("arr：" + arr.mkString(","))
    println("arr1：" + arr1.mkString(","))
}

2、函数实操

• 获取集合长度/大小：Set与Map用size；List用length；Array都可以用

object Main extends App {
    val map = Map("a" -> 1,"b" -> 2)
    val map1 = Map("a" -> 1,"b" -> 2,"c" -> 3)
    val list = List(1,2,3,4)
    val list1 = List(5,2,3,6,7)
    val set = Set(1,3,5,6)
    val set1 = Set(8,3,5,4,9)
    val arr = Array("a","b","c")
    val arr1 = Array("d","b","c","e")
    //Map、Set、Array的大小用size
    println("map的size：" + map.size)
    println("set的size：" + set.size)
    println("arr的size：" + arr.size)
    
    //Array、List长度用length
    println("list长度：" + list.length)
    println("arr长度：" + arr.length)
}
map的size：2
set的size：4
arr的size：3
list长度：4
arr长度：3

• 遍历元素：foreach(println)、迭代器iterator，或者一般for循环，所有集合均适用

object Main extends App {
    //遍历元素foreach(println)
    println("map遍历：") 
    map.foreach(println)
    println("list遍历：") 
    list.foreach(println)
    println("set遍历：") 
    set.foreach(println)
    println("arr遍历：") 
    arr.foreach(println)
	println("============")
    //迭代器iterator
    println("map迭代")
    for (i <- map.iterator) println(i)
    println("list迭代")
    for (i <- list.iterator) println(i)
    println("set迭代")
    for (i <- set.iterator) println(i)
    println("arr迭代")
    for (i <- arr.iterator) println(i)
}
map遍历：
(a,1)
(b,2)
list遍历：
1
2
3
4
set遍历：
1
3
5
6
arr遍历：
a
b
c
============
map迭代
(a,1)
(b,2)
list迭代
1
2
3
4
set迭代
1
3
5
6
arr迭代
a
b
c

• 包含与否：contains()，所有集合均适用

object Main extends App {
    //包含与否
    println("map是否包含a：" + map.contains("a"))
    println("list是否包含1：" + list.contains(1))
    println("set是否包含1：" + set.contains(1))
    println("arr是否包含d：" + arr.contains("d"))
}
map是否包含a：true
list是否包含1：true
set是否包含1：true
arr是否包含d：false

• 转换成字符串：mkString(“连接符”)
• 获取集合头部，即第一个元素：head，所有集合均适用

object Main extends App {
    //获取集合头部，即第一个元素
    println("map头：" + map.head)
    println("list头：" + list.head)
    println("set头：" + set.head)
    println("arr头：" + arr.head)
}
map头：(a,1)
list头：1
set头：1
arr头：a

• 获取集合尾部，即除了头部外剩下的集合：tail，所有集合均适用

object Main extends App {
    println("map尾：" + map.tail)
    println("list尾：" + list.tail)
    println("set尾：" + set.tail)
    println("arr尾：" + arr.tail.mkString(",")) //Array数组访问的是引用地址,所以为直观显示，转换成字符串输出
}
map尾：Map(b -> 2)
list尾：List(2, 3, 4)
set尾：Set(3, 5, 6)
arr尾：b,c

• 获取集合最后一个元素：last，所有集合均适用

object Main extends App {
    println("map最后一个元素：" + map.last)
    println("list最后一个元素：" + list.last)
    println("set最后一个元素：" + set.last)
    println("arr最后一个元素：" + arr.last)
}
map最后一个元素：(b,2)
list最后一个元素：4
set最后一个元素：6
arr最后一个元素：c

• 获取集合初始数据，即除了最后一个元素外剩下的集合：init，所有集合均适用

object Main extends App {
    println("map初始元素：" + map.init)
    println("list初始元素：" + list.init)
    println("set初始元素：" + set.init)
    println("arr初始元素：" + arr.init.mkString(","))
}
map初始元素：Map(a -> 1)
list初始元素：List(1, 2, 3)
set初始元素：Set(1, 3, 5)
arr初始元素：a,b

• 获取集合前(后)n个元素：take(n)、takeRight(n)，所有集合均适用

object Main extends App {
    println("map前2个元素：" + map.take(2))
    println("list前2个元素：" + list.take(2))
    println("set后2个元素：" + set.takeRight(2))
    println("arr后2个元素：" + arr.takeRight(2).mkString(","))
}
map前2个元素：Map(a -> 1, b -> 2)
list前2个元素：List(1, 2)
set后2个元素：Set(5, 6)
arr后2个元素：b,c

• 去掉集合前(后)n个元素：drop(n)、dropRight(n)，所有集合均适用

object Main extends App {
    println("map去掉前1个元素：" + map.drop(1))
    println("list去掉前2个元素：" + list.drop(2))
    println("set去掉后2个元素：" + set.dropRight(2))
    println("arr去掉后2个元素：" + arr.dropRight(2).mkString(","))
}
PC端 手机端 平板端
map去掉前1个元素：Map(b -> 2)
list去掉前2个元素：List(3, 4)
set去掉后2个元素：Set(1, 3)
arr去掉后2个元素：a

• 集合反转,Map和Set不能反转：reverse

object Main extends App {
    println("list反转：" + list.reverse)
    println("arr反转：" + arr.reverse.mkString(","))
}
list反转：List(4, 3, 2, 1)
arr反转：c,b,a

• 集合并集：Set、List、Array用union/++，Map用++，且Set取并集时会去重

object Main extends App {
    //并集
    val arr_union = arr.union(arr1)
    val list_union = list.union(list1)
    val set_union = set.union(set1)
    val map_union = map ++ map1
    println("arr_union_arr1：" + arr_union.mkString(","))
    println("list_union_list1：" + list_union)
    println("set_union_set1：" + set_union) //合并后去重
    println("map_union_map1：" + map_union)
}
arr_union_arr1：a,b,c,d,b,c,e
list_union_list1：List(1, 2, 3, 4, 5, 2, 3, 6, 7)
set_union_set1：Set(5, 1, 6, 9, 3, 8, 4)
map_union_map1：Map(a -> 1, b -> 2, c -> 3)

• 集合交集：intersection，Map不可用

object Main extends App {
    //交集
	val arr_intersection = arr.intersect(arr1)
    val list_intersection = list.intersect(list1)
    val set_intersection = set.intersect(set1)
    println("arr_intersection_arr1：" + arr_intersection.mkString(","))
    println("list_intersection_list1：" + list_intersection)
    println("set_intersection_set1：" + set_intersection)
}
arr_intersection_arr1：b,c
list_intersection_list1：List(2, 3)
set_intersection_set1：Set(3, 5)

• 集合差集：diff，Map不可用

object Main extends App {
    //差集
    val arr_diff = arr.diff(arr1)
    val list_diff = list.diff(list1)
    val set_diff = set.diff(set1)
    println("arr_diff_arr1：" + arr_diff.mkString(","))
    println("list_diff_list1：" + list_diff)
    println("set_diff_set1：" + set_diff)
}
arr_diff_arr1：a
list_diff_list1：List(1, 4)
set_diff_set1：Set(1, 6)

• 拉链：zip，即一个集合与另一个集合一一对应形成二维元组，拉链两边的集合可以是不同的类型，所有集合均适用

object Main extends App {
    //拉链
    println("arr_zip_arr1：" + arr.zip(arr1).mkString(","))
    println("arr_zip_list1：" + arr.zip(list1).mkString(","))
    println("list_zip_list1：" + list.zip(list1))
    println("list_zip_map1：" + list.zip(map1))
    println("set_zip_set1：" + set.zip(set1))
    println("set_zip_set1：" + map.zip(map1).zip(map1))
}
arr_zip_arr1：(a,d),(b,b),(c,c)
arr_zip_list1：(a,5),(b,2),(c,3)
list_zip_list1：List((1,5), (2,2), (3,3), (4,6))
list_zip_map1：List((1,(a,1)), (2,(b,2)), (3,(c,3)))
set_zip_set1：Set((1,5), (3,9), (5,3), (6,8))
set_zip_set1：Map(((a,1),(a,1)) -> (a,1), ((b,2),(b,2)) -> (b,2))

• 滑窗：sliding(i,j)，i代表每个循环窗口的元素个数，j代表每个窗口间隔的元素个数，所有集合均适用

object Main extends App {
    for (i <- arr.sliding(2)) println("arr1_sliding：" + i.mkString) //每2个元素循环输出
    for (i <- list1.sliding(2,2)) println("list1_sliding：" + i) //每2个元素循环输出，且每次循环间隔2个元素
    for (i <- set1.sliding(2,3)) println("set1_sliding：" + i) //每2个元素循环输出，且每次循环间隔3个元素
    for (i <- map1.sliding(1,2)) println("map1_sliding：" + i) //每1个元素循环输出，且每次循环间隔2个元素
}
rr1_sliding：ab
arr1_sliding：bc
list1_sliding：List(5, 2)
list1_sliding：List(3, 6)
list1_sliding：List(7)
set1_sliding：Set(5, 9)
set1_sliding：Set(8, 4)
map1_sliding：Map(a -> 1)
map1_sliding：Map(c -> 3)