Scala 优雅入门 (八) 数据结构 - 列表

 

 

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"]

1. 符号 : : 表示向集合中添加元素, 返回一个新集合。
2. 运算时，集合对象一定要放置在最右边，
3. 运算规则，从右向左。
4. : : :  运算符是将集合中的每一个元素加入到空集合中去, : : : 左右两边都需要是集合

// :: 使用
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" -> "北京")

1. 输出顺序和声明顺序一致
2. 默认情况下（即没有引入其它包的情况下）, Map 是不可变 Map

创建可变映射

val map2 = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> 30)

1. 输出顺序和声明顺序不一致
2. 需要指定可变 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")

1. 如果 key 存在，则返回对应的值
2. 如果 key 不存在，则抛出异常 [java.util.NoSuchElementException]
3. 在 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再取出

1. map.get 方法会将数据进行包装
2. 如果 map.get(key) key 存在返回 some, 如果 key 不存在，则返回 None
3. 如果 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","默认值"))

总结

1. 如果我们确定 key 是存在的，应该使用 map("key") ,速度快.
2. 如果我们不确定 key 是否存在， 而且在不存在时，有业务逻辑处理就是用 map.contains() 配合 map("key")
3. 如果只是简单的希望返回一个值，就使用 getOrElse()

修改、添加和删除

val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
map4("A") = 20 //修改和增加

1. map 是可变的，才能修改，否则报错
2. 如果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