企业网站建设方案效果,网络管理系统设备,做网站为什么能赚钱吗,金色网站模板集合第七章:集合7.1 集合简介7.1.1 不可变集合继承图7.1.2 可变集合继承图7.2 数组7.2.1 不可变数组7.2.2 可变数组7.2.3 不可变数组与可变数组的转换7.2.4 多维数组7.3 列表 List7.3.1 不可变 List7.3.2 可变 ListBuffer7.4 Set 集合7.4.1 不可变 Set7.4.2 可变 mutable.Set7.…
集合第七章:集合7.1 集合简介7.1.1 不可变集合继承图7.1.2 可变集合继承图7.2 数组7.2.1 不可变数组7.2.2 可变数组7.2.3 不可变数组与可变数组的转换7.2.4 多维数组7.3 列表 List7.3.1 不可变 List7.3.2 可变 ListBuffer7.4 Set 集合7.4.1 不可变 Set7.4.2 可变 mutable.Set7.5 Map 集合7.5.1 不可变 Map7.5.2 可变 Map7.6 元组7.7 集合常用函数7.7.1 基本属性和常用操作7.7.2 衍生集合7.7.3 集合计算简单函数7.7.4 集合计算高级函数7.7.5 普通 WordCount 案例7.7.6 复杂 WordCount 案例7.8 队列7.9 并行集合第七章:集合
7.1 集合简介
1Scala 的集合有三大类序列 Seq、集 Set、映射 Map所有的集合都扩展自 Iterable 特质。 2对于几乎所有的集合类Scala 都同时提供了可变和不可变的版本分别位于以下两 个包
不可变集合scala.collection.immutable可变集合 scala.collection.mutable
3Scala 不可变集合就是指该集合对象不可修改每次修改就会返回一个新对象而 不会对原对象进行修改。类似于 java 中的 String 对象 4可变集合就是这个集合可以直接对原对象进行修改而不会返回新的对象。类似 于 java 中 StringBuilder 对象 建议在操作集合的时候不可变用符号可变用方法
7.1.1 不可变集合继承图 1Set、Map 是 Java 中也有的集合 2Seq 是 Java 没有的我们发现 List 归属到 Seq 了因此这里的 List 就和 Java 不是同一个 概念了 3我们前面的 for 循环有一个 1 to 3就是 IndexedSeq 下的 Range 4String 也是属于 IndexedSeq 5我们发现经典的数据结构比如 Queue 和 Stack 被归属到 LinearSeq(线性序列) 6大家注意 Scala 中的 Map 体系有一个 SortedMap说明 Scala 的 Map 可以支持排序 7IndexedSeq 和 LinearSeq 的区别
1IndexedSeq 是通过索引来查找和定位因此速度快比如 String 就是一个索引集合通过索引即可定位2LinearSeq 是线型的即有头尾的概念这种数据结构一般是通过遍历来查找
7.1.2 可变集合继承图 7.2 数组
7.2.1 不可变数组
加粗样式1第一种方式定义数组 定义val arr1 new ArrayInt 1new 是关键字2[Int]是指定可以存放的数据类型如果希望存放任意数据类型则指定 Any3(10)表示数组的大小确定后就不可以变化
2案例实操
object TestArray{def main(args: Array[String]): Unit {//1数组定义val arr01 new Array[Int](4)println(arr01.length) // 4//2数组赋值//2.1修改某个元素的值arr01(3) 10//2.2采用方法的形式给数组赋值arr01.update(0,1)//3遍历数组//3.1查看数组println(arr01.mkString(,))//3.2普通遍历for (i - arr01) {println(i)}//3.3简化遍历def printx(elem:Int): Unit {println(elem)}arr01.foreach(printx)// arr01.foreach((x){println(x)})// arr01.foreach(println(_))arr01.foreach(println)//4增加元素由于创建的是不可变数组增加元素其实是产生新的数
组println(arr01)val ints: Array[Int] arr01 : 5println(ints)}
}3第二种方式定义数组 val arr1 Array(1, 2)
1在定义数组时直接赋初始值2使用 apply 方法创建数组对象
4案例实操
object TestArray{def main(args: Array[String]): Unit {var arr02 Array(1, 3, bobo)println(arr02.length)for (i - arr02) {println(i)}}
}7.2.2 可变数组
1定义变长数组 val arr01 ArrayBuffer[Any](3, 2, 5) 1[Any]存放任意数据类型2(3, 2, 5)初始化好的三个元素3ArrayBuffer 需要引入 scala.collection.mutable.ArrayBuffer
2案例实操
1ArrayBuffer 是有序的集合2增加元素使用的是 append 方法()支持可变参数
import scala.collection.mutable.ArrayBuffer
object TestArrayBuffer {def main(args: Array[String]): Unit {//1创建并初始赋值可变数组val arr01 ArrayBuffer[Any](1, 2, 3)//2遍历数组for (i - arr01) {println(i)}println(arr01.length) // 3println(arr01.hash arr01.hashCode())//3增加元素//3.1追加数据arr01.(4)//3.2向数组最后追加数据arr01.append(5,6)//3.3向指定的位置插入数据arr01.insert(0,7,8)println(arr01.hash arr01.hashCode())//4修改元素arr01(1) 9 //修改第 2 个元素的值println(--------------------------)for (i - arr01) {println(i)}println(arr01.length) // 5}
}7.2.3 不可变数组与可变数组的转换
1说明 arr1.toBuffer //不可变数组转可变数组 arr2.toArray //可变数组转不可变数组 1arr2.toArray 返回结果才是一个不可变数组arr2 本身没有变化2arr1.toBuffer 返回结果才是一个可变数组arr1 本身没有变化
2案例实操
object TestArrayBuffer {def main(args: Array[String]): Unit {//1创建一个空的可变数组val arr2 ArrayBuffer[Int]()//2追加值arr2.append(1, 2, 3)println(arr2) // 1,2,3//3ArrayBuffer Array//3.1arr2.toArray 返回的结果是一个新的定长数组集合//3.2arr2 它没有变化val newArr arr2.toArrayprintln(newArr)//4Array ArrayBuffer//4.1newArr.toBuffer 返回一个变长数组 newArr2//4.2newArr 没有任何变化依然是定长数组val newArr2 newArr.toBuffernewArr2.append(123)println(newArr2)}}7.2.4 多维数组
1多维数组定义 val arr Array.ofDimDouble 说明二维数组中有三个一维数组每个一维数组中有四个元素 2案例实操
object DimArray {def main(args: Array[String]): Unit {//1创建了一个二维数组, 有三个元素每个元素是含有 4 个元素一维
数组()val arr Array.ofDim[Int](3, 4)arr(1)(2) 88//2遍历二维数组for (i - arr) { //i 就是一维数组for (j - i) {print(j )}println()}}
}7.3 列表 List
7.3.1 不可变 List
1说明
1List 默认为不可变集合2创建一个 List数据有顺序可重复3遍历 List4List 增加数据5集合间合并将一个整体拆成一个一个的个体称为扁平化6取指定数据7空集合 Nil 2案例实操
object TestList {def main(args: Array[String]): Unit {//1List 默认为不可变集合//2创建一个 List数据有顺序可重复val list: List[Int] List(1,2,3,4,3)//7空集合 Nilval list5 1::2::3::4::Nil//4List 增加数据//4.1::的运算规则从右向左//val list1 5::listval list1 7::6::5::list//4.2添加到第一个元素位置val list2 list.:(5)//5集合间合并将一个整体拆成一个一个的个体称为扁平化val list3 List(8,9)//val list4 list3::list1val list4 list3:::list1//6取指定数据println(list(0))//3遍历 List//list.foreach(println)//list1.foreach(println)//list3.foreach(println)//list4.foreach(println)list5.foreach(println)}
}7.3.2 可变 ListBuffer
1说明
1创建一个可变集合 ListBuffer2向集合中添加数据3打印集合数据
2案例实操
import scala.collection.mutable.ListBuffer
object TestList {def main(args: Array[String]): Unit {//1创建一个可变集合val buffer ListBuffer(1,2,3,4)//2向集合中添加数据buffer.(5)
buffer.append(6)
buffer.insert(1,2)//3打印集合数据buffer.foreach(println)
//4修改数据
buffer(1) 6
buffer.update(1,7)
//5删除数据
buffer.-(5)
buffer.-(5)
buffer.remove(5)}
}7.4 Set 集合 默认情况下Scala 使用的是不可变集合如果你想使用可变集合需要引用 scala.collection.mutable.Set 包 7.4.1 不可变 Set
1说明
1Set 默认是不可变集合数据无序2数据不可重复3遍历集合
2案例实操
object TestSet {def main(args: Array[String]): Unit {//1Set 默认是不可变集合数据无序val set Set(1,2,3,4,5,6)//2数据不可重复val set1 Set(1,2,3,4,5,6,3)//3遍历集合for(x-set1){println(x)}}
}7.4.2 可变 mutable.Set
1说明
1创建可变集合 mutable.Set2打印集合3集合添加元素4向集合中添加元素返回一个新的 Set5删除数据
2案例实操
object TestSet {def main(args: Array[String]): Unit {//1创建可变集合val set mutable.Set(1,2,3,4,5,6)//3集合添加元素set 8//4向集合中添加元素返回一个新的 Setval ints set.(9)println(ints)println(set2 set)//5删除数据set-(5)//2打印集合set.foreach(println)println(set.mkString(,))}
}7.5 Map 集合 Scala 中的 Map 和 Java 类似也是一个散列表它存储的内容也是键值对key-value 映射 7.5.1 不可变 Map
1说明
1创建不可变集合 Map2循环打印3访问数据4如果 key 不存在返回 0
2案例实操
object TestMap {def main(args: Array[String]): Unit {// Map//1创建不可变集合 Mapval map Map( a-1, b-2, c-3 )//3访问数据for (elem - map.keys) {// 使用 get 访问 map 集合的数据会返回特殊类型 Option(选项):
有值Some无值(None)println(elem map.get(elem).get)}//4如果 key 不存在返回 0println(map.get(d).getOrElse(0))println(map.getOrElse(d, 0))//2循环打印map.foreach((kv){println(kv)})}
}7.5.2 可变 Map
1说明
1创建可变集合2打印集合3向集合增加数据4删除数据5修改数据
2案例实操
object TestSet {def main(args: Array[String]): Unit {//1创建可变集合val map mutable.Map( a-1, b-2, c-3 )//3向集合增加数据map.(d-4)// 将数值 4 添加到集合并把集合中原值 1 返回val maybeInt: Option[Int] map.put(a, 4)println(maybeInt.getOrElse(0))//4删除数据map.-(b, c)//5修改数据map.update(d,5)
map(d) 5//2打印集合map.foreach((kv){println(kv)})}
}7.6 元组
1说明 元组也是可以理解为一个容器可以存放各种相同或不同类型的数据。说的简单点就是将多个无关的数据封装为一个整体称为元组。 注意元组中最大只能有 22 个元素。 2案例实操
1声明元组的方式(元素 1元素 2元素 3)2访问元组3Map 中的键值对其实就是元组,只不过元组的元素个数为 2称之为对偶
object TestTuple {def main(args: Array[String]): Unit {//1声明元组的方式(元素 1元素 2元素 3)val tuple: (Int, String, Boolean) (40,bobo,true)//2访问元组//2.1通过元素的顺序进行访问调用方式_顺序号println(tuple._1)println(tuple._2)println(tuple._3)//2.2通过索引访问数据println(tuple.productElement(0))//2.3通过迭代器访问数据for (elem - tuple.productIterator) {println(elem)}//3Map 中的键值对其实就是元组,只不过元组的元素个数为 2称之为
对偶val map Map(a-1, b-2, c-3)val map1 Map((a,1), (b,2), (c,3))map.foreach(tuple{println(tuple._1 tuple._2)})}
}7.7 集合常用函数
7.7.1 基本属性和常用操作
1说明
1获取集合长度2获取集合大小3循环遍历4迭代器5生成字符串6是否包含
2案例实操
object TestList {def main(args: Array[String]): Unit {val list: List[Int] List(1, 2, 3, 4, 5, 6, 7)//1获取集合长度println(list.length)//2获取集合大小,等同于 lengthprintln(list.size)//3循环遍历list.foreach(println)//4迭代器for (elem - list.itera tor) {println(elem)}//5生成字符串println(list.mkString(,))//6是否包含println(list.contains(3))}
}7.7.2 衍生集合
1说明
1获取集合的头2获取集合的尾不是头的就是尾3集合最后一个数据4集合初始数据不包含最后一个5反转6取前后n 个元素7去掉前后n 个元素8并集9交集10差集11拉链12滑窗 2案例实操
object TestList {def main(args: Array[String]): Unit {val list1: List[Int] List(1, 2, 3, 4, 5, 6, 7)val list2: List[Int] List(4, 5, 6, 7, 8, 9, 10)//1获取集合的头println(list1.head)//2获取集合的尾不是头的就是尾println(list1.tail)//3集合最后一个数据println(list1.last)//4集合初始数据不包含最后一个println(list1.init)//5反转println(list1.reverse)//6取前后n 个元素println(list1.take(3))println(list1.takeRight(3))//7去掉前后n 个元素println(list1.drop(3))println(list1.dropRight(3))//8并集println(list1.union(list2))//9交集println(list1.intersect(list2))//10差集println(list1.diff(list2))//11拉链 注:如果两个集合的元素个数不相等那么会将同等数量的数据进
行拉链多余的数据省略不用println(list1.zip(list2))//12滑窗list1.sliding(2, 5).foreach(println)}
}7.7.3 集合计算简单函数
1说明
1求和2求乘积3最大值4最小值5排序
2实操
object TestList {def main(args: Array[String]): Unit {val list: List[Int] List(1, 5, -3, 4, 2, -7, 6)//1求和println(list.sum)//2求乘积println(list.product)//3最大值println(list.max)//4最小值println(list.min)//5排序// 5.1按照元素大小排序println(list.sortBy(x x))// 5.2按照元素的绝对值大小排序println(list.sortBy(x x.abs))// 5.3按元素大小升序排序
println(list.sortWith((x, y) x y))
// 5.4按元素大小降序排序println(list.sortWith((x, y) x y))}
}1sorted 对一个集合进行自然排序通过传递隐式的 Ordering2sortBy 对一个属性或多个属性进行排序通过它的类型。3sortWith 基于函数的排序通过一个 comparator 函数实现自定义排序的逻辑。
7.7.4 集合计算高级函数
1说明
1过滤 遍历一个集合并从中获取满足指定条件的元素组成一个新的集合2转化/映射map将集合中的每一个元素映射到某一个函数3扁平化4扁平化映射 注flatMap 相当于先进行 map 操作在进行 flatten 操作 集合中的每个元素的子元素映射到某个函数并返回新集合5分组(group) 按照指定的规则对集合的元素进行分组6简化归约7折叠
2实操
object TestList {def main(args: Array[String]): Unit {val list: List[Int] List(1, 2, 3, 4, 5, 6, 7, 8, 9)val nestedList: List[List[Int]] List(List(1, 2, 3), List(4,
5, 6), List(7, 8, 9))val wordList: List[String] List(hello world, hello
atguigu, hello scala)//1过滤println(list.filter(x x % 2 0))//2转化/映射println(list.map(x x 1))//3扁平化println(nestedList.flatten)//4扁平化映射 注flatMap 相当于先进行 map 操作在进行 flatten
操作println(wordList.flatMap(x x.split( )))//5分组println(list.groupBy(x x % 2))}
}3Reduce 方法 Reduce 简化归约 通过指定的逻辑将集合中的数据进行聚合从而减少数据最 终获取结果。案例实操 object TestReduce {def main(args: Array[String]): Unit {val list List(1,2,3,4)// 将数据两两结合实现运算规则val i: Int list.reduce( (x,y) x-y )println(i i)// 从源码的角度reduce 底层调用的其实就是 reduceLeft//val i1 list.reduceLeft((x,y) x-y)// ((4-3)-2-1) -2val i2 list.reduceRight((x,y) x-y)println(i2)}
}4Fold 方法 Fold 折叠化简的一种特殊情况。 1案例实操fold 基本使用
object TestFold {def main(args: Array[String]): Unit {val list List(1,2,3,4)// fold 方法使用了函数柯里化存在两个参数列表// 第一个参数列表为 零值初始值// 第二个参数列表为 简化规则// fold 底层其实为 foldLeftval i list.foldLeft(1)((x,y)x-y)val i1 list.foldRight(10)((x,y)x-y)println(i)println(i1)}
}2案例实操两个集合合并
object TestFold {def main(args: Array[String]): Unit {// 两个 Map 的数据合并val map1 mutable.Map(a-1, b-2, c-3)val map2 mutable.Map(a-4, b-5, d-6)val map3: mutable.Map[String, Int] map2.foldLeft(map1)
{(map, kv) {val k kv._1val v kv._2map(k) map.getOrElse(k, 0) vmap}}println(map3)}
}7.7.5 普通 WordCount 案例
1需求 单词计数将集合中出现的相同的单词进行计数取计数排名前三的结果 2需求分析 3案例实操
object TestWordCount {def main(args: Array[String]): Unit {// 单词计数将集合中出现的相同的单词进行计数取计数排名前三的结
果val stringList List(Hello Scala Hbase kafka, Hello
Scala Hbase, Hello Scala, Hello)// 1) 将每一个字符串转换成一个一个单词val wordList: List[String]
stringList.flatMap(strstr.split( ))//println(wordList)// 2) 将相同的单词放置在一起val wordToWordsMap: Map[String, List[String]]
wordList.groupBy(wordword)//println(wordToWordsMap)// 3) 对相同的单词进行计数// (word, list) (word, count)val wordToCountMap: Map[String, Int]
wordToWordsMap.map(tuple(tuple._1, tuple._2.size))// 4) 对计数完成后的结果进行排序降序val sortList: List[(String, Int)]
wordToCountMap.toList.sortWith {(left, right) {left._2 right._2}}// 5) 对排序后的结果取前 3 名val resultList: List[(String, Int)] sortList.take(3)println(resultList)}
}7.7.6 复杂 WordCount 案例
1方式一
object TestWordCount {def main(args: Array[String]): Unit {// 第一种方式不通用val tupleList List((Hello Scala Spark World , 4), (Hello
Scala Spark, 3), (Hello Scala, 2), (Hello, 1))val stringList: List[String] tupleList.map(t(t._1
) * t._2)//val words: List[String]
stringList.flatMap(ss.split( ))val words: List[String] stringList.flatMap(_.split( ))//在 map 中如果传进来什么就返回什么不要用_省略val groupMap: Map[String, List[String]]
words.groupBy(wordword)//val groupMap: Map[String, List[String]]
words.groupBy(_)// (word, list) (word, count)val wordToCount: Map[String, Int] groupMap.map(t(t._1,
t._2.size))val wordCountList: List[(String, Int)]
wordToCount.toList.sortWith {(left, right) {left._2 right._2}}.take(3)//tupleList.map(t(t._1 ) * t._2).flatMap(_.split(
)).groupBy(wordword).map(t(t._1, t._2.size))println(wordCountList)}
}2方式二
object TestWordCount {def main(args: Array[String]): Unit {val tuples List((Hello Scala Spark World, 4), (Hello
Scala Spark, 3), (Hello Scala, 2), (Hello, 1))// (Hello,4),(Scala,4),(Spark,4),(World,4)// (Hello,3),(Scala,3),(Spark,3)// (Hello,2),(Scala,2)// (Hello,1)val wordToCountList: List[(String, Int)] tuples.flatMap
{t {val strings: Array[String] t._1.split( )strings.map(word (word, t._2))}}// Hello, List((Hello,4), (Hello,3), (Hello,2), (Hello,1))// Scala, List((Scala,4), (Scala,3), (Scala,2)// Spark, List((Spark,4), (Spark,3)// Word, List((Word,4))val wordToTupleMap: Map[String, List[(String, Int)]]
wordToCountList.groupBy(tt._1)val stringToInts: Map[String, List[Int]]
wordToTupleMap.mapValues {datas datas.map(t t._2)}stringToInts/*val wordToCountMap: Map[String, List[Int]]
wordToTupleMap.map {t {(t._1, t._2.map(t1 t1._2))}}val wordToTotalCountMap: Map[String, Int]
wordToCountMap.map(t(t._1, t._2.sum))println(wordToTotalCountMap)*/}
}7.8 队列
1说明 Scala 也提供了队列Queue的数据结构队列的特点就是先进先出。进队和出队的方 法分别为 enqueue 和 dequeue。 2案例实操
object TestQueue {def main(args: Array[String]): Unit {val que new mutable.Queue[String]()que.enqueue(a, b, c)println(que.dequeue())println(que.dequeue())println(que.dequeue())}
}7.9 并行集合
1说明 Scala 为了充分使用多核 CPU提供了并行集合有别于前面的串行集合用于多核 环境的并行计算。 2案例实操
object TestPar {def main(args: Array[String]): Unit {val result1 (0 to 100).map{case _
Thread.currentThread.getName}val result2 (0 to 100).par.map{case _
Thread.currentThread.getName}println(result1)println(result2)}
}
