scala第十二讲：列表

蔚落 2022-06-03 09:11 275阅读 0赞

列表是任何语言中比较重要的部分，在scala中也不例外

一：List的定义

1：基本定义

List\[T\]

做好心理准备，这块跟java还是有很大的差别的

字符串列表

val strList :  List \[ String \]  =  List ( "abc" ,  "def" ,  "gh" )

整型列表

var intList: List\[Int\]=List(1,2,3,4)

空列表

val empty:List\[Nothing\]=List()

二维列表

val dim:List\[List\[Int\]\]=List(List(1,0,0),List(0,1,0),List(0,0,1))

构造列表的两个基本单位是 **Nil** 和  **::**

**Nil** 也可以表示为一个空列表

// 字符串列表  
val strList= "abc" :: ("def" :: ("gh" :: Nil))

// 整型列表  
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))

// 空列表  
val empty = Nil

// 二维列表  
val dim = (1 :: (0 :: (0 :: Nil))) ::  
          (0 :: (1 :: (0 :: Nil))) ::  
          (0 :: (0 :: (1 :: Nil))) :: Nil

2：如果想创建一个同一元素列表，有没有方法呢，答案是有的

使用fill函数

![20171225074447660][]

3：通过函数定义更好玩的列表====》tabulate

下面的例子一个是生成有规则的一维列表，第二个是生成一个二维列表

![20171225075145629][]

二：列表相关操作

1：基本操作

head：列表的第一个字符

tail：列表的第二个一直到最后一个字符

isEmpty：判断列表是否为空

![20171224235128911][]

2：列表连接

有以下几种连接方式

alist:::blist    alist.:::blist     List.concat(alist,blist)

![20171225072222108][]

其中要注意的是：a.:::b的这种模式，生成的新列表元素顺序是把a在b后面，其他两种都是b在a后面

3：列表的反转===== reverse

因为列表是有序的，所以是可以反转的

![20171225075456332][]

下面还有一些常用的方法，除了背，别无他法

<table> 
 <tbody> 
 <tr> 
 <th style="width:5%">序号</th> 
 <th style="width:95%">方法及描述</th> 
 </tr> 
 <tr> 
 <td>1</td> 
 <td> def +:(elem: A): List[A] 为列表预添加元素 <pre>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)</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>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)</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>scala&gt; l.exists(s =&gt; s == "Hah")
res7: Boolean = true</pre> </td> 
 </tr> 
 <tr> 
 <td>17</td> 
 <td> def filter(p: (A) =&gt; Boolean): List[A] 输出符号指定条件的所有元素。 过滤出长度为3的元素: <pre>scala&gt; l.filter(s =&gt; s.length == 3)
res8: List[String] = List(Hah, WOW)</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] 列表排序 </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>

[20171225074447660]: /images/20220603/80d90b69d07244c0b92fecdbfa1af86d.png
[20171225075145629]: /images/20220603/e43eeb86586148c1a006f9a132044244.png
[20171224235128911]: /images/20220603/ef142ceb020f4f2cada77e58261ec8c8.png
[20171225072222108]: /images/20220603/43a7df3a7c00446e8a4a52f4fcd267c9.png
[20171225075456332]: /images/20220603/127ac945def147ff9e0042d54ed1632d.png