scala集合之运算函数

• 创建集合
  Map(a -> 2, b -> 1)
  List((a,2), (b,3), (c,1))
  Set(1, 3, 5, 6)
  1,2,3

object Main extends App {
    val map = Map("a" -> 2,"b" -> 1)
    val list = List(("a",2),("b",3),("c",1))
    val set = Set(1,3,5,6)
    val arr = Array(1,2,3)
}

• 求和：sum

object Main extends App {
    println(map.values.sum) //Map的值求和
    println(set.sum)
    println(arr.sum)
}
3
15
6

• 乘积：product，List元素为元组时，转换为Map，然后给Map.values求乘积

object Main extends App {
    println(set.product)
    println(arr.product)
    println(map.values.product)
    println(list.toMap.values.product)
}
90
6
2
6

• 最大最小值：max/maxBy(参数 => {函数体})、min/minBy(参数 => {函数体})

object Main extends App {
    println(map.max) //默认取key的最大值
    println(map.values.max) //取value的最大值
    println(set.min)
    println(list.max) //默认以tuple里的字符串排序
    println(list.maxBy((tuple:(String,Int)) => tuple._2)) //以tuple里的数值排序
    println(list.minBy(_._2)) //简写，以tuple里的数值排序
}
(b,1)
2
1
(c,1)
(b,3)
(c,1)

• 排序：sorted、sortBy(参数)、sortWith((参数) => {函数体})，map先转换成List再排序，Set不排序

升序

bject Main extends App {
    val arr_sort = arr.sorted
    println(arr_sort.mkString(","))
    val map_sort = map.toList.sorted //默认以tuple里的字符串排序
    println(map_sort)
    val list_sort = list.sortBy(_._2) //以tuple里的数值排序
    println(list_sort)
}
1,2,3
List((a,2), (b,1))
List((c,1), (a,2), (b,3))

降序

object Main extends App {
    //隐式参数
    println(arr.sorted(Ordering[Int].reverse).mkString(",")) //sorted的参数Ordering默认为升序，降序的话直接把参数反转就好
    println(map.toList.sortBy(_._1)(Ordering[String].reverse)) //Map按照key降序
    
	//sortBy
    println(arr.sortBy(-_).mkString(","))
    println(map.toList.sortBy(-_._2)) //Map按照值降序,按照key降序时不能用负号，因为key不是数值型
    
    //sortWith
    println(arr.sortWith((a,b) => a>b).mkString(","))
    println(arr.sortWith(_>_).mkString(","))  
}
3,2,1
List((b,1), (a,2))
3,2,1
List((a,2), (b,1))
3,2,1
3,2,1

• 过滤：filter((参数) => {函数体})，将遍历集合的参数，用函数体过滤，得到返回为true的结果

object Main extends App {
    val evenset = set.filter(i => i%2==0) //返回偶数Set集合
    println(evenset)
    val map1 = map.keys.filter(i => i=="a") //返回Map中的key
    println(map1)
    val keymap = map.filterKeys(i => i=="a") //返回对key过滤后的Map
    println(keymap)
    val valuemap = map.filter(i => i._2==1) //返回对value过滤后的Map
    println(valuemap)
    val list1 = list.filter(i => i._1=="b") //返回对元素中字符串过滤后的List
    println(list1)
    val arr1 = arr.filter(i => i%2 != 0)
    println(arr1.mkString(","))
	//简写
	println(set.filter(_%2==0))
    println(map.keys.filter(_=="a"))
    println(map.filterKeys(_=="a"))
    println(map.filter(_._2==1))
    println(list.filter(_._1=="b"))
    println(arr.filter(_%2 != 0).mkString(","))
}

• 影射：map(参数 => {函数体})，即对每个元素进行函数处理

object Main extends App {
    println(arr.map(_*2).mkString(","))
    println(set.map(i => i*i)) //平方，不能用_*_，一个_代表一个参数
    println(list.map(_._2*2)) //返回为List的每个元组中value乘2后的List
    println(map.map(_._2*2)) //返回为Map的每个value乘2后的Liist
}
2,4,6
Set(1, 9, 25, 36)
List(4, 6, 2)
List(4, 2)

• 扁平化：flatten，将集合中的子集合去掉，并将其中的元素提取出来直接作为集合元素

object Main extends App {
    val list1 = List(List(1,2),List(3,4))
    println(list1.flatten)
    val set1 = Set(Set(1,3,5,6),Set(2,4))
    println(set1.flatten)
    val arr1 = Array(Array(1,2,3),Array(4,5))
    println(arr1.flatten.mkString(","))
}
List(1, 2, 3, 4)
Set(5, 1, 6, 2, 3, 4)
1,2,3,4,5

• 扁平映射：flatMap(参数 => {函数体})，即将每个元素进行函数处理，使其扁平化体现

object Main extends App {
    val list1 = List("1,2","3,4")
    println(list1.flatMap(i => i.split(",")))
    val set1 = Set("1,3,5,6","2,4")
    println(set1.flatten(_.split(",")))
    val arr1 = Array("1 2 3","4 5")
    println(arr1.flatMap(_.split(" ")).mkString(","))
}
List(1, 2, 3, 4)
Set(4, 5, 6, 1, 2, 3)
1,2,3,4,5

• 分组：groupBy(参数 => {函数体})，按照函数返回的值进行分组

object Main extends App {
    //按余数分组
    println(set.groupBy(_ % 2))
    
	//按首字母分组
    val list1 = List("alice","Alist","cindy","centy")
    println(list1.groupBy(_.charAt(0)))
}
Map(1 -> Set(1, 3, 5), 0 -> Set(6))
Map(A -> List(Alist), a -> List(alice), c -> List(cindy, centy))

• 归约：第一个元素与第2个计算，计算的值再与第三个计算，以此类推

reduce((a,b) => {函数体})：从头部两个元素开始计算
reduceLeft((a,b) => {函数体})：运算顺序与reduce相同
reduceRight((a,b) => {函数体})：从最后两个元素开始计算，但依旧是前边的元素与后边的元素进行计算

object Main extends App {
    println(set.reduce((a,b) => a+b)) //两两相加，第一个元素与第2个相加，相加的值再与第三个相加，以此类推
    println(arr.reduceLeft(_+_)) //从左往右归约 (1+2)+3
    println(set.reduceRight(_+_)) //从右往左归约 1+(3+(5+6))
    println(set.reduce(_-_))
    println(set.reduceLeft(_-_)) //从左往右归约 ((1-3)-5)-6
    println(set.reduceRight(_-_)) //从右往左归约 1-(3-(5-6))
}
15
6
15
-13
-13
-3

fold(初始值)((a,b) => {函数体})等同于：初始值按照函数体的运算规则与集合中的每个元素进行运算
foldLeft(初始值)((a,b) => {函数体})：运算顺序与fold相同，foldLeft的每个运算结果允许为元组
foldRight(初始值)((a,b) => 函数体)：从初始值与最后1个元素开始计算，但依旧是前边的元素与后边的元素进行计算

object Main extends App {
    val map = Map("a" -> 2,"b" -> 1)
    val list = List(("a",2),("b",3),("c",1))
    val set = Set(1,3,5,6)
    val arr = Array(1,2,3)
    
    println(set.fold(10)((i,j) => i+j)) //i为每次运算结果(默认为10)，j为集合的每个元素
    println(arr.fold(10)(_+_)) //第一步的简写
    println(set.foldLeft(10)(_-_))
    println(set.foldRight(10)(_-_)) //1-(3-(5-(6-10)))
    
    //Map实例，将map的元素合并到map1中，key重复时，累计value。这就要求map1是可变的，否则无法改变value值
    val map1 = scala.collection.mutable.Map("a" -> 1,"b" -> 3,"c" -> 4) //创建可变map1
    //使用foldLeft归约，map1_merge_map是每次的运算结果(默认值是map1)，每次参与运算参数map_kv是map的每个元素
    val map2 = map.foldLeft(map1)((map1_merge_map,map_kv) => {
        map1_merge_map(map_kv._1) = map1_merge_map.getOrElse(map_kv._1,0) + map_kv._2//map1中与map的key相同的key对应的value等于map1的value+map的value
        map1_merge_map
    })
    println(map2)
}
25
16
-5
7
Map(b -> 4, a -> 3, c -> 4)