![](http://e-1.cn/wp-content/uploads/2023/05/frc-93829c6380dd5e8bf7d31a15dfdbf451.png)
目录
集合介绍:
不可变集合继承图:编辑
可变集合继承图
数组:
不可变数组:
样例代码:
遍历集合的方法:
1.for循环
2.迭代器
3.转换成List列表:
4.使用foreach()函数:
可变数组:
ArrayBuffer:
二维数组:
List集合:
Set 集合:
不可变 Set:
可变Set:
Map集合:
创建map:
map集合的遍历:
可变map:
元组:
tuple的定义:
元组与map的关系:
特点:
集合介绍:
Scala
的集合有三大类:序列
Seq
、集
Set
、映射
Map
,所有的集合都扩展自
Iterable
)对于几乎所有的集合类,
Scala
都同时提供了
可变
和
不可变
的版本,分别位于以下两
scala.collection.
immutable
scala.collection.
mutable
)
Scala
不可变集合,就是指该集合对象不可修改,每次修改就会返回一个新对象,而
java
中的
String
对象
)可变集合,就是这个集合可以直接对原对象进行修改,而不会返回新的对象。类似
java
中
StringBuilder
对象
不可变集合:
不可变集合继承图:![](http://e-1.cn/wp-content/uploads/2023/05/frc-f6baeb28074e50abb0ba258b0ef414fd.png)
set集合特点:无序,不重复
对set集合无序的理解:set集合的无序是指在使用append等方法给集合添加元素的时候所添加的元素的顺序是不可预测的,并且不能按照添加顺序进行遍历(存储位置是不一定的)
Set集合的无序性是由它的实现方式所决定的。通常,Set集合的实现方式采用了哈希表这种数据结构,其中元素被散列到桶中,不同的元素可能被散列到同一个桶中,因此添加的顺序不能保证元素的顺序。
set集合提供了SortedSet集合是有序的(放入2,3,1,4会按照1,2,3,4进行存储)SortedSet写了一个TreeSet集合是树状存储
是
Java
没有的,我们发现
List
归属到
Seq
了,因此这里的
List
就和
Java
不是同一个
for
循环有一个
1 to 3
,就是
IndexedSeq
下的
Range
Queue(队列)
和
Stack (栈)
被归属到
LinearSeq(
线性序列
)
和
LinearSeq
的区别:
1
)
IndexedSeq
是通过索引来查找和定位(相当于数组,通过下标查找),因此速度快,比如
String 就是一个索引集
2
)
LinearSeq
是线型的,即有头尾的概念,这种数据结构一般是通过遍历来查找
可变集合继承图
数组:
不可变数组:
不可变集合是长度不可变
Scala中的array 是与 Java中的[]对应
样例代码:
package chapter05
object Test01_Array {
def main(args: Array[String]): Unit = {
val array = new Array[Int](4)
array(3)=100
//遍历
for (elem
在Scala中没有写方法名的都是调用了apply方法
遍历集合的方法:
1.for循环
上边样例代码已经使用
2.迭代器
迭代器相当于是指针的跳转(指针在内存中的跳转)
样例代码:
package chapter05
object Test01_Array {
def main(args: Array[String]): Unit = {
val array = new Array[Int](4)
array(3)=100
val iterator: Iterator[Int] = array.iterator
while (iterator.hasNext)
{
val i: Int = iterator.next()
println(i)
}
}
}
3.转换成List列表:
array集合可以通过to方法转换成List列表
4.使用foreach()函数:
在Scala中给所有的集合都提供了一个foreach()方法 进行函数式打印
foreach()源码:
def foreach[U](f: A => U): Unit = {
var i = 0
val len = length
while (i
源码分析:
foreach()传入的参数实际是传入的函数
A:是代表你传入集合的类型
U:是泛型,代表你的输出类型
这个函数的返回值是Unit类型
让后通过while进行向下运行
对foreach()函数的调用使用匿名函数进行调用
array.foreach(i=>println(i*2))
可变数组:
数组是默认的不可变的,如果需要可变是需要自己导包的
ArrayBuffer:
填入的初始化大小(数组的大小) 只决定了创建底层结构的长度(不填的话默认是16)
ArrayBuffer是可以进行添加元素的append()
可以进行增删改查
可变数组与不可变数组元素的增加区别:
可变的用方法不可变的用符号
代码样例:
可变数组的增删改查:
package chapter05
import scala.collection.mutable.ArrayBuffer
object Test_02_ArrayBuffer {
def main(args: Array[String]): Unit = {
//可变---导包
val arrayBuffer = new ArrayBuffer[Int](4)
arrayBuffer.append(1,2,3)
arrayBuffer.remove(1)
arrayBuffer.update(0,100)
println(arrayBuffer(0))
println(arrayBuffer)
}
}
不可变数组是不可变的,如果使用符号做出改变会生成一个新的对象
val array = new Array[Int](10)
val array1: Array[Int]= array :+ 8
println(array1.toList)
使用to方法可以让可变与不可变数组进行相互转换
二维数组:
二维数组的定义与遍历:
val array2: Array[ Array[Int]] = Array(Array(1, 2, 3),Array(1, 2, 3),Array(1, 2, 3))
for (array3
在Scala中创建多维数组的方法:
val array3: Array[Array[Int]] = Array.ofDim[Int](3, 4)
List集合:
List是一个抽象类 在不继承的情况下是无法new的,所以需要使用伴生对象的apply方法
直接使用即可
1
)
List
默认为不可变集合
2
)创建一个
List
(数据有顺序,可重复)
val list = List(1, 2, 3, 4)
3
)遍历
List
list.foreach(println)
4
)
List
增加数据
val ints: List[Int] = list :+ 10
ints.foreach(println)
val list1: List[Int] = 10 :: list
list1.foreach(println)
5
)集合间合并:将一个整体拆成一个一个的个体,称为扁平化
val list2 = List(5, 6, 7, 8)
val ints1: List[Int] = list ::: list2
println(ints1)
6
)取指定数据
println(ints1(5))
7
)空集合
Nil
Nil是一个空集合,相当于创建一个空的List,他是一个单独的对象
val ints2: List[Int] = 1 :: 2 :: 4 :: 5 :: Nil
val ints3: List[Int] = 3 :: 6 :: 7 :: 9 :: List()
上述两行代码代表的是一个意思
Set 集合:
使用的是不可变集合,如果你想使用可变集合,需要引用
包
不可变 Set:
1
)
Set
默认是不可变集合,数据无序
2
)数据不可重复(set集合的使用场景—->去重)
val value: Any = Set(1, 1, 2,2,3, 4, 5, 6, 7, 8, 9)
println(value)
运行结果:
判断set的类型:
val bool: Boolean = value.isInstanceOf[HashSet[Int]]
println(bool)
可变Set:
val ints: mutable.Set[Int] = mutable.Set(1, 2, 2, 3, 1, 4, 5, 6, 8, 7, 9)
可变Set的增加是add方法,不是append方法
可变Set的集合也是符合不可重复,不可修改的特点
只可增删查
Map集合:
map集合也是一个特质,可以通过apply方法创建对象
map是一个(k,v)集合
创建map:
(1)这是一种采用元组的方式创建的
val map = Map(("hello", 10), ("world", 20))
(2)这是采用的箭头的方式创建的
val map1 = Map("hello" -> 10, "world" -> 12)
常用第一种方式创建
map集合的遍历:
(采用第一种方式创建的)
for循环得到的对象是元组
for (elem
在Scala中value的类型为Int类型 在Java中是Int的包装类(防止在get方法找value不存在的时候为Null的情况)
上述情况也会在Scala中出现,Scala是对get方法使用Option(是一个抽象类,被两个子类实现(None,Some))封装
如果get的key存在 就调用上述的some类 再对结果进行调用get 转换成int类型 (方法很长,而且在没有值的情况下是会报错的)
因为太长引入了新的写法:
对map集合直接调用getOrElse(1)方法 设置1 有值输出值 无值输出1
val i: Int = map.getOrElse("hello", 1)
println(i)
不存在就会返回None
可变map:
可变map也是采用mutable.map进行创建
增删改查:
增加:
put方法 这个方法可以增加也可以进行修改 当key值存在的时候 如果value不同会覆盖前值
val maybeInt: Option[Int] = map.put("helloi2", 23)
删除:
val maybeInt1: Option[Int] = map.remove("hello")
查找:
查找与不可变一样使用getOrElse方法进行查找
元组:
本身为不可变 ,可以存放不同数据类型的元素
list具有上述的性质 但是使用list存放不同类型的数据 在调用的时候无法得到相应的类型(统一为Any)而tuple(元组可以)
tuple的定义:
val tuple: (String, Int) = ("hihihi", 23)
元组与map的关系:
map中的(key value )元素被默认当作二元组
特点:
这样我们可以实现list集合与map集合的转换
val toList: List[(String, Int)] = map1.toList
println(toList)
运行结果: