Scala：集合类型Collection和迭代器

Love The Way You Lie 2022-07-15 13:11 230阅读 0赞

http://[blog.csdn.net/pipisorry/article/details/52902549][blog.csdn.net_pipisorry_article_details_52902549]

# Scala Collection #

Scala 集合分为可变的和不可变的集合。

可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。

而不可变集合类，相比之下，永远不会改变。不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。

## 集合类型的应用 ##

1     Scala List(列表)  
List的特征是其元素以线性方式存储，集合中可以存放重复对象。  
2     Scala Set(集合)  
Set是最简单的一种集合。集合中的对象不按特定的方式排序，并且没有重复对象。  
3     Scala Map(映射)  
Map 是一种把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象。  
4     Scala 元组  
元组是不同类型的值的集合  
5     Scala Option  
Option\[T\] 表示有可能包含值的容器，也可能不包含值。  
6     Scala Iterator（迭代器）  
迭代器不是一个容器，更确切的说是逐一访问容器内元素的方法。

## 实例 ##

以下代码判断，演示了所有以上集合类型的定义实例：

// 定义整型 List
    val x = List(1,2,3,4)
    
    // 定义 Set
    var x = Set(1,3,5,7)
    
    // 定义 Map
    val x = Map("one" -> 1, "two" -> 2, "three" -> 3)
    
    // 创建两个不同类型元素的元组
    val x = (10, "Runoob")
    
    // 定义 Option
    val x:Option[Int] = Some(5)

[皮皮blog][blog]

# Scala Iterator（迭代器） #

Scala Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法。

迭代器 it 的两个基本操作是 **next** 和 **hasNext**。

调用 **it.next()** 会返回迭代器的下一个元素，并且更新迭代器的状态。

调用 **it.hasNext()** 用于检测集合中是否还有元素。

让迭代器 it 逐个返回所有元素最简单的方法是使用 while 循环：

object Test {
       
       def main(args: Array[String]) {
       
          val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
          
          while (it.hasNext){
       
             println(it.next())
          }
       }
    }

## Scala Iterator 常用方法 ##

<table> 
 <tbody> 
 <tr> 
 <th style="width:5%">序号</th> 
 <th style="width:95%">方法及描述</th> 
 </tr> 
 <tr> 
 <td>1</td> 
 <td>def hasNext: Boolean如果还有可返回的元素，返回true。</td> 
 </tr> 
 <tr> 
 <td>2</td> 
 <td>def next(): A返回迭代器的下一个元素，并且更新迭代器的状态</td> 
 </tr> 
 <tr> 
 <td>3</td> 
 <td>def ++(that: =&gt; Iterator[A]): Iterator[A]合并两个迭代器</td> 
 </tr> 
 <tr> 
 <td>4</td> 
 <td>def ++[B &gt;: A](that :=&gt; GenTraversableOnce[B]): Iterator[B]合并两个迭代器</td> 
 </tr> 
 <tr> 
 <td>5</td> 
 <td>def addString(b: StringBuilder): StringBuilder添加一个字符串到 StringBuilder b</td> 
 </tr> 
 <tr> 
 <td>6</td> 
 <td>def addString(b: StringBuilder, sep: String): StringBuilder添加一个字符串到 StringBuilder b，并指定分隔符</td> 
 </tr> 
 <tr> 
 <td>7</td> 
 <td>def buffered: BufferedIterator[A]迭代器都转换成 BufferedIterator</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 count(p: (A) =&gt; Boolean): Int返回迭代器元素中满足条件p的元素总数。</td> 
 </tr> 
 <tr> 
 <td>11</td> 
 <td>def drop(n: Int): Iterator[A]返回丢弃前n个元素新集合</td> 
 </tr> 
 <tr> 
 <td>12</td> 
 <td>def dropWhile(p: (A) =&gt; Boolean): Iterator[A]从左向右丢弃元素，直到条件p不成立</td> 
 </tr> 
 <tr> 
 <td>13</td> 
 <td>def duplicate: (Iterator[A], Iterator[A])生成两个能分别返回迭代器所有元素的迭代器。</td> 
 </tr> 
 <tr> 
 <td>14</td> 
 <td>def exists(p: (A) =&gt; Boolean): Boolean返回一个布尔值，指明迭代器元素中是否存在满足p的元素。</td> 
 </tr> 
 <tr> 
 <td>15</td> 
 <td>def filter(p: (A) =&gt; Boolean): Iterator[A]返回一个新迭代器 ，指向迭代器元素中所有满足条件p的元素。</td> 
 </tr> 
 <tr> 
 <td>16</td> 
 <td>def filterNot(p: (A) =&gt; Boolean): Iterator[A]返回一个迭代器，指向迭代器元素中不满足条件p的元素。 </td> 
 </tr> 
 <tr> 
 <td>17</td> 
 <td>def find(p: (A) =&gt; Boolean): Option[A]返回第一个满足p的元素或None。注意：如果找到满足条件的元素，迭代器会被置于该元素之后；如果没有找到，会被置于终点。</td> 
 </tr> 
 <tr> 
 <td>18</td> 
 <td>def flatMap[B](f: (A) =&gt; GenTraversableOnce[B]): Iterator[B]针对迭代器的序列中的每个元素应用函数f，并返回指向结果序列的迭代器。 </td> 
 </tr> 
 <tr> 
 <td>19</td> 
 <td>def forall(p: (A) =&gt; Boolean): Boolean返回一个布尔值，指明 it 所指元素是否都满足p。</td> 
 </tr> 
 <tr> 
 <td>20</td> 
 <td>def foreach(f: (A) =&gt; Unit): Unit在迭代器返回的每个元素上执行指定的程序 f</td> 
 </tr> 
 <tr> 
 <td>21</td> 
 <td>def hasDefiniteSize: Boolean如果迭代器的元素个数有限则返回true（缺省等同于isEmpty） </td> 
 </tr> 
 <tr> 
 <td>22</td> 
 <td>def indexOf(elem: B): Int返回迭代器的元素中index等于x的第一个元素。注意：迭代器会越过这个元素。</td> 
 </tr> 
 <tr> 
 <td>23</td> 
 <td>def indexWhere(p: (A) =&gt; Boolean): Int返回迭代器的元素中下标满足条件p的元素。注意：迭代器会越过这个元素。</td> 
 </tr> 
 <tr> 
 <td>24</td> 
 <td>def isEmpty: Boolean检查it是否为空, 为空返回 true，否则返回false（与hasNext相反）。</td> 
 </tr> 
 <tr> 
 <td>25</td> 
 <td>def isTraversableAgain: BooleanTests whether this Iterator can be repeatedly traversed.</td> 
 </tr> 
 <tr> 
 <td>26</td> 
 <td>def length: Int返回迭代器元素的数量。</td> 
 </tr> 
 <tr> 
 <td>27</td> 
 <td>def map[B](f: (A) =&gt; B): Iterator[B]将 it 中的每个元素传入函数 f 后的结果生成新的迭代器。</td> 
 </tr> 
 <tr> 
 <td>28</td> 
 <td>def max: A返回迭代器迭代器元素中最大的元素。</td> 
 </tr> 
 <tr> 
 <td>29</td> 
 <td>def min: A返回迭代器迭代器元素中最小的元素。</td> 
 </tr> 
 <tr> 
 <td>30</td> 
 <td>def mkString: String将迭代器所有元素转换成字符串。</td> 
 </tr> 
 <tr> 
 <td>31</td> 
 <td>def mkString(sep: String): String将迭代器所有元素转换成字符串，并指定分隔符。 </td> 
 </tr> 
 <tr> 
 <td>32</td> 
 <td>def nonEmpty: Boolean检查容器中是否包含元素（相当于 hasNext）。</td> 
 </tr> 
 <tr> 
 <td>33</td> 
 <td>def padTo(len: Int, elem: A): Iterator[A]首先返回迭代器所有元素，追加拷贝 elem 直到长度达到 len。</td> 
 </tr> 
 <tr> 
 <td>34</td> 
 <td>def patch(from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B]返回一个新迭代器，其中自第 from 个元素开始的 replaced 个元素被迭代器所指元素替换。</td> 
 </tr> 
 <tr> 
 <td>35</td> 
 <td>def product: A返回迭代器所指数值型元素的积。</td> 
 </tr> 
 <tr> 
 <td>36</td> 
 <td>def sameElements(that: Iterator[_]): Boolean判断迭代器和指定的迭代器参数是否依次返回相同元素</td> 
 </tr> 
 <tr> 
 <td>37</td> 
 <td>def seq: Iterator[A]返回集合的系列视图</td> 
 </tr> 
 <tr> 
 <td>38</td> 
 <td>def size: Int返回迭代器的元素数量</td> 
 </tr> 
 <tr> 
 <td>39</td> 
 <td>def slice(from: Int, until: Int): Iterator[A]返回一个新的迭代器，指向迭代器所指向的序列中从开始于第 from 个元素、结束于第 until 个元素的片段。</td> 
 </tr> 
 <tr> 
 <td>40</td> 
 <td>def sum: A返回迭代器所指数值型元素的和</td> 
 </tr> 
 <tr> 
 <td>41</td> 
 <td>def take(n: Int): Iterator[A]返回前 n 个元素的新迭代器。</td> 
 </tr> 
 <tr> 
 <td>42</td> 
 <td>def toArray: Array[A]将迭代器指向的所有元素归入数组并返回。</td> 
 </tr> 
 <tr> 
 <td>43</td> 
 <td>def toBuffer: Buffer[B]将迭代器指向的所有元素拷贝至缓冲区 Buffer。</td> 
 </tr> 
 <tr> 
 <td>44</td> 
 <td>def toIterable: Iterable[A]Returns an Iterable containing all elements of this traversable or iterator. This will not terminate for infinite iterators.</td> 
 </tr> 
 <tr> 
 <td>45</td> 
 <td>def toIterator: Iterator[A]把迭代器的所有元素归入一个Iterator容器并返回。</td> 
 </tr> 
 <tr> 
 <td>46</td> 
 <td>def toList: List[A]把迭代器的所有元素归入列表并返回</td> 
 </tr> 
 <tr> 
 <td>47</td> 
 <td>def toMap[T, U]: Map[T, U]将迭代器的所有键值对归入一个Map并返回。</td> 
 </tr> 
 <tr> 
 <td>48</td> 
 <td>def toSeq: Seq[A]将代器的所有元素归入一个Seq容器并返回。</td> 
 </tr> 
 <tr> 
 <td>49</td> 
 <td>def toString(): String将迭代器转换为字符串</td> 
 </tr> 
 <tr> 
 <td>50</td> 
 <td>def zip[B](that: Iterator[B]): Iterator[(A, B)返回一个新迭代器，指向分别由迭代器和指定的迭代器 that 元素一一对应而成的二元组序列</td> 
 </tr> 
 </tbody> 
</table>

from: [http://blog.csdn.net/pipisorry/article/details/52902549][blog.csdn.net_pipisorry_article_details_52902549]

ref:

[blog.csdn.net_pipisorry_article_details_52902549]: http://blog.csdn.net/pipisorry/article/details/52902549
[blog]: http://blog.csdn.net/pipisorry