Scala006--Scala中的数据结构【集合】之列表

之前我们已经认识了Scala中的数组类型的数据，接下来我们去认识与之类似的列表数据，列表数组类型与数组类型相比没啥区别，都是可以存放对象的数据结构类型。也有可变列表和不可变列表之分。值得注意是：①列表中的数据不可变，而数组可以改变元素；②数组和列表之间可以相互转换。

目录

一，列表的声明和定义

二，不可变列表

1，定义声明

三，可变列表

1，声明和定义

动态声明的列表：

 静态声明的列表：

 2，只能可变列表使用的常用函数

1），插入元素[元组]                 insert（index，element）

2），删除元素【多个元素】      remove（index）/(index,count）

3），追加元素【多个元素】      append（x1,x2...）

4），（需要新的列表来接收）在列表前面添加元组                     +：（x）/(x1,x2...)

5），（需要新的列表来接收）在列表后面添加元素【元组】       :+(x)/(x1,x2...)

6），在列表后面添加元素【多个元素】   +=x/(x1,x2...)

7），删除列表中的元素【多个元素】     -=x/(x1,x2...)

8），同类序列进行拼接                           ++=

9），同类序列进行相减                           --=

四，列表中常用的函数[在数组中也通用]

1，在列表前面添加元素 （元组的形式） +:

2，在列表后面添加元素（以元组的形式）  :+

 3，两个列表相互拼接 ++

4,列表排序sorted

五，数组与列表之间的相互转换

1，由可变列表转换成不可变列表：toList

2，由不可变列表转换成可变列表：toBuffer

3，将列表转换成数组：toArray

4，由数组转换成列表：toList

---

一，列表的声明和定义

列表的声明和定义没有动态和静态之分，它只能够使用List进行创建。

二，不可变列表

1，定义声明

格式为：var/val  变量名=List(element1,element2,element3.....)

scala>  var list_imutable=List[Int](1,2,3)  // 静态声明一个不可变列表

 相信学过数组的还有这么一个影响，那就是即使数组是个不可变数组但是它的元素值确实可变的，但是对于列表来说，它就真的是完完全全不可变，元素不可变，长度也不可变。

如下，我们修改它的元素值，则会显示错误，不允许更改：

 但是对于不可变数组来说，它的元素值可以修改：

三，可变列表

1，声明和定义

可变列表和可变数组一样都需要导入相应的包才能够声明和定义：

import scala.collection.mutable.ListBufferr

动态声明的列表：

 静态声明的列表：

scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer
 
scala> val list_m001=ListBuffer(7,3,2,1,8,9)
list_m001: scala.collection.mutable.ListBuffer[Int] = ListBuffer(7, 3, 2, 1, 8, 9)

 2，只能可变列表使用的常用函数

我们多次提到，列表和数组的操作基本上一致，因此，只要是可变数组中有的函数，在可变列表中依旧通用。如：在集合中的指定索引位置插入insert元素，删除，追加等操作。

1），插入元素[元组]                 insert（index，element）

insert函数可以在序列的指定索引位置进行添加元素，如下在该列表的第一位插入100： 

2），删除元素【多个元素】      remove（index）/(index,count）

remove函数可以删除一个元素，也可以删除多个元素。

删除单个元素，如下删除列表中索引位置为2的元素：【需要传入的参数为索引】

 删除多个元素：remove (index,count）

index表示开始删除的元素的索引下标

count表示需要删除多少个元素

现在list_m001列表元素如下：

 使用remove函数从索引3开始删除3个元素，如下：

3），追加元素【多个元素】      append（x1,x2...）

追加单个元素：

追加多个元素：

4），（需要新的列表来接收）在列表前面添加元组                     +：（x）/(x1,x2...)

scala> list_m001
res15: scala.collection.mutable.ListBuffer[Int] = ListBuffer(100, 7, 9, 1, 4, 5, 5, 777)
 
scala> list_m001.+:(1,2)
res16: scala.collection.mutable.ListBuffer[Any] = ListBuffer((1,2), 100, 7, 9, 1, 4, 5, 5, 777)

 如上，我们可以看到，加进去的元组并没有真正的添加进去列表中，如果要使用添加后的结果，则需要去使用一个新的列表变量来接收新生成的列表。

5），（需要新的列表来接收）在列表后面添加元素【元组】       :+(x)/(x1,x2...)

添加单个元素：

添加多个元素：

6），在列表后面添加元素【多个元素】   +=x/(x1,x2...)

添加单个元素：

scala> list_m001
res25: scala.collection.mutable.ListBuffer[Int] = ListBuffer(100, 7, 9, 1, 4, 5, 5, 777)
 
scala> list_m001 +=2
res26: list_m001.type = ListBuffer(100, 7, 9, 1, 4, 5, 5, 777, 2)
 
scala> list_m001
res27: scala.collection.mutable.ListBuffer[Int] = ListBuffer(100, 7, 9, 1, 4, 5, 5, 777, 2)

 添加多个元素：

7），删除列表中的元素【多个元素】     -=x/(x1,x2...)

删除单个元素：

scala> list_m001
res29: scala.collection.mutable.ListBuffer[Int] = ListBuffer(100, 7, 9, 1, 4, 5, 5, 777, 2, 99, 100, 101)
 
scala> list_m001 -=100
res30: list_m001.type = ListBuffer(7, 9, 1, 4, 5, 5, 777, 2, 99, 100, 101)
 
scala> list_m001
res31: scala.collection.mutable.ListBuffer[Int] = ListBuffer(7, 9, 1, 4, 5, 5, 777, 2, 99, 100, 101)

 删除多个元素：

scala> list_m001
res31: scala.collection.mutable.ListBuffer[Int] = ListBuffer(7, 9, 1, 4, 5, 5, 777, 2, 99, 100, 101)
 
scala> list_m001 -=(100,101,777,2,99,5,1)
res32: list_m001.type = ListBuffer(7, 9, 4, 5)
 
scala> list_m001
res33: scala.collection.mutable.ListBuffer[Int] = ListBuffer(7, 9, 4, 5)

8），同类序列进行拼接                           ++=

++=函数能够拼接上另外一个序列中元素到自己的序列中：

scala> list_m001
res33: scala.collection.mutable.ListBuffer[Int] = ListBuffer(7, 9, 4, 5)
 
scala> val list_m002=ListBuffer(1,2,3)
list_m002: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)
 
scala> list_m001  ++= list_m002
res34: list_m001.type = ListBuffer(7, 9, 4, 5, 1, 2, 3)
 
scala> list_m001
res35: scala.collection.mutable.ListBuffer[Int] = ListBuffer(7, 9, 4, 5, 1, 2, 3)

9），同类序列进行相减                           --=

 --=函数能够让当前序列减去另外一个序列中的元素：

scala> list_m001
res35: scala.collection.mutable.ListBuffer[Int] = ListBuffer(7, 9, 4, 5, 1, 2, 3)
 
scala> list_m002
res36: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)
 
scala> list_m001 --= list_m002
res37: list_m001.type = ListBuffer(7, 9, 4, 5)
 
scala> list_m001
res38: scala.collection.mutable.ListBuffer[Int] = ListBuffer(7, 9, 4, 5)

四，列表中常用的函数[在数组中也通用]

1，在列表前面添加元素 （元组的形式） +:

如下我们在 list_imutable列表的最前面添加三个元素(33,22,11)

scala> list_imutable.+:(33,22,11)

2，在列表后面添加元素（以元组的形式）  :+

list_imutable.:+(33,44)

 3，两个列表相互拼接 ++

scala> list_imutable
res8: List[Int] = List(1, 2, 3)
 
scala> list_imutable01
res9: List[Int] = List(88, 99)
 
scala> list_imutable ++ list_imutable01
res10: List[Int] = List(1, 2, 3, 88, 99)

4,列表排序sorted

列表也可以和数组那样进行排序，它们之间的区别到这里我只发现了列表的元素不能进行更改。列表的使用就和数组基本上是一样的。

五，数组与列表之间的相互转换

转换方法并不会对被转换的序列产生任何影响，可变的列表还是可变列表，如果想要使用转换后的不可变列表的话就需要使用一个新的变量来接收。

la> import scala.collection.mutable.ArrayBuffer  // 导入创建可变数组需要的包
import scala.collection.mutable.ArrayBuffer
 
scala> import scala.collection.mutable.ListBuffer  // 导入创建可变列表需要的包
import scala.collection.mutable.ListBuffer
la> val ar_im_1=new Array[Int](2)  // 创建不可变数组，长度为3
ar_im_1: Array[Int] = Array(0, 0)
 
scala> val ar_m_0=new ArrayBuffer[Int](3)   // 创建可变数组，长度为3
ar_m_0: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
scala> val li_im_0=List()     // 创建不可变列表
li_im_0: List[Nothing] = List()
 
scala> val li_m_0=ListBuffer()    // 创建可变列表
li_im_0: scala.collection.mutable.ListBuffer[Nothing] = ListBuffer()

首先我们有如下四个序列：不可变数组，可变数组，不可变列表，可变列表。

ar_im_1: Array[Int] = Array(0, 0)
 
ar_m_0: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
 
【 li_im_0】res1: List[Nothing] = List()
  
【li_m_0 】res2: scala.collection.mutable.ListBuffer[Nothing] = ListBuffer()

1，由可变列表转换成不可变列表：toList

2，由不可变列表转换成可变列表：toBuffer

3，将列表转换成数组：toArray

4，由数组转换成列表：toList

 以上就是列表及数组相关的一些内容，如果对如上内容有任何问题的请在评论区留言。