Scala中的列表List

我会带着你远行 2022-11-11 05:20 195阅读 0赞

Scala 列表类似于数组，它们所有元素的类型都相同，

但是它们也有所不同：列表是不可变的，值一旦被定义了就不能改变，

其次列表 具有递归的结构（也就是链接表结构）而数组不是。

scala中的list是一个不可变的列表,有时候我们想直接添加对象不太方便,这个时候可以先转成java的List添加完再转回去.

LIst支持在头部快速添加和移除条目，但是不提供快速按下标访问的功能，这个功能需要线性遍历列。

快速的头部添加和移除意味着模式匹配很顺畅

如果我们想要往一个list里面存一个object,因为list不像java的list,可以直接add进行.这个时候我们需要用LIstBuffer.

LIstBuffer是一个可变的.

List提供头部快速访问，对尾部访问则没那么高效。List追加元素，通常考虑反过来，追加元素，再调用reverset

另一个可选方案，使用ListBuffer，提供了常量时间的往后追加和往前追加的操作，最后调用toList获取List。

具体的代码如下:

val list = ListBuffer\[ItemView\]().asJava  
    list.add()  
   
    //添加完成后,如果想要转回scala的list,直接asScala就行了  
   
    list.asScala

# 1.定义： #

两种方法  1. List()  构造

2. 使用  ::  Nil  构造

eg：

var list1 = List(1,2,3)
    
    list1.foreach(x => println(x))
    
    println(list1(0),list1(2))
    
    println("------change ele-----------")
    
    //list1(0) = 9999 //error : value update is not a member of List[Int]
    
    println(list1(0))

输出：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70][]

PS：如果在list中 存储不同类型 数据，list类型将变为Any

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70 1][]

# 2.列表拼接 #

两种方法   :::  和 List.concat()

eg:

var list1 = List(1)
    var list2 =List(2)
    
    //method 1
    var list3 = list1:::list2
    
    //method 2
    var list4 = List.concat(list1, list2)
    list3.foreach(x => println(x))
    list4.foreach(x => println("list4: "+x))

输出：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70 2][]

# 3.list常用方法 #

ListBuffer 的常用操作

### **map\[B\](f: (A) => B): List\[B\]** ###

通过给定的方法将所有元素重新计算

eg:

val lb = new ListBuffer[String]
    lb.append("张三","李四","王五","赵四"," ","张三")
    var list2 = lb.map(x => x.trim+"2333")
    
    list2.foreach(x => println(x))

输出：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70 3][]

### **max: A** ###

查找最大元素

### **min: A** ###

查找最小元素

eg:

var lb = new ListBuffer[Int]
    lb.append(1,2,3,4,5)
    var x = lb.max
    println(x)
    
    println("----------------")
    var n = lb.min
    println(n)

### **reverse: List\[A\]** ###

列表反转

### sorted排序 ###

<table> 
 <tbody> 
 <tr> 
 <td> def sorted[B &gt;: A]: List[A] 列表排序 &nbsp; 详细版：<a href="https://blog.csdn.net/hzp666/article/details/115086159" rel="nofollow">https://blog.csdn.net/hzp666/article/details/115086159</a> </td> 
 </tr> 
 </tbody> 
</table>

3.1增：

append()

var lb = new ListBuffer[Int]
        lb.append(1)
        lb.append(2,3,4)
    
      lb.foreach(x => println(x))
    
    输出：
    1
    2
    3
    4
    
    3.2删

<table> 
 <tbody> 
 <tr> 
 <td> drop(n: Int): List[A] 丢弃前n个元素，并返回新列表 </td> 
 </tr> 
 </tbody> 
</table>

eg:

var lb = new ListBuffer[Int]
    lb.append(1,2,3,4)
    var listTem = new ListBuffer[Int]
    listTem = lb.drop(2)  //d
    listTem.foreach(x => println(x))

输出：

![20210322135552120.png][]

**dropRight(n: Int): List\[A\]**

丢弃最后n个元素，并返回新列表

eg:
    var lb = new ListBuffer[Int]
    lb.append(1,2,3,4)
    var listTem = new ListBuffer[Int]
    listTem = lb.dropRight(2)
    listTem.foreach(x => println(x))

输出：

![20210322141317309.png][]

**dropWhile(p: (A) => Boolean): List\[A\]**

从左向右丢弃元素，直到条件p不成立

var lb = new ListBuffer[Int]
 lb.append(1,2,3,4,5)
 
 var lbTemp = new ListBuffer[Int]
 var len = lb.length
 lbTemp = lb.dropWhile(len => len<3 )
 lbTemp.foreach(x => println(x))

输出：

![20210322144540177.png][]

**exists(p: (A) => Boolean): Boolean**

判断列表中指定条件的元素是否存在。

判断l是否存在某个元素:

eg:

val listString = new ListBuffer[String]
    listString.append("张三","李四","麻子","赵四"," ")
    var flag:Boolean = listString.exists(x => x.equals("zhangsan"))
    val flag2 = listString.exists(x => x.equals("赵四"))
    
    println("flag :"+flag)
    println("flag2 :"+flag2)

输出：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70 4][]

**forall(p: (A) => Boolean): Boolean**

检测所有元素。

例如：判断所有元素是否以"H"开头：

scala> l.forall(s => s.startsWith("H")) res10: Boolean = false

3.3

3.4查询

根据下标查询：

var lb = new ListBuffer[Int]
    lb.append(1)
    lb.append(2,3,4)
    println(lb.apply(1))

输出：

**indexOf(elem: A, from: Int): Int**

从指定位置 from 开始查找元素第一次出现的位置

找不到 返回  -1

eg:

val lb = new ListBuffer[String]
    lb.append("张三","李四","王五","赵四"," ")
    
    var index1 = lb.indexOf("张三")
    println(index1)
    println("------------------")
    var index2 = lb.indexOf("张三1")
    println(index2)

输出：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70 5][]

**lastIndexOf(elem: A, end: Int): Int**

在指定的位置 end 开始查找元素最后出现的位置

eg:
    
      val lb = new ListBuffer[String]
      lb.append("张三","李四","王五","赵四"," ","张三")
    var index = lb.lastIndexOf("张三")
    println(index)

输出：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70 6][]

**length: Int**

返回列表长度

<table> 
 <tbody> 
 <tr> 
 <th>序号</th> 
 <th>方法及描述</th> 
 </tr> 
 <tr> 
 <td>1</td> 
 <td> def +:(elem: A): List[A] 为列表预添加元素 <pre><code>scala&gt; val x = List(1)
x: List[Int] = List(1)

scala&gt; val y = 2 +: x
y: List[Int] = List(2, 1)

scala&gt; println(x)
List(1)</code></pre> </td> 
 </tr> 
 <tr> 
 <td>2</td> 
 <td> def ::(x: A): List[A] 在列表开头添加元素 </td> 
 </tr> 
 <tr> 
 <td>3</td> 
 <td> def :::(prefix: List[A]): List[A] 在列表开头添加指定列表的元素 </td> 
 </tr> 
 <tr> 
 <td>4</td> 
 <td> def :+(elem: A): List[A] 复制添加元素后列表。 <pre><code>scala&gt; val a = List(1)
a: List[Int] = List(1)

scala&gt; val b = a :+ 2
b: List[Int] = List(1, 2)

scala&gt; println(a)
List(1)</code></pre> </td> 
 </tr> 
 <tr> 
 <td>5</td> 
 <td> def addString(b: StringBuilder): StringBuilder 将列表的所有元素添加到 StringBuilder </td> 
 </tr> 
 <tr> 
 <td>6</td> 
 <td> def addString(b: StringBuilder, sep: String): StringBuilder 将列表的所有元素添加到 StringBuilder，并指定分隔符 </td> 
 </tr> 
 <tr> 
 <td>7</td> 
 <td> def apply(n: Int): A 通过列表索引获取元素 </td> 
 </tr> 
 <tr> 
 <td>8</td> 
 <td> def contains(elem: Any): Boolean 检测列表中是否包含指定的元素 </td> 
 </tr> 
 <tr> 
 <td>9</td> 
 <td> def copyToArray(xs: Array[A], start: Int, len: Int): Unit 将列表的元素复制到数组中。 </td> 
 </tr> 
 <tr> 
 <td>10</td> 
 <td> def distinct: List[A] 去除列表的重复元素，并返回新列表 </td> 
 </tr> 
 <tr> 
 <td>11</td> 
 <td> def drop(n: Int): List[A] 丢弃前n个元素，并返回新列表 </td> 
 </tr> 
 <tr> 
 <td>12</td> 
 <td> def dropRight(n: Int): List[A] 丢弃最后n个元素，并返回新列表 </td> 
 </tr> 
 <tr> 
 <td>13</td> 
 <td> def dropWhile(p: (A) =&gt; Boolean): List[A] 从左向右丢弃元素，直到条件p不成立 </td> 
 </tr> 
 <tr> 
 <td>14</td> 
 <td> def endsWith[B](that: Seq[B]): Boolean 检测列表是否以指定序列结尾 </td> 
 </tr> 
 <tr> 
 <td>15</td> 
 <td> def equals(that: Any): Boolean 判断是否相等 </td> 
 </tr> 
 <tr> 
 <td>16</td> 
 <td> def exists(p: (A) =&gt; Boolean): Boolean 判断列表中指定条件的元素是否存在。 判断l是否存在某个元素: <pre><code>scala&gt; l.exists(s =&gt; s == "Hah")
res7: Boolean = true</code></pre> </td> 
 </tr> 
 <tr> 
 <td>17</td> 
 <td> def filter(p: (A) =&gt; Boolean): List[A] 输出符号指定条件的所有元素。 过滤出长度为3的元素: <pre><code>scala&gt; l.filter(s =&gt; s.length == 3)
res8: List[String] = List(Hah, WOW)</code></pre> </td> 
 </tr> 
 <tr> 
 <td>18</td> 
 <td> def forall(p: (A) =&gt; Boolean): Boolean 检测所有元素。 例如：判断所有元素是否以"H"开头： scala&gt; l.forall(s =&gt; s.startsWith("H")) res10: Boolean = false</td> 
 </tr> 
 <tr> 
 <td>19</td> 
 <td> def foreach(f: (A) =&gt; Unit): Unit 将函数应用到列表的所有元素 </td> 
 </tr> 
 <tr> 
 <td>20</td> 
 <td> def head: A 获取列表的第一个元素 </td> 
 </tr> 
 <tr> 
 <td>21</td> 
 <td> def indexOf(elem: A, from: Int): Int 从指定位置 from 开始查找元素第一次出现的位置 </td> 
 </tr> 
 <tr> 
 <td>22</td> 
 <td> def init: List[A] 返回所有元素，除了最后一个 </td> 
 </tr> 
 <tr> 
 <td>23</td> 
 <td> def intersect(that: Seq[A]): List[A] 计算多个集合的交集 </td> 
 </tr> 
 <tr> 
 <td>24</td> 
 <td> def isEmpty: Boolean 检测列表是否为空 </td> 
 </tr> 
 <tr> 
 <td>25</td> 
 <td> def iterator: Iterator[A] 创建一个新的迭代器来迭代元素 </td> 
 </tr> 
 <tr> 
 <td>26</td> 
 <td> def last: A 返回最后一个元素 </td> 
 </tr> 
 <tr> 
 <td>27</td> 
 <td> def lastIndexOf(elem: A, end: Int): Int 在指定的位置 end 开始查找元素最后出现的位置 </td> 
 </tr> 
 <tr> 
 <td>28</td> 
 <td> def length: Int 返回列表长度 </td> 
 </tr> 
 <tr> 
 <td>29</td> 
 <td> def map[B](f: (A) =&gt; B): List[B] 通过给定的方法将所有元素重新计算 </td> 
 </tr> 
 <tr> 
 <td>30</td> 
 <td> def max: A 查找最大元素 </td> 
 </tr> 
 <tr> 
 <td>31</td> 
 <td> def min: A 查找最小元素 </td> 
 </tr> 
 <tr> 
 <td>32</td> 
 <td> def mkString: String 列表所有元素作为字符串显示 </td> 
 </tr> 
 <tr> 
 <td>33</td> 
 <td> def mkString(sep: String): String 使用分隔符将列表所有元素作为字符串显示 </td> 
 </tr> 
 <tr> 
 <td>34</td> 
 <td> def reverse: List[A] 列表反转 </td> 
 </tr> 
 <tr> 
 <td>35</td> 
 <td> def sorted[B &gt;: A]: List[A] 列表排序 &nbsp; 详细版：<a href="https://blog.csdn.net/hzp666/article/details/115086159" rel="nofollow">https://blog.csdn.net/hzp666/article/details/115086159</a> </td> 
 </tr> 
 <tr> 
 <td>36</td> 
 <td> def startsWith[B](that: Seq[B], offset: Int): Boolean 检测列表在指定位置是否包含指定序列 </td> 
 </tr> 
 <tr> 
 <td>37</td> 
 <td> def sum: A 计算集合元素之和 </td> 
 </tr> 
 <tr> 
 <td>38</td> 
 <td> def tail: List[A] 返回所有元素，除了第一个 </td> 
 </tr> 
 <tr> 
 <td>39</td> 
 <td> def take(n: Int): List[A] 提取列表的前n个元素 </td> 
 </tr> 
 <tr> 
 <td>40</td> 
 <td> def takeRight(n: Int): List[A] 提取列表的后n个元素 </td> 
 </tr> 
 <tr> 
 <td>41</td> 
 <td> def toArray: Array[A] 列表转换为数组 </td> 
 </tr> 
 <tr> 
 <td>42</td> 
 <td> def toBuffer[B &gt;: A]: Buffer[B] 返回缓冲区，包含了列表的所有元素 </td> 
 </tr> 
 <tr> 
 <td>43</td> 
 <td> def toMap[T, U]: Map[T, U] List 转换为 Map </td> 
 </tr> 
 <tr> 
 <td>44</td> 
 <td> def toSeq: Seq[A] List 转换为 Seq </td> 
 </tr> 
 <tr> 
 <td>45</td> 
 <td> def toSet[B &gt;: A]: Set[B] List 转换为 Set </td> 
 </tr> 
 <tr> 
 <td>46</td> 
 <td> def toString(): String 列表转换为字符串 </td> 
 </tr> 
 </tbody> 
</table>

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70]: /images/20221022/7b68b6e8621348f1ad414a2e8e01222f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70 1]: /images/20221022/779ddf9df8534969a339f5ff209f77e1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70 2]: /images/20221022/6a95c2ef15de46929ee53916f7e15ee9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70 3]: /images/20221022/05ea1f73656848feba4e34e1cfa5887a.png
[20210322135552120.png]: /images/20221022/8e194a77443a4047944a5646e3263489.png
[20210322141317309.png]: /images/20221022/32cad92a4c3e43e1876eb8f916783dc1.png
[20210322144540177.png]: /images/20221022/aec33601d5174f8f99dfecae164f352d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70 4]: /images/20221022/519cf2010a95448aac69fce501e87cf3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70 5]: /images/20221022/ac186f22b79f48a39681907e042caf56.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70 6]: /images/20221022/86ba1619ec8948bcb55bc2b1fdd7639f.png