一, 概述
1, 特点
1)Scala 同时支持不可变集合和可变集合
2)两个主要的包:
不可变集合: scala.collection.immutable
可变集合: scala.collection.mutable
3)Scala 默认采用不可变集合, 对于几乎所有的集合类, Scala 都同时提供了可变 (mutable) 和不可变 (immutable) 的版本
4)Scala 的集合有三大类: 序列 Seq, 集 Set, 映射 Map, 所有的集合都扩展自 Iterable 特质, 在 Scala 中集合有可变 (mutable) 和不可变 (immutable) 两种类型.
2, 不可变集合继承一览图
3, 可变集合继承一览图
二, 数组
1, 可变和不可变:
Array ===> ArrayBuffer
2, 定义不可变数据数组方式
- // 定义数组: 方式一
- val arr = new Array[Int](10)
- // 定义数组: 方式二
- val arr = Array(1,2,"scala") // 调用 apply 方法
- arr(1)=8 // 赋值, 索引 1 的值为 8
- // 添加, 生成一个新的数组
- arr.+:(4)
- // 删除, 删除值为 1 的元素(并且只刪除第一个)
- val array: Array[Any] = arr.drop(1)
- // 改, 修改索引 1 的值为 6
- arr.update(1,6)
- arr(1)=8
3, 定义变长数组
- // 定义变长数组
- val ints = new ArrayBuffer[Int]()
- val ints = ArrayBuffer[Int](1, 5, 9)
- // 添加, 同一个数组
- ints.append(10)
- // 删除, 删除索引为 2 之后的 2 个元素
- ints.remove(2,2)
- // 改, 同定长数组
- ints(1)=20
- ints.update(1,20)
4, 定长数组与变长数组转换
- )arr1.toBuffer // 定长数组转可变数组
- )arr2.toArray // 可变数组转定长数组
5, 多维数组
- // 定义 arr 是一个二维数组: 有三个元素[一维数组], 每个一维数组存放 4 个值
- val arr = Array.ofDim[Double](3,4)
- // 赋值
- arr(1)(1) = 11.11
6,Scala 数组与 Java 的 List 互转
- // Scala 集合转成 Java 集合
- val arr = ArrayBuffer("1", "2", "3")
- import scala.collection.JavaConverters._ // 隐式转换
- val javaList: util.List[String] = arr.asJava
- println(javaList) //[1, 2, 3]
- //java 的 List 转成 scala 的 ArrayBuffer
- val arrList = new util.ArrayList[String]()
- arrList.add("test")
- // 隐式转换
- import scala.collection.JavaConversions.asScalaBuffer
- import scala.collection.mutable
- val scalaArr: mutable.Buffer[String] = arrList
三, 元组
1, 简介
元组也是可以理解为一个容器, 可以存放各种相同或不同类型的数据.
说的简单点, 就是将多个无关的数据封装为一个整体, 称为元组, 最大的特点灵活, 对数据没有过多的约束. // 需求 -> 高效率
2, 创建
- //1. tuple 的类型是 Tuple3
- //2. 根据元素个数不同, 对应的类型是 Tuple1----Tuple22
- //3. Tuple 是一个整体, 使用迭代器进行遍历
- //4. 访问 Tuple 的元素的方式是 tuple._1 .... tuple._3
- //5. 元组是 scala 推荐使用, 在 java 没有
- val tuple = (1, 2, "scala")
四, 集合
1, 定义:
Scala 的 List 可以直接存放数据, 就是一个 object, 默认情况下 Scala 的 List 是不可变的, List 属于序列 Seq.
不可变, 可变: List ===> ListBuffer
2, 创建:
val ints:List[Int] = List(1,2,3) // 创建
List 默认采用不可变方式在 immutable 包下不用引包, List 中可以放任何类型数据 List[Any], 空集合可以直接使用 Nil 对象
3,List 常用操作
- val ints = List(1,2,4,5)
- // 添加
- val ints1 = ints :+ 20 //ints 集合后面追加
- val ints2 = 10 +: ints //ints 集合前面添加
- val ints3 = 1 :: ints // 将 1 作为元素往 ints 中添加
- val ints3 = ints1 :: ints // 将 ints1 中的元素与 ints 中元素合并为一个集合,::: 两边都是集合
- // 修改, 会生成一个新的集合
- val intsUpdate = ints .updated(1,15)
- // 删除, 截取原集合指定索引以及后面的所有元素生成一个新的集合
- val intsDrop = ints.drop(2) //List(4, 5)
4,ListBuffer 常用操作
- val buffer = ListBuffer(6,7,8)
- // 添加
- buffer.append(10)
- // 修改
- buffer.update(1,1)
- // 删除
- buffer.remove(3)
- println(buffer.mkString(",")) //6,1,10
五, Map
1, 定义
Scala 中的 Map 和 Java 类似, 也是一个散列表, 它存储的内容也是键值对 (key-value) 映射, Scala 中不可变的 Map 是有序的, 可变的 Map 是无序的.
不可变, 可变: scala.collection.immutable.Map ===> scala.collection.mutable.Map
2, 不可变 immutable.Map
- // 创建
- // 方式一: 底层为元组 Tuple2 类型, 输出顺序与声明顺序一致
- val map1 = Map("A" -> 10, "B" -> 20, "C" -> 30)
- // 方式二: 对偶元组
- val map2 = Map( ("A", 1), ("B", 2), ("C", 3),("D", 30) )
3, 可变 mutable.Map
- // 创建: 输出顺序与声明顺序不一致
- val map1 = scala.collection.mutable.Map("A" -> 10, "B" -> 20, "C" -> 30)
- // 添加
- // 添加并创建一个新的 map
- val map2 = map1 + ("FFF"->10)
- // 添加, 追加到原有 mao 中
- map1 += ("FFF"->10)
- // 删除指定 key
- map1 -= ("B","C")
- // 修改指定 key 的值, 如果没有改 key 就为添加
- map1.update("A",888)
4,Map 取值
- //key 不存在抛异常 NoSuchElementException
- map(key)
- //map.get(key)得到 Option 对象, 要么是 Some 要么是 None
- map.get(key).get
- //key 存在返回值, 不存在返回默认值
- map.getOrElse(key,default)
六, Set
1, 可变不可变
immutable.Set ===> mutable.Set
2, 可变 set 集合操作
- // 创建可变 set 集合
- val mutableSet = mutable.Set(1,2,3)
- // 添加元素的两种方式
- mutableSet.add(6)
- mutableSet += 7
- // 删除元素的两种方式
- mutableSet -= 2
- mutableSet.remove(10)
来源: https://www.cnblogs.com/bbgs-xc/p/13222040.html