集合的基本属性和操作
集合简单的计算函数
集合高级计算函数
合并Map
队列
并行集合
集合的基本属性和操作
//定义集合
val list = List(1,2,3,4,5,6,7,8,9,10)
val set = Set(9,8,7,4,5,6)
//获取集合长度
println(list.length)
//获取集合大小
println(set.size)
//遍历
for(i <- list){
println(i)
}
list.foreach(println)
//迭代
for( i <- list.iterator) println(i)
//生成字符串
println(list.mkString(" "))
//是否包含元素
println(list.contains(1))一个集合的基本操作
//定义集合
val list1 = List(1,2,3,4,5,6,7,8,9,10)
//获取集合的头元素
println(list1.head)
//获取去掉头元素后的集合
println(list1.tail)
//获取集合最后一个数据
println(list1.last)
//获取去掉最后一个元素后的集合
println(list1.init)
//反转集合
println(list1.reverse)
//取前n个元素
println(list1.take(3)) //.take(要取的元素个数)
//去掉前（后）n个元素
println(list1.drop(2)) //去掉前2个元素
println(list1.takeRight(2)) //去掉末尾2个元素两个集合操作
//定义集合
val list1 = List(1,2,3,4,5,6,7,8,9,10)
val list2 = List(10,486,16,1)
//并集
val list3 = list1.union(list2) //使用union方法
println(list1 ::: list2) //使用连接符
println(list3)
//如果set集合做并集，则会去重
val set1 = Set(9,8,7,4,5,6)
val set2 = Set(26,5,8,9,5,4,6)
val set3 = set1.union(set2)
println(set3)
//交集(公共元素)
val inter = list1.intersect(list2)
println(inter)
//差集（集合独有的元素）
val diff1 = list1.diff(list2) //属于list1但不属于list2的元素
val diff2 = list2.diff(list1) //属于list2但不属于list1的元素
println(diff1)
println(diff2)
//拉链 （穿插配对成二元组）
println(list1.zip(list2))
println(list2.zip(list1))
//滑窗
for(i <- list1.sliding(3)){ //大小为3的滑窗
println(i)
}集合简单的计算函数
//定义集合
val list = List(1,2,3,4,5,6,7,8,9,10)
//求和
//for循环实现
var sum = 0
for (i <- list){
sum += i
}
println(sum)
//函数实现
println(list.sum)
//求乘积
println(list.product)
//最大值
println(list.max)
val list2 = List(("a",1),("b",2),("c",3),("d",4))
println(list2.max)
println(list2.maxBy((t : (String,Int)) => t._2))
//最小值
println(list.min)
//排序
//使用sorted方法
val sorlist = list.sorted
println(sorlist)
//重大到小逆序排列
println(list.sorted.reverse)
//传入隐式参数
println(list.sorted(Ordering[Int]).reverse)
//sortBy
println(list2.sortBy((t : (String,Int)) => t._2)) //简写println(list2.sortBy((_._2)) 按照二元组第二位元素进行排序
//sortBy隐式参数
println(list2.sortBy(_._2)(Ordering[Int].reverse))
//sortWith 自定义排序
println(list.sortWith((a:Int,b:Int) =>{a<b})) //重小到大
//简写： println(list.sortWith(_<_))- sorted 对一个集合进行自然排序，通过传递隐式的 Ordering
- sortBy 对一个属性或多个属性进行排序，通过它的类型。
- sortWith 基于函数的排序，通过一个 comparator 函数，实现自定义排序的逻辑。
集合高级计算函数
Map类操作
//定义集合
val list = List(1,2,3,4,5,6,7,8,9,10)
//过滤 遍历一个集合并从中获取满足指定条件的元素组成一个新的集合
//需求：选取偶数
val evenlist = list.filter((i :Int) => {i % 2 == 0})
println(evenlist)
//转化/映射（map） 将集合中的每一个元素映射到某一个函数
//需求：把集合每个数乘二
println(list.map(i => i * 2))
//需求：每个数的平方
println(list.map(x => x * x))
//扁平化
val neslist : List[List[Int]] = List(List(1,2,3),List(4,5,6),List(7,8,9))
//拼接法散合并
val flatlist1 = neslist(0) ::: neslist(1) ::: neslist(2)
println(flatlist1)
//使用flatten函数实现
val flatlist2 = neslist.flatten
println(flatlist2)
//扁平化+映射 集合中的每个元素的子元素映射到某个函数并返回新集合
//需求： 将一组字符串进行分词 并保存成单词的列表
val strings : List[String] = List("hello scala","hello java","hello python")
val splist : List[Array[String]] = strings.map(_.split(" "))//分词
val flatlist3 = splist.flatten //打散
println(flatlist3)
//使用flatMap函数完成上述操作
val flatlist4 = strings.flatMap(_.split(" "))
//分组(group) 按照指定的规则对集合的元素进行分组
//需求：分成奇数偶数两组
val gp : Map[String,List[Int]] = list.groupBy(i =>{
if (i % 2 == 0) "偶数"
else "奇数"
})
// 简写 val gp = list.groupBy(_ % 2)
println(gp)Reduce类操作
//定义集合
val list = List(1,2,3,4,5,6)
//简化（归约）reduce
println(list.reduce((a: Int, b: Int) => a + b)) //简写reduce(_+_)
println(list.reduceLeft((a: Int, b: Int) => a + b))//从左往右操作
println(list.reduceRight((a: Int, b: Int) => a + b))//从右往左操作
val list2 = List(3,4,5,6,7)
println(list2.reduceRight((a: Int, b: Int) => a + b)) //最终结果位 3-(4-(5-(6-7)))
//折叠 fold
println(list.fold(10)(_ + _)) //10+(1+2+3+4+5+6)
println(list.foldLeft(10)(_ - _)) //10-1-2-3-4-5-6
println(list2.foldRight(10)(_ - _)) //3-(4-(5-(6-(7-11))))- Reduce 简化（归约） ：通过指定的逻辑将集合中的数据进行聚合，从而减少数据，最 终获取结果。
- Fold 折叠：化简的一种特殊情况。
fold 方法使用了函数柯里化，存在两个参数列表
- 第一个参数列表为 ： 零值（初始值）
- 第二个参数列表为： 简化规则
合并Map
//定义集合
val map1 = Map("a" -> 1,"b" -> 2,"c" -> 3)
val map2 = mutable.Map("a" -> 5,"b" -> 6,"c" -> 7)
val map3 = map1.foldLeft(map2)((zmap,kv)=>{
val key = kv._1
val value = kv._2
zmap(key) = zmap.getOrElse(key,0) + value
zmap
})
println(map3)队列
Scala 也提供了队列（Queue）的数据结构，队列的特点就是先进先出。进队和出队的方 法分别为 enqueue 和 dequeue。
//创建可变队列
val qu = new mutable.Queue[String]()
//入队
qu.enqueue("元素1","元素2","元素3")
println(qu)
//出队
println(qu.dequeue())
println(qu)
println(qu.dequeue())
println(qu)
println("---------------------------")
//创建不可变队列
val qu2 : Queue[String] = Queue("A","B","C")
val newQue2 = qu2.dequeue
println(newQue2)并行集合
Scala 为了充分使用多核 CPU，提供了并行集合（有别于前面的串行集合），用于多核 环境的并行计算。
//串行
val strings1 : immutable.IndexedSeq[String] = (1 to 10).map { x =>
Thread.currentThread().getName
}
println(strings1)
//并行
val strings2: ParSeq[String] = (1 to 10).par.map { x =>
Thread.currentThread().getName
}
println(strings2)本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
