0 目录
1.foreach函数
2.map函数
3. filter和filterNot(过滤函数)
4. collect函数
5. min和max
6. minBy和maxBy
7. sum函数
8. find 函数
9. flatten 函数
10 flatMap函数
11 mapValues 函数
12 sorted函数
13 sortBy和sortWith 函数
14. partition和span 函数
15 grouped 函数和groupBy函数
1.foreach函数
作用:迭代遍历集合中的每个元素,对每个元素进行处理 ,但是没有返回值 ,常用于打印结果数据 !
ls.foreach(println) // 打印每个元素
ls.foreach(println(_))// 打印每个元素
ls.foreach(x=>println(x*10)) // 每个元素乘以10 打印结果
ls.foreach(x=>print(x+" "))// 打印每个元素 空格隔开2.map函数
作用: 适用于任意集合 ,注意Map集合的用法 map函数遍历每个元素处理返回原集合类型的新集合 , 也可以不返回数据 列表,数组,Map中都有map函数 元组中没有map函数
注意:接收返回值 也可以适用for循环的推导式来实现接收返回值(for 循环的推导式,也常用与对每个元素处理完成之后,将结果集放到新的集合中)
val arr = Array[String]("JAVA", "C++", "SCALA")
val ls = List(1, 3, 5, 7, 9)
val set = Set(1, 3, 5, 7)
val mp = Map[String, Int]("ZSS" -> 100, "LSS" -> 99)
// map函数遍历每个元素处理返回原集合类型的新集合
val new_arr: Array[String] = arr.map(x => x)
val new_list: List[Int] = ls.map(x => x)
val new_set: Set[Int] = set.map(x => x)
// Map集合使用map函数
val new_Map1: Map[String, Int] = mp.map({ case v: (String, Int) => (v._1, v._2 * 10) })
val new_Map2: Map[String, Int] = mp.map(e => (e._1, e._2 + 100))
// map函数也可以不返回数据
ls.map(println(_))3. filter和filterNot(过滤函数)
filter函数作用:按照一定的条件对集合中的元素进行过滤,符合条件的元素放入新的集合中,函数的用法,也可以进行多条件过滤
filterNot函数 作用:filterNot返回不符合自己条件的新的集合
val ls: List[Int] = List.range(1,10)
ls.filter(x=>x%2==0) //过滤每一个元素取模2 等于0 的元素
val new_list: List[Int] = ls.filter(_ % 2 == 0)// _ 代表每个元素
new_list .foreach(x=>print(x+" ")) // 2 4 6 8
ls.filterNot(_%2!=1).foreach(x=>print(x+" ")) 1 3 5 7 9
// 每个元素进行过滤
val set = Set("spark" , "scala" , "c++" , "java")
val new_set: Set[String] = set.filter(_.startsWith("s")) //筛选每一个元素中首字母为s开头的元素
set.filter(_.length>3) //筛选出每一个元素字符长度大于3 的元素,放入新的集合中
// 多条件filter进行条件过滤
val ls1 = "spark":: "scala" :: "c++"::"java"::1::2::12.34::Nil
// 过滤出选过滤出String类型的和Double类型的数据
println(ls1.filter(_.isInstanceOf[String]))
ls.filter{
case i:String => true
case i:Int=>false
case i:Double=>true
}
// 连续使用多次filter进行条件过滤
val map = Map[String,Int](("zss" ,91),("zww",89),("zzx",92) , ("ww",23))
map.filter(_._1.startsWith("z")).filter(_._2>90)4. collect函数
作用:常于 数组 List Map collect函数也可以遍历集合中的每个元素处理返回新的集合
特点:因为collect支持偏函数 , 所以我们可以使用collect实现filter和map的特性!!
5. min和max
作用:适用于 数组 List Map,取集合中的最大值或者是最小值
特点:对于map集合来说,min和max函数,默认是按照K值来进行取值的
6. minBy和maxBy
作用:适用于 数组 List Map,集合中的min和max可以获取任意集合中的最小和最大值 ,但是如果集合中存储的是用户自定义的类 , 或者是按照Map集合中的key,value规则排序的话就需要用户指定排序规则
对map集合的value进行取最大值和最小值
val map = Map[String,Int]("a"->10, "b"->99 , "c"->88)
// map中使用min和max函数默认是按照key排序获取最大和最小数据
// minBy和maxBy函数可以用指定map排序 按照value排序
map.maxBy(x=>x._2) //(b,99)
map.minBy(x=>x._2) //(a,10)对map集合中的自定义类进行取最大值和最小值
val ls = List(new User("zs",22),new User("ww",18) ,new User("tq",34))
println(ls.max.name)
println(ls.min.name)7. sum函数
作用:是将集合中的所有元素进行求和操作,适用于list 和set 和数组
val arr = Array(1,2,345,67,5)
arr.sum
val ls = List(1,2,345,67,5)
println(ls.sum)
val set = Set(1,2,345,67,5)
set.sum8. find 函数
作用:适用于 数组 List Map 查找符合要求的元素 , 匹配到就返回数据 ,最多只返回一个,Option中的数据要么是Some(T) 要么是None标识没有找到
我的理解:这个函数在集合中按照条件进行查找,找到则将元素返回,不管后面是否还有满足条件元素都不进行判断,立刻停止
val arr = Array(1,2,345,67,5)
val e: Option[Int] = arr.find(x=>x>1)
val ls = List("hello" , "hi" , "heihei" , "tom")
val res: Option[String] = ls.find(_.contains("e"))
if(res.isDefined){
println(res) //Some(hello)
println(res.get) //hello
}
// 补充: def isDefined: Boolean
// 如果可选值是 Some 的实例返回 true，否则返回 false。
val map = Map[String,Int]("a"->10,"ab"->10, "b"->99 , "c"->88)
val res_map: Option[(String, Int)] = map.find(x=>x._2>20)
if(res_map.isEmpty){
"没有匹配到内容"
}else{
// 打印数据
println(res_map.get)
}9. flatten 函数
作用: 适用于 数组 List 用法,压平 将一个集合展开 组成一个新的集合
val arr = Array(1,2,345,67,5.23)
//val res1: Array[Nothing] = arr.flatten I数值了类型的无法压平
val ls = List("hello" , "hi" , "heihei" , "tom")
val res2: Seq[Char] = ls.flatten // 压成单个字符 因为字符串属于序列集合的一种
val map = Map[String,Int]("a"->10,"ab"->10, "b"->99 , "c"->88)
// map无法直接压平
//val flatten: immutable.Iterable[Nothing] = map.flatten
// 压平存储Map集合的list 获取Map中每个元素
val ls1 = List[Map[String,Int]](Map[String,Int]("a"->10,"ab"->10) , Map[String,Int]("jim"->100,"cat"->99))
ls1.flatten // List((a,10), (ab,10), (jim,100), (cat,99))
val res: List[Int] = List(Array(1,2,3),Array(4,5,6)).flatten
// 错误 注意压平的数据的类型
val res4 = List(Array(1,2,3),Array("hel",5,6)).flatten10 flatMap函数
适用于 数组 List
作用:map+flatten方法的组合 ,先遍历集合中的每个元素(可以对集合中的每一个元素进行处理) , 再按照指定的规则压平, 返回压平后的新的集合
val ls = List("today is my first day of my life" , "so I feel so happy")
// map处理每个元素 就是处理每句话
ls.map(x=>println(x))
// 获取集合中的每个元素 获取两句话 然后再扁平成字符
ls.flatMap(x=>x)
// 指定扁平化的规则 按照空格压平 压平的规则
ls.flatMap(x=>x.split(" ")).foreach(println) // 获取到每个单词map和flatmap 函数的补充,加深理解
// 读取外部文件
val bs: BufferedSource = Source.fromFile("d://word.txt")
// 读取所有的数据行
val lines: Iterator[String] = bs.getLines()
// m遍历每行数据按照 \\s+ 切割返回一个新的迭代器
val words: Iterator[String] = lines.flatMap(_.split("\\s+"))
// 遍历迭代器 获取每个单词
words.foreach(println)
// 读取外部文件
val bs2: BufferedSource = Source.fromFile("d://word.txt")
// 获取所有的行数据
val lines2: Iterator[String] = bs2.getLines()
// 处理每行数据 切割单词后 每行返回一个数组 将所有的数组封装在迭代器中
val arrs: Iterator[Array[String]] = lines2.map(_.split("\\s+"))11 mapValues 函数
适用于 Map
mapValues方法只对Map集合的value做处理!
新版本的scala中已经废弃了这个方法 可以单独使用 map.values来单独处理map中所有的value数据!
12 sorted函数
适用于 数组 List Map
sorted 适用于简单的数字, 字符串等排序规则简答的集合进行排序 , 如果需要定制化排序建议使用sortBy 和 sortWith函数
13 sortBy和sortWith 函数
适用于 数组 List Map,可以按照需求进行制定的升序和降序 详解如下:
var arr = Array(1, 11, 23, 45, 8, 56)
val arr1 = arr.sortBy(x => x) //ArraySeq(1, 8, 11, 23, 45, 56)
//按照数据倒序排列
val arr2 = arr.sortBy(x => -x) //(56, 45, 23, 11, 8, 1)
// 按照字典顺序排序
val arr3 = arr.sortBy(x => x.toString) //ArraySeq(1, 11, 23, 45, 56, 8)
// x 前面的元素 y 后面的元素
arr.sortWith((x, y) => x > y)
arr.sortWith((x, y) => x < y)
var list = List("hello", "cat", "happy", "feel")
// 字典顺序
list.sortBy(x => x)
// 执行排序
list.sortWith((x, y) => x > y) //按照前一个元素大于后一个元素进行排序,也就是降序
list.sortWith((x, y) => x < y)//前一个元素小于后一个元素也就是升序
val map = Map("peiqi" -> 5, "jong" -> 3, "baji" -> 12)//默认是升序
map.toList.sortBy(x => x._1) //List((baji,12), (jong,3), (peiqi,5))
map.toList.sortBy(x => x._2) //List((jong,3), (peiqi,5), (baji,12))
// 指定key排序
map.toArray.sortWith((x,y)=>x._1>y._1)
map.toArray.sortWith((x,y)=>x._1<y._1)
//指定value排序规则
map.toArray.sortWith((x,y)=>x._2>y._2)
map.toArray.sortWith((x,y)=>x._2<y._2)对于集合中的自定义类进行排序,适用sortBy 和 sortWith 按照集合对象的某一个维度进行排序,就是可以指定排序字段,详解如下:
val u1 = new User("wuji", 34)
val u2 = new User("zhiruo", 24)
val u3 = new User("zhoamin", 44)
val u4 = new User("cuishan", 64)
var arr = Array(u1, u2, u3, u4)
// 按照姓名字典排序
arr.sortBy(user => user.name)
//年龄小到大
arr.sortBy(user => user.age)
//数值类型的排序可以直接使用- 来倒序排列 年龄大到小
arr.sortBy(user => -user.age)
// 年龄大到小
arr.sortWith((user1, user2) => user1.age > user2.age)
// 年龄小到大
arr.sortWith((user1, user2) => user1.age < user2.age)
// 姓名字典升序
arr.sortWith((user1, user2) => user1.name < user2.name)
//姓名字典降序
arr.sortWith((user1, user2) => user1.name > user2.name)14. partition和span 函数
partition将数组按照指定的规则分组 ,适用于 数组 List Map
// partition函数,就是根据条件,将满足条件的放一组,将不满住条件的放一组,
//功能要比filter函数要强,filter函数只能过滤出满足条件的函数,
// 而partition函数可以将满足条件的元素过滤出来,也可以将不满住条件单额过滤出来
val list = List(1,2,3,4,5,6,7,8,9)
val tuple: (List[Int], List[Int]) = list.partition(_ % 2 == 0)
println(tuple._1)//List(2, 4, 6, 8)
println(tuple._2)//List(1, 3, 5, 7, 9)对map集合使用partition过滤
//map集合******************************************
val map = Map("peiqi" -> 5, "jong" -> 3, "baji" -> 12)
// (Map(baji -> 12),Map(peiqi -> 5, jong -> 3))
val tuple: (Map[String, Int], Map[String, Int]) = map.partition(x=>x._1.contains("b"))
val tuple2: (Map[String, Int], Map[String, Int]) = map.partition(x=>x._2 >5)span函数和partiton函数的不同点在于,span函数在过滤每一个元素的时候在遇到第一不满住条件的元素就会停止,对后面元素的筛选
15 grouped 函数和groupBy函数
grouped函数作用:将集合中的元素按照指定的个数进行分组,本人理解就是将集合中的元素,按照指定数组分组
val list1 = List(1,2,3,4,5,6,7,8,9)
val list2 = List("scala" , "is" , "option" , "fucntion")
val map = Map[String,Int]("peiqi" -> 5, "jong" -> 3, "baji" -> 12)
// 两个元素分成一组 ,9个元素总共分成5组
val res: Iterator[List[Int]] = list1.grouped(2)
var i = 0
// 遍历每个元素
res.foreach(list=>{
i+=1
list.foreach(x=>println(x+"----"+i)) // 打印每个元素和它所对应的组
})
// 将map集合按照个数进行分组
val res2: Iterator[Map[String, Int]] = map.grouped(2)
res2.foreach(i=>i.foreach(x=>println((x._1,x._2))))groupBy函数作用:将集合中的数据按照指定的规则进行分组
val list1 = List(1,2,3,4,5,6,7,8,9)
val list2 = List("scala" , "is" , "option" , "fucntion")
// 对序列数据进行分组
val res1: Map[Boolean, List[Int]] = list1.groupBy(x=>x>3)
println(res1)//结果展示:Map(false -> List(1, 2, 3), true -> List(4, 5, 6, 7, 8, 9))键值对映射集合分组
val map = Map[String,Int]("peiqi" -> 5, "jong" -> 3, "baji" -> 12)
val arr = Array(("cat",21),("lucy",33),("book",22),("jack",34))
// 按照key和value的内容分组
println(map.groupBy(mp => mp._1))//Map(peiqi -> Map(peiqi -> 5), baji -> Map(baji -> 12), jong -> Map(jong -> 3))
println(map.groupBy(mp => mp._2))//Map(5 -> Map(peiqi -> 5), 12 -> Map(baji -> 12), 3 -> Map(jong -> 3))
// 根据key 或者 value 分成两组 满足条件的和不满足条件的
println(map.groupBy(mp => mp._1.hashCode%2==0))//Map(true -> Map(peiqi -> 5, jong -> 3, baji -> 12))
println(map.groupBy(mp => mp._2>2))//Map(true -> Map(peiqi -> 5, jong -> 3, baji -> 12))
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
