List
Scala 中的 List 和 Java List 不一样,在 Java 中 List 是一个接口,真正存放数据是 ArrayList,而 Scala 的 List 可以直接存放数据,就是一个 object,默认情况下 Scala 的 List 是不可变的,List 属于序列 Seq
val List = scala.collection.immutable.List
object List extends SeqFactory[List]
//集合在scala.collection.mutable(immutalbe)._ 不引入包也能使用List
//原因: package object scala 包中声明了
//val List = scala.collection.immutable.List
//val Nil = scala.collection.immutable.Nil
val list01 = List(1, 2, 3) //创建时,直接分配元素 调用 apply
println(list01)
val list02 = Nil //空集合
println(list02)
List 中可以放任何数据类型,比如 arr1 的类型为 List[Any]
如果希望得到一个空列表,可以使用 Nil 对象
元素访问: list1(1)
向列表中增加元素, 会返回新的列表/集合对象。注意:Scala 中 List 元素的追加形式非常独特
var list1 = List(1, 2, 3, "abc")
// :+运算符表示在列表的最后增加数据
// :+ 符号 : 前是集合 + 后是元素
val list2 = list1 :+ 4
println(list1) //list1没有变化
println(list2) //结果是 [1, 2, 3, "abc", 4]
//给list向前面追加
// +: 符号 : 后是集合 + 前是元素
val list3 = 100 +: list1
println("list3=" + list3) // [100, 1, 2, 3, "abc"]
- 符号 : : 表示向集合中添加元素, 返回一个新集合。
- 运算时,集合对象一定要放置在最右边,
- 运算规则,从右向左。
- : : : 运算符是将集合中的每一个元素加入到空集合中去, : : : 左右两边都需要是集合
// :: 使用
val list4 = List(1, 2, 3, "abc")
// 步骤
// 1. ()
// 2. (List(1, 2, 3, "abc"))
// 3. (6, List(1, 2, 3, "abc"))
// 4. (5, 6, List(1, 2, 3, "abc"))
// 5. (4, 5, 6, List(1, 2, 3, "abc"))
val list5 = 4 :: 5 :: 6 :: list4 :: Nil
println("list5=" + list5)
// ::: 的使用
//下面等价 4 :: 5 :: 6 :: list1
var list6 = List(1, 2, 3, "abc")
// 步骤
// 1. ()
// 2. (1, 2, 3, "abc")
// 3. (6, 1, 2, 3, "abc")
// 4. (5, 6, 1, 2, 3, "abc")
// 5. (4, 5, 6, 1, 2, 3, "abc")
val list7 = 4 :: 5 :: 6 :: list6 ::: Nil
println("list7=" + list7)
ListBuffer
ListBuffer 是可变的 list 集合,可以添加,删除元素, ListBuffer 属于序列
//添加
val lst1 = new ListBuffer[Int]
lst1 += 4 //lst1(4)
lst1.append(5) //lst1(4,5)
//++ 表示的是加入的是集合中的各个元素
lst0 ++= lst1 //lst0(1,2,3,4,5)
val lst2 = lst0 ++ lst1 //lst2(1,2,3,4,5,4,5)
val lst3 = lst0 :+ 5 // 单独的加入元素 (1,2,3,4,5,5)
lst1.remove(1) //使用remove进行删除
队列 Queue
队列是一个有序列表,在底层可以用数组或是链表来实现。
其输入和输出要遵循先入先出的原则。即:先存入队列的数据,要先取出。后存入的要后取出
在 Scala 中, 有 scala.collection.mutable.Queue 和 scala.collection.immutable.Queue , 一般来说,我们在开发中通常使用可变集合中的队列
//这里的Int是泛型,表示q1队列只能存放Int类型
//如果希望q1可以存放其它类型或加入一个List,则使用 Any 即可。
val q1 = new mutable.Queue[Int]
//追加单个元素
q1 += 1
q1 += 2
println(q1) //(1,2)
q1 ++= List(4, 5, 6) //(1,2,3,4,5,6)
//如果希望加入一个List或者其他的类型,则需要将Queue的泛型指定为[Any]
q1 += List(8,9) //(1,2,3,4,5,6, List(8,9))
//dequeue的操作,是出队列(即将队列的头元素取出)
val ele = q1.dequeue()
println("ele=" + ele) //1
println("q1=" + q1) // (2,4,5,6)
//enqueue的操作,表示给队列尾部加入数据
q1.enqueue(10,20,30)
println("q1=" + q1) // (2,4,5,6,10,20,30)
//head
println("q1.head=" + q1.head) // 2
//last
println("q1.last=" + q1.last) // 30
//tail的用法, 除去第一个元素剩下的所有元素
println(q1.tail.tail) //(5,6,10,20,30)
println("q1=" + q1) // (2,4,5,6,10,20,30)
映射 Map
HashMap 是一个散列表(数组+链表),它存储的内容是键值对 (key-value) 映射,Java 中的 HashMap 是无序的,key 不能重复
Scala 中,有可变 Map (scala.collection.mutable.Map) 和不可变 Map(scala.collection.immutable.Map)
Scala 中的 Map 和 Java 类似,也是一个散列表,它存储的内容也是键值对 (key-value) 映射,Scala 中不可变的 Map 是有序的,可变的 Map 是无序的
创建不可变映射
Scala 中的不可变 Map 是有序,构建 Map 中的元素底层是 Tuple2 类型
val map1 = Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京")
- 输出顺序和声明顺序一致
- 默认情况下(即没有引入其它包的情况下), Map 是不可变 Map
创建可变映射
val map2 = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> 30)
- 输出顺序和声明顺序不一致
- 需要指定可变 Map 的包
创建空映射
val map3 = new scala.collection.mutable.HashMap[String, Int]
创建包含键值对的二元组
val map4 = mutable.Map( ("A", 1), ("B", 2), ("C", 3),("D", 30) )
取值
方式1 - 使用 map(key) val value1 = map2("Alice")
- 如果 key 存在,则返回对应的值
- 如果 key 不存在,则抛出异常 [java.util.NoSuchElementException]
- 在 Java 中,如果 key 不存在则返回 null
方式2 - 使用 contains 方法检查是否存在 key map4.contains("B")
1.如果 key 存在,则返回 true
2.如果 key 不存在,则返回 false
方式3 - 使用map.get(key).get取值
通过 映射.get(键) 这样的调用返回一个 Option 对象,要么是 Some,要么是 None
var map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
println(map4.get("A")) //Some
println(map4.get("A").get) //得到Some再取出
- map.get 方法会将数据进行包装
- 如果 map.get(key) key 存在返回 some, 如果 key 不存在,则返回 None
- 如果 map.get(key).get key 存在,返回 key 对应的值,否则,抛出异常 java.util.NoSuchElementException: None.get
方式4 - 使用 map4.getOrElse() 取值
getOrElse 方法 : def getOrElse[V1 >: V](key: K, default: => V1)
说明:
如果 key 存在,返回key对应的值。
如果 key 不存在,返回默认值。在java中底层有很多类似的操作。
val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
println(map4.getOrElse("A","默认值"))
总结
- 如果我们确定 key 是存在的,应该使用 map("key") ,速度快.
- 如果我们不确定 key 是否存在, 而且在不存在时,有业务逻辑处理就是用 map.contains() 配合 map("key")
- 如果只是简单的希望返回一个值,就使用 getOrElse()
修改、添加和删除
val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
map4("A") = 20 //修改和增加
- map 是可变的,才能修改,否则报错
- 如果key存在:则修改对应的值,key不存在,等价于添加一个key-val
map4.remove(key) //删除
遍历
1.每遍历一次,返回的元素是 Tuple2
2.取出的时候,可以按照元组的方式来取
val map1 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
for ((k, v) <- map1) println(k + " is mapped to " + v)
for (v <- map1.keys) println(v)
for (v <- map1.values) println(v)
for(v <- map1) println(v) //v是Tuple2
集 Set
集是不重复元素的结合。集不保留顺序,默认是以哈希集合实现
java中,HashSet 是实现 Set<E> 接口的一个实体类,数据是以哈希表的形式存放的,里面的不能包含重复数据。Set 接口是一种不包含重复元素的 collection,HashSet 中的数据也是没有顺序的
默认情况下,Scala 使用的是不可变集合,如果想使用可变集合,需要引用 scala.collection.mutable.Set 包
val set01 = Set(1,2,4,"abc")
val set02 = mutable.Set(1,2,4,"abc")
可变集删除
val set02 = mutable.Set(1,2,4,"abc")
set02 -= 2 // 操作符形式
set02.-=(4) // ok
set02.remove("abc") // 方法的形式,scala的Set可以直接删除值
如果删除的对象不存在,则不生效,也不会报错
遍历
val set02 = mutable.Set(1, 2, 4, "abc")
for(x <- set02) {
println(x)
}
最大最小值
val set03 = Set(1,9,-10)
println("max=" + (set03 max)) //9
println("max=" + (set03 min)) //-10