1、集合简介
说明
- Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。
- 对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包
不可变集合：scala.collection.immutable
可变集合： scala.collection.mutable - Scala不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。
- 可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。
- 默认都是不可变的
2、Array 数组有关操作
object Demo01Array {
def main(args: Array[String]): Unit = {
/* 不可变的数组 该集合对象不可修改 */
val arr1 = new Array[Int](6)
for (i <- arr1){
/* int默认是 0 */
print(i + " ")
}
println()
/* 赋值 */
arr1(0) = 666
/* 取值 */
println("赋值后在取值后的数组的第一个元素为： " + arr1(0))
/* 不可变数组，一旦被创建，数组长度就固定了 =>下标越界了！！！ arr1(6) = 777 */
/* String默认是 null */
val arr2 = new Array[String](6)
for (i <- arr2){
print(i + " ")
}
println()
/* 使用apply方式创建 */
val arr03 = Array(1, 2, 3, 4, 5, 6)
/* 重新赋值 */
arr03(0) = 888
/* 不可变数组 直接输出是地址值 */
println("不可变数组直接输出数组为地址值： " + arr03)
/* 不可变数组转换成可变数组 */
println("不可变数组转成可变数组后直接输出数组为： " + arr03.toBuffer)
/* 可变数组转换成不可变数组 */
println("可变数组再次转换成不可变数组输出为： " + arr03.toBuffer.toArray)
/* foreach形式遍历数组第一种 */
arr03.foreach( i => print(i + " "))
println()
/* foreach形式遍历第二种 _代表每一个元素 */
arr03.foreach(print(_))
println()
/* 定义一个打印所有的方法，为下方foreach遍历准备 */
def printFunction(i: Int) = {
print(i + " ")
}
/* foreach形式遍历第三种 调用上方的打印的方法，传入参数为所有的 */
arr03.foreach(printFunction(_))
println()
/* mkString将数组元素转化成字符串 */
println("将数组元素转化成字符串为： " + arr03.mkString(","))
println("将数组元素转化成字符串为： " + arr03.mkString("+","-","="))
println("====================")
/*
可变的数组
需要导包 scala.collection.mutable.ArrayBuffer
*/
/* 导包 可变数组 */
import scala.collection.mutable.ArrayBuffer
/* 创建可变数组 */
val arrayBuffer01 = ArrayBuffer[Int](1, 2, 3, 4, 5)
println("直接输出可变数组ArrayBuffer为： " + arrayBuffer01)
/* 添加元素的几种形式 */
arrayBuffer01.append(369)
/* 添加元素并确定添加元素索引 */
arrayBuffer01.insert(1,100)
arrayBuffer01 += 200
/* 添加元素的时候加 . 后后面添加的元素必须加上小扩号 */
arrayBuffer01 .+= (500)
println("添加完元素后的可变数组为： " + arrayBuffer01)
/* 删除元素 根据索引删除 */
arrayBuffer01.remove(2)
println("删除元素后的可变数组为： " + arrayBuffer01)
/* 修改元素 */
arrayBuffer01(0) = 555
print("修改元素后遍历可变数组为: ")
def updateFunction(i: Int) = {
print(i + " ")
}
arrayBuffer01.foreach(updateFunction(_))
println()
/* 将可变数组转换成字符串 */
println("将可变数组转换成字符串为： " + arrayBuffer01.mkString(","))
/* 输出可变数组的元素的最大值 */
println("可变数组的元素的最大值为： " + arrayBuffer01.max)
/* 输出可变数组的元素的最小值 */
println("可变数组的元素的最大值为： " + arrayBuffer01.min)
/* 输出可变数组的元素的值的总和 */
println("可变数组的元素的值的总和为： " + arrayBuffer01.sum)
/* 输出可变数组的元素的大小*/
println("可变数组的元素的大小为： " + arrayBuffer01.size)
/* 输出可变数组的元素的长度*/
println("可变数组的元素的长度为： " + arrayBuffer01.length)
/* 输出可变数组排序后的结果 默认是升序排列*/
println("可变数组默认排序后的结果为： " + arrayBuffer01.sorted)
/* 输出可变数组排序后的结果 自己定义降序排列 */
println("可变数组自定义排序后的结果为： " + arrayBuffer01.sortWith(_>_))
/* 输出可变数组排序后的结果 自己定义降序排列 */
println("可变数组自定义排序后的结果为： " + arrayBuffer01.sortBy(i => i))
/* 将可变数组的每一个元素乘以10，再转换成字符串输出为 */
println("将可变数组的每一个元素乘以10，再转换成字符串为： " + arrayBuffer01.map(_ * 10).mkString("-"))
/* 取出可变数组中所有的偶数 filter()方法 留下所有为true的，过滤掉其他的 */
println("可变数组中所有的偶数为： " + arrayBuffer01.filter(_ % 2 == 0).mkString("-"))
/* 多维数组 创建一个三行三列的二维数组 */
val array = Array.ofDim[Int](3, 3)
/* 给第三行第二列的元素赋值 */
array(2)(1) = 100
/* 遍历二维数组 */
for (i <- array){
// 此时i就相当于一个一维数组
for (j <- i){
// 相当于从一维数组中取值
print(j + " ")
}
}
println()
println("二维数组的第三行第二列的值为： " + array(2)(1))
}
}
3、Seq集合（List）有关操作
不可变List 说明
（1）List默认为不可变集合
（2）创建一个List（数据有顺序，可重复，插入有顺序）
（3）遍历List
（4）List增加数据
（5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化
（6）取指定数据
（7）空集合Nil
可变ListBuffer 说明
（1）创建一个可变集合ListBuffer
（2）向集合中添加数据
（3）打印集合数据
object Demo02list {
def main(args: Array[String]): Unit = {
/*
不可变的集合
List 有序(插入顺序排列)
*/
/* 创建不可变的集合 */
var list01 = List(1, 2, 3, 4, 5)
println("不可变的集合直接输出为： " + list01)
/* 往集合左边添加元素 */
println("从集合左边添加完元素的不可变集合为=============")
//println(666 :: list01)
// 需要拿集合本身接收
list01 = list01 .+: (666)
println("qqqqq" + list01)
println(list01 .:: (888))
println(369 +: list01)
println(list01 .+: (110))
println("从集合右边添加完元素的不可变集合为=============")
/* 往集合右边添加元素 */
println(list01 :+ 120)
println(list01 .:+ (119))
/* 集合的Nil 就是一个空的list01 */
println("集合的Nil为： " + Nil)
print("添加元素到Nil的结果为： ")
/* 向Nil中添加元素 */
println(1::2::3::Nil)
/* head代表list01的第一个元素 */
println("不可变集合的第一个元素为： " + list01.head)
/* tail代表list01集合的除了第一个元素的所有元素 */
println("不可变集合的除了第一个元素的所有元素为： " + list01.tail)
/* 创建第二个List集合 */
val list02 = List(110, 120, 119, 144, 158)
/* 集合合并 */
print("两个集合合并为：")
println(list01 ::: list02)
/* foreach遍历List集合 */
def ListFunction(i: Int) = {
print(i + " ")
}
print("foreach遍历List集合为： ")
println(list02.foreach(ListFunction(_)))
println("List集合的最大值为： " + list02.max)
println("List集合的最小值为： " + list02.min)
println("List集合的总和为： " + list02.sum)
println("List集合的大小为： " + list02.size)
println("List集合的长度为： " + list02.length)
println("List集合的默认排序升序为： " + list02.sorted)
println("List集合的自定义排序降序为： " + list02.sortWith(_>_))
/* 反转 */
println("List集合的默认排序升序后的反转为： " + list02.sorted.reverse)
/* take(3) 取List前三个元素 */
println("取List集合的前三个元素为： " + list02.sorted.reverse.take(3))
/*
可变的集合
ListBuffer
*/
import scala.collection.mutable.ListBuffer
var listBuffer = ListBuffer(111, 222, 555, 333)
println("可变集合直接输出为： " + listBuffer)
/* 往集合左边添加元素 这种添加事实上没有添加进去*/
println("从集合左边添加完元素的可变集合为=============")
//println(369 +: listBuffer)
listBuffer = 369 +: listBuffer
println("aaaaaa" + listBuffer)
// println(listBuffer .:+ (110))
// println("从集合左边添加完元素的可变集合为 ：" + listBuffer)
println("从集合右边添加完元素的可变集合为=============")
/* 往集合右边添加元素 */
// println(listBuffer :+ 120)
// println(listBuffer .:+ (119))
println(listBuffer += 666)
println(listBuffer.append(200))
println(listBuffer.insert(1,888))
println(listBuffer)
/* 删除元素 */
println(listBuffer -= 888)
/* 根据索引删除元素 删除一个 */
listBuffer.remove(1)
println("删除元素后的可变集合为： " + listBuffer)
/* 根据索引删除元素 从索引几开始 删除几个元素 */
listBuffer.remove(1,3)
println("删除元素后的可变集合为： " + listBuffer)
/* 获取集合中最后一个元素 */
println("集合中最后一个元素为： " + listBuffer.last)
/* 将可变的集合转换成不可变的集合 */
val list = listBuffer.toList
println("可变的集合转换成不可变的集合为： " + list)
/* 将不可变的集合转换成可变的集合 */
val buffer = list01.toBuffer
println("不可变的集合转换成可变的集合为： " + buffer)
}
}
4、Set集合有关操作
不可变Set 说明
（1）Set默认是不可变集合，数据无序(插入顺序无序)
（2）数据不可重复
（3）遍历集合
object Demo03Set {
def main(args: Array[String]): Unit = {
/*
默认不可变集合
Set 无序(不会按插入顺序排列)
默认是 HashSet
*/
var set01 = Set(1, 2, 3, 4, 5)
println(set01)
/* 这种添加实际上没有添加进去 */
println(set01 + 66)
/* foreach遍历 */
set01.foreach(println(_))
println("===================")
/* 对于不可变set，每次修改就会返回一个新对象，而不会对原对象进行修改，所有需要用原对象接收一下才能添加进去值 */
set01 = set01 + 88
println(set01)
println("===================")
/*
可变集合 Set
需要导包 scala.collection.mutable.Set
*/
import scala.collection.mutable.Set
/* 创建可变Set */
val set02 = Set(3, 6, 9)
/* 向Set集合中添加元素 */
set02 += 4
println("添加元素后Set为： " + set02)
/* 从Set集合中删除元素 */
set02.-=(3)
println("删除元素后Set为： " + set02)
}
}
5、Map集合有关操作
- Scala中的Map和Java类似，也是一个散列表，它存储的内容也是键值对（key-value）映射，Scala中不可变的Map是有序的，可变的Map是无序的。
- 使用get访问map集合的数据，会返回特殊类型Option(选项):有值（Some），无值(None)
object Demo04Map {
def main(args: Array[String]): Unit = {
/*
不可变集合 Map
不能重新给一个键赋值
创建方式两种 映射 元组
*/
/* 用映射的方式创建 */
val map01 = Map("刘备" -> "主公", "张飞" -> "五虎将1", "关羽" -> "五虎将2")
println("使用映射形式创建的map直接输出不可变集合Map的值为： " + map01)
/* 使用元组的方式创建 */
val map02 = Map(("李世民", "唐朝"), ("赵匡胤", "宋朝"), ("曹操", "三国"))
println("使用元组形式创建的map直接输出为： " + map02)
/* 获取不可变集合Map中的值 */
println("获取不可变集合Map的刘备键对应的值为： " + map01("刘备"))
/* 获取不可变集合Map中的值，以Some的形式呈现 */
val someString = map01.get("张飞")
println("获取不可变集合Map的刘备键对应的值为： " + someString)
/* 或取Some中的值 */
println("获取不可变集合Map的刘备键对应的值Some对应的值为： " + someString.get)
/* Option 有两个子类 Some None 获取map中不存在的键的值 返回None */
println("获取不可变集合Map中不存在的键对应的值为： " + map01.get("刘备备"))
/* map取值推荐使用getOrElse()方法，键存在返回对应的值，不存在返回默认值 */
/* 存在 */
println("键存在： " + map01.getOrElse("关羽","默认"))
/* 不存在 */
println("键不存在： " + map01.getOrElse("关羽羽","默认"))
/* for循环遍历 键值对的形式 */
for (i <- map01){
print(i)
}
println()
/* for循环遍历 自定义键值对的形式 */
for(i <- map01){
print(i._1 + ":" + i._2 + " ")
}
println()
/* for循环遍历 自定义键值对的形式 */
for((k,v) <- map01){
print(k + ":" + v + " ")
}
println()
/* foreach循环遍历 键值对的形式 */
map01.foreach(print(_))
println()
/* foreach循环遍历 自定义键值对的形式 */
map01.foreach(aaa =>{
print(aaa._1 + " " + aaa._2 + ";")
})
println()
/*
可变集合 Map
需要导包 scala.collection.mutable.Map
创建方式两种 映射 元组
可以重新给一个键赋值
*/
import scala.collection.mutable.Map
val map03 = Map(("李世民", "唐朝"), ("赵匡胤", "宋朝"), ("曹操", "三国"))
/* 给曹操重新赋值 */
map03("曹操") = "东汉末年"
println(map03)
/* 如果赋值的这个键不存在，就直接创建这个键，相当于添加元素 */
map03("朱元璋") = "明朝"
println(map03)
/* 添加元素 */
map03.put("慈禧","清朝")
println(map03)
/* 添加元素 */
map03.+=(("嬴政","秦"))
println(map03)
/* 删除元素 */
map03.remove("嬴政")
println(map03)
map03.keys
map03.keySet
map03.size
// map03.update("",)
map03.contains("")
}
}
6、元组有关操作
- 元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组。
- 注意：元组中最大只能有22个元素。
- Map中的键值对其实就是元组,只不过元组的元素个数为2，称之为对偶
object Demo05Tuple {
def main(args: Array[String]): Unit = {
/*
元组
() 代表一个元组 元组中可以同时存放任意类型的元素
*/
/* 创建第一个元组对象 */
val tuple01 = ("xiaozhang", 18, 18.8, 110L)
println(tuple01)
/* 取值时下标从1开始 */
println(tuple01._1)
/* 创建第二个元组对象 */
val tuple02 = (("xiaozhang", 18, 18.8, 110L),"zhansgan",22,"age")
/* 获取元组中第一个元素的第一个元素 */
println(tuple02._1._1)
/* for循环形式遍历元组 */
for (i <- tuple01.productIterator){
print(i + " ")
}
println()
println("====================")
/* foreach循环形式遍历元组 */
tuple02.productIterator.foreach(println(_))
/* 对偶元组 只有两个元素的元组 */
val tuple03 = ("刘备", "主公")
println(tuple03)
}
}
7、衍生集合常用函数
object Demo01Collection {
def main(args: Array[String]): Unit = {
/* 创建List */
val list01 = List(1, 2, 3, 4, 5,7,8)
var list02 = List(3,4,5,6,7,8,9,10,11,12)
println("list01为： " + list01)
/* 获取前三个元素 */
println("======take========" + list01.take(3))
/* 获取后三个元素 */
println("======takeRight========" + list01.takeRight(3))
/*
takeWhile, 从第一个元素开始判断，满足条件，就留下，
直到遇到第一个不满足的条件的元素，就结束循环
如果第一个不满足条件，那就直接结束循环了
可见，takeWhile 有可能并不是对所有的元素进行操作的
表示，从左边开始，将满足条件的元素取出来，直到遇到第一个不满足条件的元素
*/
list01.takeWhile(_ > 0).foreach{
x => print(x + " ")}
list01.takeWhile(_ > 2).foreach(print(_))
println()
/*
filter，同样，满足条件，就留下。是对所有的元素，进行操作的
表示，取出所有满足条件的元素
*/
list01.filter(_ > 2).foreach{
x => print(x + " ")}
println()
/* drop() 丢弃前几个元素 */
list02 = list02.drop(3)
println("======drop========" + list02)
/* dropRight() 删除后几个元素 */
list02 = list02.dropRight(2)
println("======dropRight========" + list02)
/*
dropWhile移除前几个匹配断言函数的元素
如下 从集合左边删除偶数元素，直到遇见奇数截止
*/
list02 = list02.dropWhile(_ % 2 == 0)
println("======dropWhile========" + list02)
/* 两个集合并集 合并 */
list02 = list01.union(list02)
println("=====union========" + list02)
/* 两个集合交集 */
println(list02.intersect(list01))
/* 两个集合差集 */
println(list02.diff(list01))
/* 拉链 注:如果两个集合的元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用 */
println(list01.zip(list02))
/* 划窗 参数： size(一次取出几个) step(步长，一次跳几个) */
list01.sliding(1,2).foreach(print(_))
println()
/* 划窗 参数： size(一次取出几个) 默认步长为1 */
list01.sliding(2).foreach(print(_))
println()
/* list去重 */
list02 = list02.distinct
println("=====distinct==========" + list02)
}
}
8、集合计算高级函数
object Demo03Function {
def main(args: Array[String]): Unit = {
var list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
/* List中每个元素都加10 */
list = list.map(_ + 10)
println(list)
/* filter方法过滤 自定义过滤条件 过滤掉list中所有偶数 */
println(list.filter(_ % 2 != 0))
/* reduce方法计算 自定义计算规则 */
println(list.reduce((a: Int,b: Int) => a + b))
/* _+_ 第一个_ 代表的是累加的和 第二个_表示每一个元素 */
println(list.reduce(_+_))
/* 嵌套List */
val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
println(nestedList)
/* 扁平化 把嵌套集合内部的集合展开成为单层集合 */
println(nestedList.flatten)
/* 创建List */
val wordList: List[String] = List("hello world", "hello atguigu", "hello scala")
println(wordList)
/* 根据空格切分字符串 切分完List中存放了多个Array */
val stringses: List[Array[String]] = wordList.map(_.split(" "))
println(stringses)
/* 扁平化输出 */
println(stringses.flatten)
/* 相当于 flatMap = map + flatten */
val strings: List[String] = wordList.flatMap(_.split(" "))
println(strings)
/* 分组 */
println(strings.map( word => (word,1) ).groupBy(_._1))
//分组
val intToInts: Map[Int, List[Int]] = list.groupBy(_%2)
println(intToInts)
}
}
WC案例
object Demo04WC {
def main(args: Array[String]): Unit = {
val wordList: List[String] = List("hello world", "hello jinghang", "hello scala")
wordList.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).mapValues(_.size).foreach(println(_))
}
}