文章目录
- 1.集合常用方法
- 2.衍生集合
- 3.集合的常用函数
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)
