val ls = List(1,3,5,7,9)
ls.foreach(println) // 打印每个元素
ls.foreach(println(_))// 打印每个元素
ls.foreach(x=>println(x*10)) // 每个元素乘以10 打印结果
ls.foreach(x=>print(x+" "))// 打印每个元素 空格隔开
/**
* foreach
* 使用于任意的集合
* 对集合中的每个元素遍历 操作 打印 没有返回值
*
* 基本上就是用于测试 打印
*/
object ForeachDemo {
def main(args: Array[String]): Unit = {
val arr = Array(1, 3, 5, 7)
val ls = List(2, 4, 6, 8)
val set = Set("java", "js", "scala")
val mp = Map[String, Int](("tom", 111), ("jim", 222), ("cat", 3333))
// f:T=>U
arr.foreach(i => {
print(i * 10 + " ")
})
println()
ls.foreach(e => {
//e 代表遍历出来的每个元素
print(e * 100 + " ")
})
println()
set.foreach(e => print(e.toUpperCase() + " "))
println()
// 遍历map集合的对偶元组 e代表每个元组
mp.foreach(e => {
val k = e._1
val v = e._2
print(k + " ")
})
}
}
-
适用于任意集合
注意Map集合的用法
map函数遍历每个元素处理返回原集合类型的新集合 , 也可以不返回数据
列表,数组,Map中都有map函数 元组中没有map函数
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(_))
/**
* 方法map
* 遍历集合中的每个元素 操作每个元素 返回到一个新的集合中
* 使用于任何集合
* 常用于对集合中的每个元素处理的场景
*/
object MapDemo {
def main(args: Array[String]): Unit = {
val arr = Array(1, 3, 5, 7)
val ls = List(2, 4, 6, 8)
val set = Set("java", "js", "scala")
val mp = Map[String, Int](("tom", 111), ("jim", 222), ("cat", 333))
// _ 代表 e=>e
val res1: Array[Int] = arr.map(e => e * 10)
// res1.foreach(e=>println(e))
// _ 代表遍历出来的每个元素
val res2 = ls.map(_ * 100)
// res2.foreach(println(_))
//遍历Set 每个元素 转大写 遍历打印
set.map(_.toUpperCase()).foreach(println(_))
// 处理map集合中的每个key转大写 每个value*10
val res4: Map[String, Int] = mp.map(e=>{
/* val k = e._1.toUpperCase()
val v = e._2*10
// 返回值
// ( e._1.toUpperCase(), e._2*10)
(k,v)*/
( e._1.toUpperCase(), e._2*10)
})
res4.foreach(println(_))
}
}
map eg2:
val list = List("hadoop","hive","spark")
val list2 = list.map(s => s.toUpperCase())
list2.foreach(println("list2: ",_))
val list3 = list.map(s => println(s.length))输出：
切分压平
eg:
val list = List("hadoop","hive","spark")
println(list.flatMap(s => s.toList))输出：
输出：
适用于 数组 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+"))
object FlatMapDemo {
def main(args: Array[String]): Unit = {
val str = Array("hello jim tom cat" , "today is my first day")
// 1 遍历数数组中的每个元素
// 2 将每个元素 再 压平
// 存储了所有的单词
val strs: Array[String] = str.flatMap(e => e.split(" "))
strs.foreach(println)
}
}
适用于 数组 List Map
filter返回符合自己条件的新的集合,filterNot返回不符合自己条件的新的集合
val ls: List[Int] = List.range(1,10)
ls.filter(x=>x%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"))
set.filter(_.length>3)
多条件filter进行条件过滤
val ls = "spark":: "scala" :: "c++"::"java"::1::2::12.34::Nil
// 过滤出选过滤出String类型的和Double类型的数据
ls.filter{
case i:String => true
case i:Int=>false
case i:Double=>true
}
连续使用多次filter进行条件过滤
// 连续使用多次filter进行条件过滤
val map = Map[String,Int](("zss" ,91),("zww",89),("zzx",92) , ("ww",23))
map.filter(_._1.startsWith("z")).filter(_._2>90)
/**
* filter 过滤出 p:T=>Boolean
* 过滤出集合中符合条件的元素 将所有的元素添加到新的集合中
* 使用于所有的集合
* 对集合中的数据进行筛选
* 多条件的筛选过滤
* 1 filter().filter().filter()
* 2 filter(e=> 条件1 && 条件2 ....)
*
*/
object FilterDemo {
def main(args: Array[String]): Unit = {
val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val set = Set("java", "js", "scala")
val mp = Map[String, Int](("tom", 111), ("jim", 222), ("cat", 333))
// 过滤出数组中大于5的元素 p:T=>Boolean
// 遍历每个元素 判断每个元素是否符合条件 将符合条件的数据添加到新的集合中返回
val res1 = arr.filter(_ > 5)
// res1.foreach(println)
// 大于5 的 偶数 两个条件使用 &&
val res2: Array[Int] = arr.filter(e => e > 5 && e % 2 == 0)
val res21: Array[Int] = arr.filter(_ > 5).filter(_ % 2 == 0)
//res2.foreach(println)
val res3: Set[String] = set.filter(_.startsWith("j")).map(_.toUpperCase).filter(_.size > 2)
res3.foreach(println)
val res4: Map[String, Int] = mp.filter(e => e._1.startsWith("t"))
val res5: Map[String, Int] = mp.filter(_._2 > 200)
val res6 = for (elem <- arr if elem < 5) yield elem
}
}
object FilterNotDemo {
def main(args: Array[String]): Unit = {
val arr = Array("hello" , "jim" , "jack" , "cobi" , "haha")
// 遍历每个元素 判断 不符合条件的返回到新的数组中 ....
val res: Array[String] = arr.filterNot(_.startsWith("j"))
res.foreach(println)
}
}
val map1 = Map("zs"->"张三","ls"->"李四","ww"->"王五")
val map2 = map1 filter {x=> x._1 contains("s") }
map2.foreach(x=> println( x._1, x._2))输出：
常于 数组 List Map
collect函数也可以遍历集合中的每个元素处理返回新的集合
def map[B](f: (A) ⇒ B): List[B]
def collect[B](pf: PartialFunction[A, B]): List[B]
主要支持偏函数
val ls = List(1,2,3,4,"hello")
// 主要支持偏函数
val new_list: List[Int] = ls.collect({case i:Int=>i*10})
new_list.foreach(x=>print(x+" "))//10 20 30 40
// collect实现filter和map特性
list.collect({ case i: Int => i * 10
case i: String => i.toUpperCase
}).foreach(println)
val new_list2: List[Int] = ls.map({case x:Int=>x*10})
new_list2.foreach(x=>print(x+" "))// 错误 hello (of class java.lang.String)
因为collect支持偏函数 , 所以我们可以使用collect实现filter和map的特性!!!
val res: List[Int] = List(1, 2, 3, 4, 5, 6,"hello").collect({case i:Int if i%2==0=>i*10})
res.foreach(println) // 40 60 是不是牛逼闪电??
/**
* collect 方法和map方法非常一样
* 遍历每个元素 操作 返回新的集合
*
* collect支持偏函数 单独侧处理某一种数据 String Int
* collect可以处理某一种类型
* map 只能处理所有的数据类型 对[每个]元素处理
*/
object CollectDemo {
def main(args: Array[String]): Unit = {
val ls = List("a","b","c" ,"x" ,"y" , 1,2,3,4)
/* val res: Seq[Any] = ls.collect({
// e代表每个元素 类型匹配
case e:String =>e.toUpperCase
})*/
val res2: Seq[Any] = ls.map({
case e:String =>e.toUpperCase
case e:Int=>e*10
})
res2.foreach(println)
}
}
适用于 数组 List Map
数组
val arr = Array(1,2,345,67,5)
arr.min
arr.max
arr.sum
List
val ls = List(1,2,345,67,5)
ls.min
ls.max
ls.sum
Set
val set = Set(1,2,345,67,5)
set.min
set.max
set.sum
map 默认按照key排序获取最大和最小数据
val map = Map[String,Int]("a"->10, "b"->99 , "c"->88)
// map默认按照key排序获取最大和最小数据
map.min //(a,10)
map.max //(c,88)
/**
* 方法max
* 方法min 获取最大最小值的 要求集合中的元素是可排序的
*/
object MaxAndMin {
def main(args: Array[String]): Unit = {
val arr = Array(1, 34, 2, 33, 37, 23, 21)
println(arr.min) // 最小值
println(arr.max) // 最大值
// 字符串按照字典顺序排序 第一个最小 最后一个最大
val ls = List("java", "hello", "ahive", "scala")
println(ls.min)
println(ls.max)
// map数据按照key排序
val mp = Map[String, Int]("zss" -> 23, "alisi" -> 33, "fengjie" -> 38, "gy" -> 45)
// mp.maxBy(_._2)
// 返回一个元组
val max: (String, Int) = mp.max
val min: (String, Int) = mp.min
println(min)
println(max)
// 前提排序 User 不可排序
/**
* 实现思路 User类是可排序的 自定义排序
*/
/* val users = Array(
new User(23, "zss"),
new User(33, "lisi"),
new User(18, "fuanyu")
)
println(users.max)*/
}
}
适用于 数组 List Map
集合中的min和max可以获取任意集合中的最小和最大值 ,但是如果集合中存储的是用户自定义的类 , 或者是按照Map集合中的key,value规则排序的话就需要用户指定排序规则
map按照value取最大最小
val map = Map[String,Int]("a"->10, "b"->99 , "c"->88)
// map默认按照key排序获取最大和最小数据
// 指定map排序 按照value排序
map.maxBy(x=>x._2) //(b,99)
map.minBy(x=>x._2) //(a,10)
集合中存储的是用户自定义的类型
class User(val name:String ,val age:Int) {}
方式一 隐式转换
implicit def ordersUser(user:User)={
new Ordered[User] {
override def compare(that: User) = {
user.age.compareTo(that.age)
}
}
}
val ls = List(new User("zs",22),new User("ww",18) ,new User("tq",34))
println(ls.max.name)
println(ls.min.name)
方式二:
println(ls.maxBy(x => x.age).name)
/**
* by... 通过某种属性操作
* maxby(_.age)
* maxby(_.name)
*/
object MaxByAndMinBy {
def main(args: Array[String]): Unit = {
val users = Array(
new User(23, "zss"),
new User(33, "lisi"),
new User(18, "guanyu")
)
// 根据那个属性取最大值
val user = users.maxBy(user => user.age)
println(user)
println(users.minBy(_.age))
println(users.maxBy(_.name))
}
}
适用于 数组 List Set
求集合中的所有元素的和 ,下面三种集合类型常用
val arr = Array(1,2,345,67,5)
arr.sum
val ls = List(1,2,345,67,5)
ls.sum
val set = Set(1,2,345,67,5)
set.sum
/**
* sum
* 数字求和
*/
object SumDemo {
def main(args: Array[String]): Unit = {
val arr = List(1,2,34,5)
println(arr.sum)
val mp = Map[String , Int] (
"a"->12 ,
"b"->23 ,
"c"->33
)
println(mp.values.sum)
mp.map(e => e._2).sum
}
}
适用于 数组 List Map
def count(p: ((A, B)) => Boolean): Int
计算满足指定条件的集合元素数量
val arr = Array(1,2,345,67,5)
arr.count(_>5) // array list set 统用
val ls = List("hello" , "hi" , "heihei" , "tom")
ls.count(_.startsWith("h"))
ls.count(_.equals("hello"))
ls.count(_ == "hello")
// 忽略大小写
ls.count(_.equalsIgnoreCase("HELLO"))
// 统计符合条件的map元素的数量
val map = Map[String,Int]("a"->10,"ab"->10, "b"->99 , "c"->88)
map.count(x=>x._1.startsWith("a"))
map.count(_._2>10)
适用于 数组 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("a"))
if(res.isDefined){
println(res) //Some(hello)
println(res.get) //hello
}
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)
}
适用于 数组 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)).flatten
/**
* flatten
* 压平
* 数组 中的string[集合]
* 数组中的数字 基本
* 数组中的数组[数组]
* 数组中存储list集合
*/
object FlattenDemo {
def main(args: Array[String]): Unit = {
// int数字 简单的数值类型 123 1 2 3
val arr = Array("hello" ,"jim")
val res = arr.flatten
// res.foreach(println) // 压成字符
// 压平 扁平化数据
val arr2 = Array(List(1,2,3) , List(4,5,6))
arr2.flatten.foreach(println)
}
}
适用于 Map
mapValues方法只对Map集合的value做处理!
新版本的scala中已经废弃了这个方法 可以单独使用 map.values来单独处理map中所有的value数据!
适用于 数组 List Map
sorted 使用域简单的数字, 字符串等排序规则简答的集合进行排序 , 如果需要定制化排序建议使用sortBy 和 sortWith函数
List对数值
val list = List (1, 34 , 32 , 12 , 20 ,44 ,27)
// 返回排好序的list集合 默认从小到达排序
val sorted: List[Int] = list.sorted
对Array字符串
val arr = Array("jim" , "cat" , "jong" , "huba")
// 字符串默认按照先后排序
val sorted_arr: Array[String] = arr.sorted
对Map
val map = Map[String , Int]("aeiqi"->4 , "qiaozhi"->2 , "baji"->34)
// map集合也没有sorted 函数 只有转换成List或者Array集合 默认按照key字典先后排序
val sorted_map: Seq[(String, Int)] = map.toList.sorted
sorted_map.foreach(println)
自定义类
implicit def ordersUser(user:User)={
new Ordered[User] {
override def compare(that: User) = {
that.age.compareTo(user.age)
}
}
}
val u1 = new User("wuji",34)
val u2 = new User("zhiruo",24)
val u3 = new User("zhoamin",44)
val u4 = new User("cuishan",64)
// Set集合中没有sorted方法 如果指定规则排序 转成成List集合
val set = Set(u1, u2 , u3 , u4)
// 默认按照用户指定的排序规则排序
val sorted_set = set.toList.sorted
sorted_set.foreach(println)
适用于 数组 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)
自定义类型在集合中的排序
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)
-
partition将数组按照指定的规则分组 ,适用于 数组 List Map
val list = List(1,2,3,4,5,6,7,8,9)
// 将集合根据条件分成两组返回一个存储集合的元组第一个集和实符合要求的元素
//(List(3, 6, 9),List(1, 2, 4, 5, 7, 8))
val res: (List[Int], List[Int]) = list.partition(x=>x%3==0)
//从第一个元素开始处理 配到不符合条件的就结束
list.span(_<3) // (List(1, 2),List(3, 4, 5, 6, 7, 8, 9))
val list2 = List("scala" , "is" , "option" , "fucntion")
// (List(scala, is, fucntion),List(option))
list2.partition(_.hashCode%2==0)
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)
/**
* 明确数据分区的规则
* 数据很多 分成若干份 多个线程 多个进程并行处理 提高处理效率
*/
object PartitionDemo {
def main(args: Array[String]): Unit = {
val arr = Array(3,4,1,2,3,4,5,6,7,8,9)
val tuple1: (Array[Int], Array[Int]) = arr.partition(_ > 3)
val tuple2: (Array[Int], Array[Int]) = arr.partition(e => e % 3 == 0)
// tuple2._1.foreach(println)
// 从头遍历每个元素 符合条件添加到返回值集合中 如果元素不满足要求了 终止方法退出
val tuple: (Array[Int], Array[Int]) = arr.span(_>2)
tuple._1.foreach(println)
}
}
将集合中的元素按照指定的个数进行分组
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))))
将集合中的数据按照指定的规则进行分组
序列集合
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) //HashMap(false -> List(1, 2, 3), true -> List(4, 5, 6, 7, 8, 9))
val res2: Map[Boolean, List[Int]] = list1.groupBy(x=>x%2==0)//HashMap(false -> List(1, 3, 5, 7, 9), true -> List(2, 4, 6, 8))
list2.groupBy(x=>x.hashCode%2==0)
//HashMap(false -> List(is, option, fucntion), true -> List(scala))
val res: Map[Boolean, List[String]] = list2.groupBy(x=>x.startsWith("s"))
键值映射集合分组
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))
println(map.groupBy(mp => mp._2))
// 根据key 或者 value 分成两组 满足条件的和不满足条件的
println(map.groupBy(mp => mp._1.hashCode%2==0))
println(map.groupBy(mp => mp._2>2))
// 对偶元组集合 和map的分组方式是一样的
arr.groupBy(arr=>arr._1)
arr.groupBy(arr=>arr._2)
/**
* 分组 指定分组条件
* 如果集合是map 指定按照key分组 按照value分组
* 如果存储的集合是User类 name 性别
* 如果存储的是普通的字符串 数字 条件分组 两组
*/
object GroupByDemo {
def main(args: Array[String]): Unit = {
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(_ > 2)
val res = res1.map(e=>{
val k = e._1
val sum = e._2.sum
(k,sum)
})
res.foreach(println)
/* res1.map(e=>{
val k = e._1
val ls: Seq[String] = for (elem <- e._2) yield (k+":"+elem)
ls
}).foreach(println)*/
/*
List(false:1, false:2)
List(true:3, true:4, true:5, true:6, true:7, true:8, true:9)
*/
}
}
object GroupByDemo2 {
def main(args: Array[String]): Unit = {
val arr = Array(("sl","fsy"),("sl","swk"),("wd","zsf"),("wd","zwj"),("em","hgy"),("em","zzr"))
// 数组中存储的是对偶元组 按照元组的第一个元素的内容分组
val mp: Map[String, Array[(String, String)]] = arr.groupBy(e => e._1)
//mp.keys.foreach(println)
//mp.values.toList.foreach(println)
mp.map(e=>{
val mp = e._1
val arr = e._2 // 所有的人 ("sl","fsy") ("sl","swk")
// 遍历所有的人
for (tp <- arr) {
println(mp+"--"+tp._2)
}
})
}
}
规约操作
eg:
val list = List(1,2,3,4,5)
val num = list.sum
val num2 = list.reduce(_+_) //等价于调用了 sum
println(num)
println(num2)
输出：
底层调用的是reduceLeft , 从左边开始运算元素
val list = List(1,3,5,7,9)
// 每个元素累加 从左到右相加
val res1: Int = list.reduce(_+_) // 25
//1-3)-5)-7)-9
val res2: Int = list.reduce(_ - _) // -23
val arr = Array("haha", "heihei", "hehe")
// x 前面的元素 y 后面的元素 实现集合中字符串的拼接
val res3: String = arr.reduce((x, y) => x + " " + y) //haha heihei hehe
// 键值对元素的
val map = Map(("shaolin",88),("emei", 77),("wudang",99))
//(shaolin emei wudang,264) key value分别做归约操作
val res4: (String, Int) = map.reduce((m1,m2)=>(m1._1+" "+m2._1 , m1._2+ m2._2))
/**
* reduce 集合操作
* 返回一个结果
*/
object ReduceDemo {
def main(args: Array[String]): Unit = {
val arr = Array(1,2,3,4,5)
// (((1+2)+3)+4)+5
val res: Int = arr.reduce((x1, x2) => x1 + x2)
println(res)
// ((((1*2)*3)*4)*5
println(arr.reduce((a1, a2) => a1 * a2))
/* val ls = Array("java" , "mysql" , "html" , "JavaScript")
val res2: String = ls.reduce(_ +" "+ _)
res2.foreach(print)*/
}
}
val list = List(1, 3, 5, 7, 9)
val arr = Array("a", "b", "c","d","e")
val map = Map(("shaolin",88),("emei", 77),("wudang",99))
// 执行顺序是 1+3)+5)+7)+9
val res1: Int = list.reduceLeft(_+_)
// 1-3)-5)-7)-9
val res01: Int = list.reduceLeft(_-_)
val res2: String = arr.reduceLeft((a1, a2)=>a1+","+a2)
val res3: (String, Int) = map.reduceLeft((m1,m2)=>(m1._1+" "+m2._1 , m1._2+ m2._2))
println(res1) //25
println(res2) //a,b,c,d,e
println(res3)//(shaolin emei wudang,264)
val res11: Int = list.reduceRight(_+_) // 25
// 执行顺序是 a,(b,(c,(d,e))) a2 右边的最后一个元素
val res12: String = arr.reduceRight((a1, a2)=>a1+","+a2)//a,b,c,d,e
val res13: (String, Int) = map.reduceRight((m1,m2)=>(m1._1+" "+m2._1 , m1._2+ m2._2))//(shaolin emei wudang,264)
// 5-(7-9)-->5-(7-9)-->3-(5-(7-9))-->1-(3-(5-(7-9)))
val res14: Int = list.reduceRight(_-_)
println(res14) // 5
println(res11) //25
println(res12) //a,b,c,d,e
println(res13)//(shaolin emei wudang,264)
// 字符串的拼接
arr.reduce(_ ++ _)
// 字符串的拼接
println(arr.reduce(_ ++"."++ _))
object ReduceLeftAndReduceRight {
def main(args: Array[String]): Unit = {
val list = List(1, 3, 5, 7, 9)
//list.reduceLeft((x1,x2)=>x1+x2)
// (((1+3)+5)+7)+9
val res: Int = list.reduceLeft(_ + _) // 和reduce的运算过程一样
println(res)
// 1+(3+(5+(7+9))) // (9+7)+5)+3)+1)
val res2: Int = list.reduceRight(_ + _)
println(res2)
// 1 3 5 7 9
// 1-(3-(5-(7-9)))
val res3: Int = list.reduceRight(_ - _)
println(res3)
}
}
val list = List(1, 3, 5, 7, 9)
val arr = Array("a", "b", "c","d","e")
val map = Map(("shaolin",88),("emei", 77),("wudang",99))
// 执行顺序是 1+3)+5)+7)+9
val res1: Int = list.reduceLeft(_+_)
// 1-3)-5)-7)-9
val res01: Int = list.reduceLeft(_-_)
val res2: String = arr.reduceLeft((a1, a2)=>a1+","+a2)
val res3: (String, Int) = map.reduceLeft((m1,m2)=>(m1._1+" "+m2._1 , m1._2+ m2._2))
println(res1) //25
println(res2) //a,b,c,d,e
println(res3)//(shaolin emei wudang,264)
val res11: Int = list.reduceRight(_+_) // 25
// 执行顺序是 a,(b,(c,(d,e))) a2 右边的最后一个元素
val res12: String = arr.reduceRight((a1, a2)=>a1+","+a2)//a,b,c,d,e
val res13: (String, Int) = map.reduceRight((m1,m2)=>(m1._1+" "+m2._1 , m1._2+ m2._2))//(shaolin emei wudang,264)
// 5-(7-9)-->5-(7-9)-->3-(5-(7-9))-->1-(3-(5-(7-9)))
val res14: Int = list.reduceRight(_-_)
println(res14) // 5
println(res11) //25
println(res12) //a,b,c,d,e
println(res13)//(shaolin emei wudang,264)
// 字符串的拼接
arr.reduce(_ ++ _)
// 字符串的拼接
println(arr.reduce(_ ++"."++ _))
val arr1 = Array(1, 3, 5, 7, 0)
val arr2 = Array(5, 7, 8, 9)
val res1: Array[Int] = arr1.intersect(arr2) // 交集 5 7
val res2: Array[Int] = arr1.diff(arr2) // 差集 1 3
// 单纯的合并两个元素中的数据
val res3: mutable.ArraySeq[Int] = arr1.union(arr2) // 1,3,5,7 ,5,7,8,9
// 在2.13.+中的union 被concat代替
val ints: Array[Int] = arr1.concat(arr2)
ints.foreach(println)
// 去除重复数据
val res4: mutable.ArraySeq[Int] = res3.distinct //,3,5,7,8,9
object JiDemo {
def main(args: Array[String]): Unit = {
val arr1 = Array(1,2,3,4,5)
val arr2 = Array(4,5,6,7)
// 1 在集合一中出现 集合2中没有出现的元素
val res1: Array[Int] = arr1.diff(arr2)
//res1.foreach(println)
// 2 单纯的合并两个集合 返回一个新的集合 不会去除重复数据
// val res2: Array[Int] = arr1.union(arr2) // 注意不去重
// 3 在集合一种出现 也在集合二中出现 集合的交集
val res3: Array[Int] = arr1.intersect(arr2)
//res3.foreach(println)
val res: Array[Int] = arr1 ++ arr2
res.foreach(println)
}
}
去除集合中的重复的元素 ,可以去除简单类型的数据, 也可以除去自定义的类型(底层依然是hashcode和equals)
val arr1 = Array("a", "a","ab","cat" ,"hellocat" ,"hicat")
val newarr: Array[String] = arr1.distinct
newarr.foreach(println)
条件去重
val arr1 = Array(new User("ls",21),new User("ls",22),new User("zss",21))
// 去除重名的重复数据
val res: Array[User] = arr1.distinctBy(x=>x.age)
res.foreach(x=> println(x.name))
/**
* distinct 去除集合中的重复元素
*/
object DistinctDemo {
def main(args: Array[String]): Unit = {
val arr = Array(1,2,3,4,4,5,5)
val ls = List("hello" , "hello" ,"cat")
// 去除集合中的重复元素 返回新的集合
ls.distinct.foreach(println)
// 自定义的对象 内容去重重复 重写equals和hashcode方法
val users = List(new User("zss",21) , new User("zss",21))
users.distinct.foreach(println)
}
}
object DistinctByDemo {
def main(args: Array[String]): Unit = {
val arr = Array(1,2,3,4,5,6,6,5,4)
val users = List(
new User("zss" ,21) ,
new User("zss" ,33) ,
new User("fengjie" ,35)
)
val arr2 = Array(("a",1),("a",2),("a",1),("a",2))
// val res: Array[(String, Int)] = arr2.distinctBy(_._2)
// res.foreach(println)
// users.distinctBy(_.name).foreach(println)
}
}
实现拉链式拼接, 只要操作的集合是迭代集合就可以拼接
val list1 = List("a" , "b" , "c" , "d")
val arr1 = Array(1,2,3,4)
val map = Map[String,Int]("aa"->11,"cc"->22,"dd"->33)
// 以两个迭代集合中少的一方为基准对偶拼接List((a,1), (b,2), (c,3))
val res: List[(String, Int)] = list1.zip(arr1)
//ArraySeq((1,(aa,11)), (2,(cc,22)), (3,(dd,33)))
val res2: Array[(Int, (String, Int))] = arr1.zip(map)
/**
* zip
*/
object ZipDemo {
def main(args: Array[String]): Unit = {
val arr = Array("sl", "wd", "em", "gb", "hs")
val arr2 = Array("fsy", "zsf", "mjst", "qf", "ybq")
val res: Array[((String, String), Int)] = arr.zip(arr2).zipWithIndex
res.map(tp => {
val index: Int = tp._2
val d: (String, String) = tp._1
(index, d._1, d._2)
}).foreach(println)
val rr: Array[(String, Int)] = arr.zipWithIndex
val res2: Array[(String, (String, Int))] = arr.zip(arr.zipWithIndex)
// res.foreach(println)
//zip操作以后返回一个对偶元组 _1 前面的集合的元素 _.2 后面集合的元素 返回的结果的集合的个数是少的一方
// 注意 一一对应 不对应的多余的不处理
/* val res: Array[(String, Int)] = arr.zip(arr2)
res.foreach(println)*/
// val res: Array[((String, String), Int)] = arr.zip(arr2).zipWithIndex
/*
val res2: Array[(String, (Any, Int))] = arr.zip(arr2.zipWithIndex)
val res2 = res.map(e=>{
val tp = e._1
val index = e._2
(index , tp._1 , tp._2)
})
res2.foreach(println)
*/
}
}
简单理解为 遍历集合中的每个元素 , 将每个元素打上对应的索引值 , 组成元组(element , index) 返回新的集合 !
val list1 = List("a" , "b" , "c" , "d")
val arr1 = Array(1,2,3,4)
val map = Map[String,Int]("aa"->11,"cc"->22,"dd"->33)
// List(((a,1),0), ((b,2),1), ((c,3),2), ((d,4),3))
list1.zip(arr1).zipWithIndex
//List((a,0), (b,1), (c,2), (d,3))
list1.zipWithIndex
折叠是归约操作类似于reduce函数 ,但是fold函数中多出来一个初始值
eg:
val list = List(1,2,3,4,5)
val rs = list.fold(10)(_*_)
println(rs)
val list2 = (list fold 10) (_+_) //infix
println(list2)输出：
val arr = Array("tom" , "cat" , "jim" , "rose")
// 遍历集合中的每个元素进行拼接 比reduce函数多出一个初始值
val res = arr.fold("hello")(_+" "+_)
val ls = List(1,3,5,7)
// 100+1)+3)+5)+7 底层调用的是 foldLeft
val res2 = ls.fold(100)(_+_) // 116
ls.foldLeft(100)(_+_) // 116
从右边开始运算 默认的值先参与运算进来
// 7-10)-->5-(-3)-->3-8 -->1-(-5)
val res01: Int = ls.foldRight(10)(_-_) //6
/**
* fiold 聚合操作
* foldLeft和fold一样
* foldRight
*/
object FoldDemo {
def main(args: Array[String]): Unit = {
val arr = Array(1, 2, 3, 4)
//println(arr.reduce(_ + _)) // 1+2)+3)+4
// arr.reduce((x1,x2)=>x1+x2)
// reduce的运算是一样的逻辑 多出来一个默认值
println(arr.fold(10)(_ + _)) // (10+1)+2)+3)+4)+5 = 20
// 方法有两个参数列表 柯里化
println(arr.fold(2)(_ * _)) //(2*1)*2)*3)*4
val ls = List("tom", "jim", "baji")
val res: String = ls.fold("hello")(_ + " " + _)
println(res)
val res2: String = ls.foldRight("hello")(_ + " " + _)
println(res2)
}
}
一个初始值开始，从左向右遍历每个元素，进行积累的op操作
val arr = Array("cat" , "jim" , "tom")
// ArraySeq(hello, hello cat, hello cat jim, hello cat jim tom)
arr.scan("hello" )(_+" "+_)
val nums = List(1,2,3)
// List(10,10+1,10+1+2,10+1+2+3) = List(10,11,12,13)
val result = nums.scan(10)(_+_)
/**
* 能记录数据运算的一个结果过程集合
*/
object ScanDemo {
def main(args: Array[String]): Unit = {
val nums = List(1,2,3)
// 10+1)+2)+3
// List(10,10+1,10+1+2,10+1+2+3) = List(10,11,12,13)
val res: List[Int] = nums.scan(10)(_ + _)
res.foreach(println)
val names = List("tom" , "jerry" ,"baji")
names.scan("hello")(_+" "+_).foreach(println)
}
}
将集合中的每个元素拼接成字符串
val arr = Array("a", "b", "c")
val str = arr.mkString
arr.mkString(" ")
arr.reduce(_+_)
arr.reduce(_+" "+_)
object MakeString {
def main(args: Array[String]): Unit = {
val arr = Array("today" , "is" ,"sunny")
//获取集合中的每个元素直接拼接成一个字符串
val res1: String = arr.mkString
println(res1)
val res2: String = arr.mkString(",")
println(res2)
println(arr.reduce(_ + _))
println(arr.reduce(_ +","+ _))
}
}
slice(from: Int, until: Int): List[A] 提取列表中从位置from到位置until(不含该位置)的元素列表, 起始位置角标从0开始
slice
val arr = Array("a", "b", "c" ,"d","e","f")
arr.slice(0 ,2) // res0: Array[String] = ArraySeq(a, b)
sliding
sliding(size: Int, step: Int): Iterator[List[A]] 将列表按照固定大小size进行分组，步进为step，step默认为1,返回结果为迭代器
val nums = List(1,1,2,2,3,3,4,4)
// 参数一 子集的大小 参数二 步进
val res: Iterator[List[Int]] = nums.sliding(2,2)
res.toList // List(List(1, 1), List(2, 2), List(3, 3), List(4, 4))
object SliceDemo {
def main(args: Array[String]): Unit = {
val arr = Array("a", "b", "c" ,"d","e","f")
// 获取指定区间位置的元素
val res1: Array[String] = arr.slice(1, 3)
res1.foreach(println)
///参数一 个数 参数二 是步进
val res2: Iterator[Array[String]] = arr.sliding(2,2)
res2.map(arr=>{
(arr(0) ,arr(1))
}).foreach(println)
}
}
take 默认从左边开始取
val arr = Array("a", "b", "c" ,"d","e","f")
// 从左边获取三个元素 组成新的数组集合
arr.take(3)
takeRight 默认从右边开始取
val nums = List(1,1,1,1,4,4,4,4)
val right = nums.takeRight(4) // List(4,4,4,4)
takeWhile
// 小于4 终止
nums.takeWhile(_ < 4)
val names = Array ("cat", "com","jim" , "scala" ,"spark")
// 从左到右遍历符合遇到不符合条件的终止 储存在新的集合中
names.takeWhile(_.startsWith("c"))
object TakeDemo {
def main(args: Array[String]): Unit = {
val arr = Array(1,2,3,4,5,6,2,3)
// 从数组的0位置开始取3个元素 返回一个新的集合中
// arr.take(3).foreach(println)
//从右边开始取值
//arr.takeRight(2).foreach(println)
// takeWhile 从左边的第一个元素开始判断是否符合条件 符合条件的放入到返回数组中 返回
// 只要遇到不满足条件的数据直接停止
val res: Array[Int] = arr.takeWhile(_ < 4)
res.foreach(println)
}
}
aggregate 方法是一个聚合函数，接受多个输入，并按照一定的规则运算以后输出一个结果值,在2.13+版本中被foldLeft取代!
object AggregateDemo {
def main(args: Array[String]): Unit = {
val arr = Array(1,2,3,4,5)
/**
* 参数一 初始值
* 参数二 区内的运算逻辑
* 参数三 区结果和区结果的运算
*/
// println(arr.aggregate(0)(_ + _, _ * _))
//集合的并行化 本地机器有8个核 8个线程
val par: ParArray[Int] = arr.par
// 分成5个区 初始值在每个区中都参与运算
val res: Int = par.aggregate(2)(_ + _ , _ * _)
println(res)
}
}
toArray 将其他类型的集合转换成数组
toList 将其他类型的集合转转成list
toSet 将其他类型的集合转换成Set
toSeq 将其他类型的集合转换成Seq序列
toMap 将对偶类型的集合转换成Map
toString 将其他类型转换成字符串
————————————————
原文链接：https://blog.csdn.net/qq_37933018/article/details/106931052