文章目录
淡黄色的是要求 必须掌握的类型
一、元组
1.1元组的定义、遍历
object _01_Tuple {
def main(args: Array[String]): Unit = {
// 元组
// 1. 定义一个元组
val tuple: (String, String, Int, Double, Int) = ("Lily", "female", 100, 173.5, 65)
// 2. 获取元组中的元素
println(tuple._1)
println(tuple._2)
println(tuple._3)
println(tuple._4)
println(tuple._5)
// 通过"下标"访问元素，是从0开始的
println(tuple.productElement(0))
println(tuple.productElement(3))
// 3. 元组的遍历
for (elem <- tuple.productIterator) {
println(elem)
}
// 4. 元组的遍历2
// 依次将元组中的每一个元素，带入到参数的函数中作为函数的参数
tuple.productIterator.foreach(ele => println(ele))
tuple.productIterator.foreach(println(_))
tuple.productIterator.foreach(println)
}
}
1.2元组的拉链、解链
object _02_Tuple {
def main(args: Array[String]): Unit = {
// 拉链操作
// 将两个集合中对应位置的元素绑定到一起，最终得到一个新的集合，这个新的集合中的元素，是以元组的形式存在的
val array1 = Array(1, 2, 3, 4, 5)
val array2 = Array("a", "b", "c", "d", "e")
val res0: Array[(Int, String)] = array1.zip(array2)
println(res0.mkString(", "))
// 如果拉链的两个集合长度不一样，会取短的集合
val array3 = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
val array4 = Array("a", "b", "c", "d", "e")
val res1: Array[(Int, String)] = array3.zip(array4)
println(res1.mkString(", "))
// 方法拓展: zipAll
// 将两个集合进行拉链操作
// 如果两个集合的长度不一样:
// array3短: 取10与array4其他的元素进行拉链
// array4短: 取gg与array3其他的元素进行拉链
val res2: Array[(Int, String)] = array3.zipAll(array4, 10, "gg")
println(res2.mkString(", "))
// 解链
val unzip: (Array[Int], Array[String]) = res2.unzip
val (arr1, arr2) = res2.unzip
}
}
二、list
2.1空list、list初始化、list遍历3种方式
object _03_List {
def main(args: Array[String]): Unit = {
// 1. 构造一个List集合
// Nil: 表示空集合，没有元素
val list1: List[Nothing] = Nil
val list4: List[Nothing] = List()
// 构造一个指定元素的List集合
val list2 = List(1, 2, 3, 4)
val list3: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
// 2. 使用中缀运算符构建集合 ::
// 注意事项: 在使用中缀运算符构建集合的时候，结尾一定要是Nil
// 中缀运算符是右结合的 1 :: (2 :: (3 :: (4 :: Nil)))
val list5 = 1 :: 2 :: 3 :: 4 :: Nil // 等同于 List(1, 2, 3, 4)
println(list5)
val list6 = (1 :: 2 :: 3 :: Nil) :: (4 :: 5 :: 6 :: Nil) :: (7 :: 8 :: 9 :: Nil) :: Nil
println(list6)
val list7 = 10 :: 20 :: list5 :: Nil // 将list5中的每一个元素拼接到后面
println(list7)
// 3. 元素访问
println(list5(1))
// 4. 遍历集合
for (elem <- list5) {
println(elem)
}
// 下标遍历
for (index <- list5.indices) {
}
list5.foreach(println)
}
}
2.2list的追加、拼接操作
object _04_List {
// 列表的追加
// 由于List集合是不可变的集合，所有的追加操作，都会返回一个新的集合
def main(args: Array[String]): Unit = {
// 0. 准备两个集合
val list1 = List(1, 2, 3, 4)
val list2 = List(5, 6, 7, 8)
// 1. 将0追加到list1的前方
val res0: List[Int] = 0 :: list1
println(s"res0 = $res0")
val res1: List[Int] = list1.::(0)
println(s"res1 = $res1")
val res2: List[Int] = 0 +: list1
println(s"res2 = $res2")
val res3: List[Int] = list1.+:(0)
println(s"res3 = $res3")
// 2. 向后拼接一个元素
val res4: List[Int] = list1 :+ 0
println(s"res4 = $res4")
// 3. 拼接两个集合
val res5: List[Int] = list1 ++ list2
println(s"res5 = $res5")
// list1 ++: list2
// list1 ::: list2
// list1.:::list2)
}
}
2.3list的基本操作
object _05_List {
def main(args: Array[String]): Unit = {
// head: 获取一个List集合中的首元素
// tail: 获取一个List集合中，除了首元素之外的所有的元素
// last: 获取一个List集合中的尾元素
// init: 获取一个List集合中，除了尾元素之外的所有的元素
// isEmpty: 判断一个集合是否为空
// List.concat(List, List): 将两个集合拼接到一起，等同于 ++
// list1.reverse: 将集合中的元素翻转
// take(Int): 从集合中获取前面的指定数量的元素
// takeRight(Int): 从集合中获取后面的指定数量的元素
// drop(Int)：从集合中删除指定数量的元素
// dropRight(Int)：删除集合后面指定数量的元素
// splitAt(Int): 按照指定的下标，将一个List集合一分为二
val list1 = List(1, 2, 3, 4, 5, 6)
println(list1.head)
println(list1.tail)
println(list1.last)
println(list1.init)
println(list1.isEmpty)
val res0: List[Int] = List.concat(list1, list1)
println(res0)
val res1 = List.fill(10)(2) // 构建一个集合，这个集合长度为10，里面填充了10个2
println(res1)
println(list1.take(3))
println(list1.takeRight(3))
println(list1.drop(2))
println(list1.dropRight(2))
println(list1.splitAt(2))
println(list1.zip(list1))
}
}
2.4list拆分模式
object _06_List {
def main(args: Array[String]): Unit = {
// List集合的模式拆分
val list: List[Int] = List(1, 2, 3)
// 依次获取到集合中的每一个值，分别给每一个变量进行赋值
// 这里需要保证元素的数量，和前面的变量的数量一致，否则会异常
val List(a, b, c) = list
println(s"a = $a, b = $b, c = $c")
// 将除了给a1、b1赋值的元素之外的所有的部分，封装到一个List集合中，给rest赋值
val a1 :: b1 :: rest = list
println(s"a1 = $a1, b1 = $b1, rest = $rest")
}
}
2.5list集合的高阶方法
object _07_List {
/*
List集合的高阶方法（将一个函数作为参数，对集合中的数据进行处理）（使用的频率较多）
重点: foreach、map、flatMap、reduce、filter、fold
foreach
依次将集合中的每一个元素，带入到参数的函数中，作为函数的参数，进行函数的逻辑处理
map
元素映射，依次将集合中的每一个元素，带入到参数的函数中，用这个函数的返回值，替换原来的集合中的元素
Tips: 由于List集合是不可变的集合，因此map方法，会返回一个新的集合
flatMap
扁平化映射，将映射之后的所有的子集合中的元素，取出放入到一个集合中
reduce/reduceLeft/reduceRight
依次将集合中的元素进行相同逻辑的处理
fold/foldLeft/foldRight
filter
过滤，依次将集合中的每一个元素带入到参数的函数中，如果返回值是true，那就保留这个元素
partition
分区，只支持两个分区
find
查找从前往后第一个满足条件的元素
takeWhile
从集合的首元素开始，依次判断元素是否满足指定的条件，如果满足，将这个元素放入到结果集合中，然后再判断下一个元素
注意事项: 如果遇到了一个元素，不满足指定的条件，则结束查找
dropWhile
从集合的首元素开始，依次判断元素是否满足指定的条件，如果满足，将这个元素从集合中删除，然后再判断下一个元素
注意事项: 如果遇到了一个元素，不满足指定的条件，则结束删除操作
span
是一个将集合一分为二的方法
依次判断集合中的元素，是否满足指定的条件，找到第一个不满足条件的元素，前面的为一个集合，后面的为一个集合
*/
def main(args: Array[String]): Unit = {
// 1. 实例化一个集合，备用
val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
// 2. map
// val res0: List[String] = list.map(x => x.toString)
val res0: List[String] = list.map(_.toString)
val res1: List[Int] = list.map(_ * 2)
// 3. flatMap
val list1 = List("hello", "world")
list1.flatMap(x => x.toList)
//"hello".toList会将字符串拆分成字母list集合
//再将这个list[list[cahr]]类型的集合进行扁平化
val chars: List[Char] = list1.flatMap(_.toList)
val list2 = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
// val res2 = list2.flatMap(_.toList)
val res2 = list2.flatten // 当出现List集合嵌套List集合，需要将他们压平的时候，就可以使用这个方法
println(res2)
// 4. reduce
val res3: Int = list.reduce((a, b) => {
println(s"a = $a, b = $b")
a + b
})
println(res3)
val res4: Int = list.reduce(_ + _)
// 5. fold
// 类似于reduce，也是将集合中的所有的元素，按照相同的规则进行处理
// 但是，比reduce多个一个参数，这个参数表示处理的起始值
val res5 = list.fold(10)((a, b) => {
println(s"a = $a, b = $b")
a + b
})
println(res5)
// 6. filter
println(list.filter(_ % 2 == 0))
// 7. partition
val res6: (List[Int], List[Int]) = list.partition(_ % 2 == 0)
println(res6._1)
println(res6._2)
// 8. find
val res7: Option[Int] = list.find(_ % 2 == 0)
println(res7)
// 9.
val res8: List[Int] = list.takeWhile(_ < 5)
println(res8)
// 10.
println(list.dropWhile(_ % 2 != 0))
val tuple: (List[Int], List[Int]) = list.span(_ % 2 != 0)
println(tuple._1)
println(tuple._2)
}
}
三、wordCount
3.1完整版
object _08_wordcount {
def main(args: Array[String]): Unit = {
// 1. 准备数据
val lines: List[String] = List("java linux Hadoop Spark", "java mysql Hadoop Spark", "java HDFS Hive MR", "mysql HDFS Hive Hbase")
// 2. 获取每一个单词
val words: List[String] = lines.flatMap(_.split(" +"))
// 3. 将单词作为键，将1作为值
val wc1: List[(String, Int)] = words.map((_, 1))
// 4. 按照单词进行分组，将所有的1存入集合作为值
val wc2: Map[String, List[(String, Int)]] = wc1.groupBy(_._1)
// 5. 将map再映射，修改值的类型
val wc3: Map[String, Int] = wc2.mapValues(_.size)
println(wc3)
// 6. 将Map转成集合，为了排序
val wc4: List[(String, Int)] = wc3.toList
// 7. 对集合做排序
val wc5 = wc4.sortBy(_._2).reverse
wc5.foreach(println)
}
}
// List(java, linux, hadoop...)
// List((java, 1), (linux, 1), (hadoop, 1)...)
// Map(java -> List((java, 1), (java, 1)), ...)
// Map(java -> 3, hadoop -> 2)
3.2进阶版
object _09_wordcount {
def main(args: Array[String]): Unit = {
// 1. 准备数据
// val lines: List[String] = List("java linux Hadoop Spark", "java mysql Hadoop Spark", "java HDFS Hive MR", "mysql HDFS Hive Hbase")
// 2. wordcount
val source: BufferedSource = Source.fromFile("C:\\Users\\luds\\Desktop\\word")
val lines = source.mkString
// val wc1: Map[String, Int] = lines.flatMap(_.split(" +")).map((_, 1)).groupBy(_._1).mapValues(_.size)
val wc2: List[(String, Int)] = lines.split("\n").flatMap(_.split(" +")).map((_, 1)).groupBy(_._1).mapValues(_.size).toList.sortBy(_._2).reverse
// wc2.sortWith(_._2 < _._2)
}
}
四、set集合
4.1 set集合的创建、相加
object _10_Set {
def main(args: Array[String]): Unit = {
val set1: Set[Int] = Set(1, 2, 3, 1)
//
val res0: Set[Int] = set1 + 2
val res1: Set[Int] = set1 ++ Set(3, 4, 5, 6)
println(res1)
println(set1.getClass)
}
}
4.2 set添加、删除操作
object _11_Set {
def main(args: Array[String]): Unit = {
// 可变集合
val set = mutable.Set(1, 2, 3)
// 添加元素
set += 4
set += (5, 6, 7)
set ++= Set(9, 8, 7)
println(set)
// 删除元素
set -= 3
set -= (4, 5, 6)
set --= Set(1, 2)
println(set)
set.add(9) // 等价于 set + 9
set.remove(9) // 等价于 set - 9
println(set.getClass)
}
}
4.3 交、并、差集
object _12_Set {
def main(args: Array[String]): Unit = {
//
val set1 = Set(1, 2, 3, 4, 5)
val set2 = Set(4, 5, 6, 7, 8)
// 1. 交集
val res0 = set1.&(set2)
// set1 & set2
println(res0)
val res1 = set1.intersect(set2)
println(res1)
// 2. 并集
val res3 = set1.union(set2)
println(res3)
// 3. 差集
val res4 = set1.&~(set2)
val res5 = set1 &~ set2
val res6 = set1.diff(set2)
println(res4)
println(res5)
}
}
4.4 求满足条件的元素的数量——count
object _13_Set {
def main(args: Array[String]): Unit = {
//
val set = Set(1, 2, 3, 4, 5)
// 1. 统计满足条件的元素的数量
println(set.count(_ % 2 == 0))
}
}
五、并行处理数据
.par
object _14_Par {
def main(args: Array[String]): Unit = {
val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val sum = list.par.sum
val sum2 = list.par.reduce(_ + _)
println(sum2)
val sum3 = list.fold(10)(_ + _)
val sum4 = list.par.fold(10)(_+_)
println(sum3)
println(sum4)
}
}
六、sorted、sortBy、sortWith的区别
object Sort {
// 关于排序
// sorted: 集合中存储的元素，本身是可以比较大小的【类似于Java中，集合中的元素对应的类实现了Comparable接口】
// sortWith: 当需要指定集合中的排序的规则的时候使用
// sortBy: 集合中存储的元素，可能是一个较复杂的类型。（类、元组...），此时如果需要按照其中的一个属性进行排序，使用这个方法
def main(args: Array[String]): Unit = {
val list: List[Person] = Nil
list.sortBy(_.age)
list.sortBy(_.score)
val list1: List[(String, Int)] = Nil
list1.sortBy(_._2)
val list2: List[Int] = Nil
list2.sortWith(_ < _)
val list3: List[Person] = Nil
list3.sortWith(_.age < _.age)
}
}
1490
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
