Scala集合 Scala map；Scala set

1、Map

1.1 Java中Map回顾

1.1.1 Java Map

    HashMap是一个散列表（数组+链表实现），他存储的内容是键值对映射，Java中的HashMap是无序的，key不能重复。

1.1.2 实例

import java.util.HashMap;

public class JavaHashMap {

    public static void main(String[] args) {

        HashMap<String,Integer> hm = new HashMap(); 

        hm.put("no1", 100);

        hm.put("no2", 200); 

        hm.put("no3", 300); 

        hm.put("no4", 400); 

        hm.put("no1", 500); //更新

        System.out.println(hm);//无序的 

        System.out.println(hm.get("no2"));

    } 

}

1.2 Scala中的Map

1.2.1 基本介绍

Scala中的Map和Java中类似，也是一个散列表，它存储的内容也是键值对。不同的是：Scala中不可变的Map是有序的，可变的Map是无序的。

1.3 构建Map

1.3.1 构建不可变的Map

    Scala中的不可变Map是有序，构建Map中的元素底层是Tuple2类型

object MapDemo01 {

    def main(args: Array[String]): Unit = {

    //1.默认 Map 是 immutable.Map

    //2.key-value 类型支持 Any

    //3.在 Map 的底层，每对 key-value 是 Tuple2

    val map1 = Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京”) 

    println(map1)

    } 
}

1.3.2 构建可变的Map

//1.从输出的结果看到，可变的 map 输出顺序和声明顺序不一致

val map2 = mutable.Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京”)

println(map2)

1.3.3 创建空的映射

val map3 = new scala.collection.mutable.HashMap[String, Int]

println(map3)

1.3.4 创建对偶元组

即创建包含键值对的二元组， 和第一种方式等价，只是形式上不同而已。 对偶元组 就是只含有两个数据的元组。//可变吗？

val map4 = mutable.Map(("Alice" , 10), ("Bob" , 20), ("Kotlin" , "北京")) 

println("map4=" + map4)

 

1.4 Map取值

1.4.1 方式一使用map（key）

val value1 = map2("Alice”) 

println(value1)

说明：

1. 如果key存在，则返回对应的值

2. 如果key不存在，则会抛出异常【java.util.NoSuchElementException】

3. 在Java中，如果key不存在返回null

 

1.4.2 使用contains方法检查是否存在key

if (map4.contains("Alice")) {

    println("key 存在，值=" + map4("Alice")) 

} else {

    println("key 不存在:)”) 

}

1.4.3 使用map.get(key).get取值

通过 映射.get(键) 这样的调用返回一个 Option 对象，要么是 Some，要么是 None

 

说明和小结：

1. map.get会将数据进行包装。

2. 如果 map.get(key) key 存在返回 some,如果 key 不存在，则返回 None

3. 如果 map.get(key).get key 存在，返回 key 对应的值 , 否则，抛出异常java.util.NoSuchElementException: None.get

//1. 如果 key 存在 map.get(key) 就会返回 Some(值) ,然后 Some(值).get 就可以取出 

//2. 如果 key 不存在 map.get(key) 就会返回 None

println(map4.get("Alice").get) 

//println(map4.get("Alice~").get) // 抛出异常

1.4.4 使用 map4.getOrElse()取值

getOrElse 方法 : def getOrElse[V1 >: V](key: K, default: => V1)

 

说明；

1. 如果key存在，返回key值。

2. 如果key不存在，则返回默认值

println(map4.getOrElse("Alice~~~","默认的值 鱼 <・)))><<"))

1.4.5 如何选择取值方式

1. 如果我们确定 map 有这个 key ,则应当使用 map(key), 速度快

2. 如果我们不能确定 map 是否有 key ,而且有不同的业务逻辑，使用 map.contains() 先判断再加入逻辑

3. 如果只是简单的希望得到一个值，使用 map4.getOrElse("ip","127.0.0.1")

 

1.5对Map 修改、添加和删除

1.5.1 更新map的元素

val map5 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) ) 

map5("A") = 20 //增加

println("map5=" + map5)

小结：

1. Map是可变的，才能修改，否则报错

2. 如果key存在：则修改对应的值，key不存在，等价于添加一个key-value

 

1.5.2 添加单个元素

val map5 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )

map5 += (“D”->4)

//增加多个元素

val map6 = map5 + (“e”->2,”f”->4)

map5 +=(“e”->2,”f”->4)

//说明: 当增加一个 key-value ,如果 key 存在就是更新，如果不存在，这是添加

1.5.3 删除Map元素

map5 -= ("A","B","AAA") // 

println("map5=" + map5)

说明：

1. "A","B" 就是要删除的 key, 可以写多个.

2. 如果 key 存在，就删除，如果 key 不存在，也不会报错.

 

1.6 对Map的遍历

//map 的遍历 四种方式

val map6 = mutable.Map(("A", 1), ("B", "北京"), ("C", 3)) 

println("----(k, v) <- map6————")

//第一种

for ((k, v) <- map6) 

    println(k + " is mapped to " + v)

//第二种

println("----v <- map6.keys--------“) 

for (v <- map6.keys) 

    println(v) 

//第三种

println("----v <- map6.values--------“) 

for (v <- map6.values) 

    println(v)

//第四种

//这样取出方式 v 类型是 Tuple2

println("----v <- map6--------")

for (v <- map6) 

    println(v + " key =" + v._1 + " val=" + v._2) //v 是 Tuple?

说明：

1. 每遍历一次，返回的元素是 Tuple2。

2. 取出的时候，可以按照元组的方式来取。

 

2、Set（集）

    集是不重复元素的集合，集不保留顺序，默认是以哈希实现。

2.1 Java中set回顾

     java 中，HashSet 是实现 Set<E>接口的一个实体类，数据是以哈希表的形式存放的，里面的不能包含重复数据。Set 接口是一种不包含重复元素的 collection，HashSet 中的数据也是没有顺序的。

2.2 Scala集的介绍

默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包

2.3 set的创建

import scala.collection.mutable 

object SetDemo01 {

    def main(args: Array[String]): Unit = {

        val set = Set(1, 2, 3) //不可变 

        println(set)

        val set2 = mutable.Set(1,2,"hello") //可以变 

        println("set2" + set2)

    } 
}

2.4 set 的增删改

2.4.1 向set中添加元素 

mutableSet.add(4) //方式 1 

mutableSet += 6 //方式 2 

mutableSet.+=(5) //方式 3

2.4.2 可变集合的元素删除

val set02 = mutable.Set(1,2,4,"abc")
set02 -= 2 // 操作符形式
set02.remove("abc") // 方法的形式，scala 的 Set 可以直接删除值
println(set02)
说明:如果删除的对象不存在，则不生效，也不会报错

2.4.3 set集合的遍历操作

val set02 = mutable.Set(1, 2, 4, "abc”) 

for(x <- set02) {

    println(x)

}