Scala(三)：集合简介

﹏ヽ暗。殇╰゛Y 2022-12-01 11:41 204阅读 0赞

### 文章目录 ###

*  一、Scala集合简介
 *  二、元组
 *  三、数组
 *   *  3.1不可变数组
     *  3.2 可变数组
     *  3.3 多维数组
     *  3.4 Scala数组与Java数组的互转
 *  四、Seq
 *   *  4.1 List
     *  4.2 Queue
 *  五、Map
 *  六、Set

# 一、Scala集合简介 #

`scala`同时支持不可变集合和可变集合。不可变集合（不能动态变化）位于`scala.collection.immutable`包下；可变集合（能动态变化）位于 `scala.collection.mutable`包下。`scala`默认采用不可变集合，对于几乎所有的集合类，`scala`都同时提供了可变和不可变的版本。

`scala`的集合有三大类：序列`Seq`、集`Set`、映射`Map`，所有的集合都扩展自`Iterable`特质。

**不可变集和继承图：**  
![在这里插入图片描述][20200826163013179.png]  
**可变集和继承图：**  
![在这里插入图片描述][20200826162953958.png]

# 二、元组 #

元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组，最大的特点灵活,对数据没有过多的约束。

注意：元组中最大只能有22个元素

**元组的创建：**

val tuple = (1,2,3,"hello")
        println(tuple)//(1,2,3,hello)
        val tuple2 = 2 -> "two"
        println(tuple2)//(2,two)
        val tuple3 = 3 -> "three" -> "三"
        println(tuple3)((3,three),三)

**元组数据的访问：**

访问元组中的数据,可以采用顺序号（`_顺序号`），也可以通过索引（`productElement`）访问。

val tuple = (1,2,3,"hello")
    
        println(tuple._1)//1
        println(tuple.productElement(0))//1
    	
    	/* * 遍历 */
    	for (item <- tuple.productIterator){ 
          println(item)
        }

# 三、数组 #

## 3.1不可变数组 ##

**定义：**  
第一种：

//声明、赋值
        val arr = new Array[Int](10)
        arr(0)=10

第二种：

//通过apply方法创建Array数组并赋值
        val arr: Array[Int] = Array(1, 2, 3, 4)

常见操作：

//访问数组
        println(arr(0))
    
        //数组长度
        println(arr.length)
    
        //打印数组
        // 1、普通for循环
        for (int <- arr) { 
          println(int)
        }
        //2、foreach
        arr.foreach((int) => { 
          println(int)
        })
    	//3、foreach最简形式
        arr.foreach(println(_))	
    	
    	//修改某个位置的值
    	arr.update(2,5)

## 3.2 可变数组 ##

//通过apply()函数创建
        val arr = ArrayBuffer(1,2,3)
        //通过new创建对象
        val arr2 = new ArrayBuffer[Int](10)
        //添加元素
        arr2.append(1,2)

说明：

*  `ArrayBuffer`是变长数组，类似`Java`的`ArrayList`
 *  `def append(elems: A*) { appendAll(elems) }`接收的是可变参数
 *  每`append`一次，`arr`在底层会重新分配空间进行扩容，`arr`的内存地址会发生变化，也就成为新的`ArrayBuffer`

**定长数组与变长数组的转换：**

`val arr3 = arr1.toBuffer`：定长数组转可变数组  
`var arr4 = arr2.toArray`：可变数组转定长数组

## 3.3 多维数组 ##

/** * arr 是一个二维数组 * 有三个元素[一维数组] * 每个一维数组存放4个值 */
    val arr = Array.ofDim[Double](3,4)
    
    //赋值
    arr(1)(1) = 11.11

## 3.4 Scala数组与Java数组的互转 ##

/** * Buffer ==> java.util.List */
        val arr = ArrayBuffer("1", "2", "3")
        println(arr)// ArrayBuffer(1, 2, 3)
        import scala.collection.JavaConversions.bufferAsJavaList
        val javaArr = new ProcessBuilder(arr)
        val arrList = javaArr.command()
        println(arrList)// [1, 2, 3]
    
    
        /** * java.util.List ==> Buffer */
        import scala.collection.JavaConversions.asScalaBuffer
        import scala.collection.mutable
        val scalaArr: mutable.Buffer[String] = arrList
        println(scalaArr)// ArrayBuffer(1, 2, 3)

# 四、Seq #

## 4.1 List ##

`scala`中的`List`和`Java List`不一样，在Java中`List`是一个接口，真正存放数据是`ArrayList`，而`scala`的`List`可以直接存放数据，就是一个`object`，默认情况下`scala`的`List`是不可变的，`List`属于序列`Seq`。

**创建`List`：**

val list = List(1, 2, 3) //创建数组并初始化
        println(list)
        val list2 = Nil //创建空数组
        println(list2)

说明：

*  `List`在`scala`包对象声明的,因此不需要引入其它包也可以使用
 *  `List`中可以放任何数据类型，比如`arr1`的类型为`List[Any]`
 *  如果希望得到一个空列表，可以使用`Nil`对象

常见使用：

val list = List(1, 2, 3) //创建数组并初始化
        //查看指定元素
        println(list(0))//1
        //元素的追加
        val list3 = list.:+(4)//或简写成list:+ 4
        println(list)//List(1, 2, 3)
        println(list3)//List(1, 2, 3, 4)
    
        /** * 符号::表示向集合中 新建集合添加元素 * 运算时，集合对象一定要放置在最右边 * 运算规则，从右向左 * ::: 运算符是将集合中的每一个元素加入到空集合中去 */
        val list5 = 4 :: 5 :: 6 :: list :: Nil // 从右向左的逻辑
         println(list5)//List(4, 5, 6, List(1, 2, 3))
        val list7 = 4 :: 5 :: 6 :: list ::: Nil
        println(list7)//List(4, 5, 6, 1, 2, 3)

**ListBuffer**

`ListBuffer`是可变的`List`集合，可以添加、删除元素，`ListBuffer`属于`Seq`序列。

val listBuffer = ListBuffer(1,2,3)
        println(listBuffer)//ListBuffer(1, 2, 3)

## 4.2 Queue ##

说明：

*  队列是一个有序列表，在底层可以用数组或是链表来实现
 *  其输入和输出要遵循先入先出的原则
 *  在`scala`中， 有`scala.collection.mutable.Queue`和`scala.collection.immutable.Queue`，一般来说，我们在开发中通常使用可变集合中的队列

常用操作：

/** * 创建Queue */
        import scala.collection.mutable
        val queue = new mutable.Queue[Int]()
    	 /** * 追加 */
    // queue +=1 //Queue(1)
        queue ++=List(1,2,3)//Queue(1, 2, 3)
    	 /** * 入队出队 */       
        queue.enqueue(4)//Queue(1, 2, 3, 4)
        queue.dequeue()//Queue(2, 3, 4)‘’
    	 /** * 查看头尾信息 */
        println(queue.head)//2
        println(queue.last)//4
        println(queue.tail)//Queue(3, 4)
        println(queue.tail.tail)//Queue(4)

# 五、Map #

`scala`中的`Map`和`Java`类似，也是一个散列表，它存储的内容也是键值对(`key-value`)映射，不可变的`Map`(`scala.collection.mutable.Map`)是有序的，可变的`Map(scala.collection.immutable.Map`) 是无序的。

**构造不可变Map：**

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

val map = Map("A" -> 1, "B" -> 2, "C" -> 3)
        println(map)//Map(A -> 1, B -> 2, C -> 3)

说明：

*  从输出的结果看到，输出顺序和声明顺序一致
 *  构建Map集合中，集合中的元素其实是Tuple2类型
 *  默认情况下（即没有引入其它包的情况下）,Map是不可变map

**构造可变Map：**

val map2 = scala.collection.mutable.Map("A" -> 1, "B" -> 2, "C" -> 3)
        println(map2)//Map(A -> 1, C -> 3, B -> 2)

说明：

*  从输出的结果看到，输出顺序和声明顺序不一致

**创建空的映射：**

val map3 = new scala.collection.mutable.HashMap[String, Int]
        println(map3)//Map()

**对偶元组**

对偶元组：只含有两个数据的元组

val map4 = mutable.Map( ("A", 1), ("B", 2), ("C", 3),("D", 30) )
        println("map4=" + map4)//map4=Map(D -> 30, A -> 1, C -> 3, B -> 2)
        println(map4("A"))//1

**Map取值**

① 使用`map(key)`  
如果键存在, 返回对应的值对象；如果键不存在, 抛出异常。例：`map("A")`

② 使用`contains`方法检查是否存在`key`  
例：`map.contains("A")`

③ `map.get(key).get`取值  
通过映射`.get(键)`调用返回一个`Option`对象，要么是`Some`，要么是`None`，然后通过`get`函数返回。例：`map.get("A").get`

④ `map4.getOrElse()`取值  
键不存在时提供默认值，例：`map.getOrElse("D","defaultValue")`

**Map操作**

val map4 = mutable.Map( ("A", 1), ("B", 2), ("C", 3) )
        //修改元素
        map4("A")=4
        //增加元素
        map4 +=("D" -> 4)
        //删除元素
        map4 -=("D")
    
        /** * 多种Map遍历方式 */
        for ((k,v) <-map4){ println(k+"->"+v)}//A->4 C->3 B->2
        for (v <-map4.keys){ println(v)}//A C B
        for (v <-map4.values){ println(v)}//4 3 2
        for (v <-map4){ println(v)}//(A,4) (C,3) (B,2)

# 六、Set #

集是不重复元素的结合。集不保留顺序，默认是以哈希集实现。默认情况下，`scala`使用的是不可变集合，如果你想使用可变集合，需要引用`scala.collection.mutable.Set`包

**创建：**

val set = Set(1,2,3)
        println(set)//Set(1, 2, 3)
        
        import scala.collection.mutable
        val mutableSet = mutable.Set(1,2,3)
        println(mutableSet)//Set(1, 2, 3)

**常用操作：**

import scala.collection.mutable
        val mutableSet = mutable.Set(1, 2, 3)
    	
    	/* 添加元素 如果添加的对象已经存在，则不会重复添加，也不会报错 */
        mutableSet.add(4)
        mutableSet += 5
        mutableSet.+=(6)
        
    	/* 删除元素 */
        mutableSet.remove(4)
        mutableSet -=4
        mutableSet.-=(4)
    
    	/* 遍历元素 */
        for (i <- mutableSet){ 
          print(i+" ")
        }

[20200826163013179.png]: /images/20221123/6866ea1027ff4b699001dba62b4345b3.png
[20200826162953958.png]: /images/20221123/1c418aa4b72e4564bfb074ebd6a306a4.png