scala陣列、Scala Collection（集合）、Iterator（迭代器）

阿新 • • 發佈：2019-01-23

一、scala陣列

陣列：用來儲存固定大小的同類型元素，通過索引來訪問指定元素，索引index從0開始

宣告陣列

定義陣列--語法格式：

var z:Array[String] = new Array[String](3) 或 var z = new Array[String](3)

賦值：z(0) = "Runoob"; z(1) = "Baidu"; z(4/2) = "Google"

var z = Array("Runoob", "Baidu", "Google")

處理陣列

陣列的元素型別和陣列的大小都是確定的，所以當處理陣列元素時，通常使用基本的 for 迴圈。

eg：陣列的建立，初始化等處理過程

多維陣列

矩陣與表格是我們常見的二維陣列。

定義二維陣列的例項：var myMatrix = ofDim[Int](3,3)

說明：上述陣列中包含三個陣列元素，每個陣列元素又含有三個值。

eg：二維陣列例項：

合併陣列

使用 concat() 方法來合併兩個陣列，concat() 方法中接受多個數組引數：

建立區間陣列

使用了 range() 方法來生成一個區間範圍內的陣列。range() 方法最後一個引數為步長，預設為 1：

Scala 陣列方法

下表中為 Scala 語言中處理陣列的重要方法，使用它前需要使用 import Array._

引入包。

序號	方法和描述
1	*def apply( x: T, xs: T ): Array[T]** 建立指定物件 T 的陣列, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。
2	*def concat[T]( xss: Array[T] ): Array[T]** 合併陣列
3	def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit 複製一個數組到另一個數組上。相等於 Java's System.arraycopy(src, srcPos, dest, destPos, length)。
4	def empty[T]: Array[T] 返回長度為 0 的陣列
5	def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T] 返回指定長度陣列，每個陣列元素為指定函式的返回值。以上例項陣列初始值為 0，長度為 3，計算函式為a=>a+1： `scala> Array.iterate(0,3)(a=>a+1) res1: Array[Int] = Array(0, 1, 2)`
6	def fill[T]( n: Int )(elem: => T): Array[T] 返回陣列，長度為第一個引數指定，同時每個元素使用第二個引數進行填充。
7	def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]] 返回二陣列，長度為第一個引數指定，同時每個元素使用第二個引數進行填充。
8	def ofDim[T]( n1: Int ): Array[T] 建立指定長度的陣列
9	def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]] 建立二維陣列
10	def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]] 建立三維陣列
11	def range( start: Int, end: Int, step: Int ): Array[Int] 建立指定區間內的陣列，step 為每個元素間的步長
12	def range( start: Int, end: Int ): Array[Int] 建立指定區間內的陣列
13	def tabulate[T]( n: Int )(f: (Int)=> T): Array[T] 返回指定長度陣列，每個陣列元素為指定函式的返回值，預設從 0 開始。以上例項返回 3 個元素： `scala> Array.tabulate(3)(a => a + 5) res0: Array[Int] = Array(5, 6, 7)`
14	def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]] 返回指定長度的二維陣列，每個陣列元素為指定函式的返回值，預設從 0 開始。

二、Scala Collection

Scala提供了一套很好的集合實現，提供了一些集合型別的抽象。

Scala 集合分為可變的和不可變的集合。

可變集合可以在適當的地方被更新或擴充套件。意味著可以修改，新增，移除一個集合的元素。
而不可變集合類，相比之下，永遠不會改變。不過，你仍然可以模擬新增，移除或更新操作。但是這些操作將在每一種情況下都返回一個新的集合，同時使原來的集合不發生改變。

常用集合型別的應用：List（列表）、Set（集合）、Map（對映）、元組、Option、Iterator（迭代器）

eg：集合型別的定義例項↓

//定義整型List
 val x = List(1,2,3,4)
 //定義Set
 val y = Set(1,3,5,7)
 //定義map
 var z = Map("one"->1,"two"->2,"three"->3)
 //建立兩個不同型別元素的元組
 val a = (10,"Runnob")

 //定義option
 val b:Option[Int] = Some(5)

1、List（列表）

List的特徵是其元素以線性方式儲存，集合中可以存放重複物件。

Scala 列表類似於陣列，所有元素的型別都相同，不同在於：列表是不可變的，值一旦被定義了就不能改變，其次列表具有遞迴的結構（也就是連結表結構）而陣列不是。。

列表的元素型別 T 可以寫成 List[T]。

eg：

//字串列表
 val site:List[String] = List("Runnob","Google","Baidu")
 //整型列表
 val nums: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 site = "Runnob" :: ("Google" :: ("Baidu" :: Nil))
 //整型列表
 val nums:List[Int] = List(1,2,3,4)
 val num = 1 :: (2 :: (3 ::(4 :: Nil)))
 //空列表
 val empty = Nil
 //二維列表
 val dim =(1 :: (0 :: (0 ::Nil))) ::
          (0 :: (1 :: (0 ::Nil))) ::
          (0 :: (0 :: (1 ::Nil))) ::Nil

列表基本操作

Scala列表有三個基本操作：

head 返回列表第一個元素
tail 返回一個列表，包含除了第一元素之外的其他元素
isEmpty 在列表為空時返回true

對於Scala列表的任何操作都可以使用這三個基本操作來表達。

val site = "Runnob" :: ("Google" :: ("Baidu" :: Nil))
val nums = Nil
 println("第一網站是：" + site.head)
 println("最後一個網站是：" + site.tail)
 println("檢視列表site是否為空：" + site.isEmpty)
 println("檢視buns是否為空：" + nums.isEmpty)

執行結果：

第一網站是：Runnob
最後一個網站是：List(Google, Baidu)
檢視列表site是否為空：false
檢視buns是否為空：true

連線列表

可以使用 ::: 運算子或 List.:::() 方法或 List.concat() 方法來連線兩個或多個列表。

List.fill()

使用 List.fill() 方法來建立一個指定重複數量的元素列表：

List.tabulate()

List.tabulate() 方法是通過給定的函式來建立列表。

方法的第一個引數為元素的數量，可以是二維的，第二個引數為指定的函式
通過指定的函式計算結果並返回值插入到列表中，起始值為 0
eg：

List.reverse

List.reverse 用於將列表的順序反轉，eg：

Scala List 常用方法

序號	方法及描述
1	def +:(elem: A): List[A] 為列表預新增元素 `scala> val x = List(1) x: List[Int] = List(1) scala> val y = 2 +: x y: List[Int] = List(2, 1) scala> println(x) List(1)`
2	def ::(x: A): List[A] 在列表開頭新增元素
3	def :::(prefix: List[A]): List[A] 在列表開頭新增指定列表的元素
4	def :+(elem: A): List[A] 複製新增元素後列表。 `scala> val a = List(1) a: List[Int] = List(1) scala> val b = a :+ 2 b: List[Int] = List(1, 2) scala> println(a) List(1)`
5	def addString(b: StringBuilder): StringBuilder 將列表的所有元素新增到 StringBuilder
6	def addString(b: StringBuilder, sep: String): StringBuilder 將列表的所有元素新增到 StringBuilder，並指定分隔符
7	def apply(n: Int): A 通過列表索引獲取元素
8	def contains(elem: Any): Boolean 檢測列表中是否包含指定的元素
9	def copyToArray(xs: Array[A], start: Int, len: Int): Unit 將列表的元素複製到陣列中。
10	def distinct: List[A] 去除列表的重複元素，並返回新列表
11	def drop(n: Int): List[A] 丟棄前n個元素，並返回新列表
12	def dropRight(n: Int): List[A] 丟棄最後n個元素，並返回新列表
13	def dropWhile(p: (A) => Boolean): List[A] 從左向右丟棄元素，直到條件p不成立
14	def endsWith[B](that: Seq[B]): Boolean 檢測列表是否以指定序列結尾
15	def equals(that: Any): Boolean 判斷是否相等
16	def exists(p: (A) => Boolean): Boolean 判斷列表中指定條件的元素是否存在。判斷l是否存在某個元素: `scala> l.exists(s => s == "Hah") res7: Boolean = true`
17	def filter(p: (A) => Boolean): List[A] 輸出符號指定條件的所有元素。過濾出長度為3的元素: `scala> l.filter(s => s.length == 3) res8: List[String] = List(Hah, WOW)`
18	def forall(p: (A) => Boolean): Boolean 檢測所有元素。例如：判斷所有元素是否以"H"開頭： scala> l.forall(s => s.startsWith("H")) res10: Boolean = false
19	def foreach(f: (A) => Unit): Unit 將函式應用到列表的所有元素
20	def head: A 獲取列表的第一個元素
21	def indexOf(elem: A, from: Int): Int 從指定位置 from 開始查詢元素第一次出現的位置
22	def init: List[A] 返回所有元素，除了最後一個
23	def intersect(that: Seq[A]): List[A] 計算多個集合的交集
24	def isEmpty: Boolean 檢測列表是否為空
25	def iterator: Iterator[A] 建立一個新的迭代器來迭代元素
26	def last: A 返回最後一個元素
27	def lastIndexOf(elem: A, end: Int): Int 在指定的位置 end 開始查詢元素最後出現的位置
28	def length: Int 返回列表長度
29	def map[B](f: (A) => B): List[B] 通過給定的方法將所有元素重新計算
30	def max: A 查詢最大元素
31	def min: A 查詢最小元素
32	def mkString: String 列表所有元素作為字串顯示
33	def mkString(sep: String): String 使用分隔符將列表所有元素作為字串顯示
34	def reverse: List[A] 列表反轉
35	def sorted[B >: A]: List[A] 列表排序
36	def startsWith[B](that: Seq[B], offset: Int): Boolean 檢測列表在指定位置是否包含指定序列
37	def sum: A 計算集合元素之和
38	def tail: List[A] 返回所有元素，除了第一個
39	def take(n: Int): List[A] 提取列表的前n個元素
40	def takeRight(n: Int): List[A] 提取列表的後n個元素
41	def toArray: Array[A] 列表轉換為陣列
42	def toBuffer[B >: A]: Buffer[B] 返回緩衝區，包含了列表的所有元素
43	def toMap[T, U]: Map[T, U] List 轉換為 Map
44	def toSeq: Seq[A] List 轉換為 Seq
45	def toSet[B >: A]: Set[B] List 轉換為 Set
46	def toString(): String 列表轉換為字串

2、Set（集合）

Set是最簡單的一種集合。集合中的物件不按特定的方式排序，並且沒有重複物件。

Scala Set(集合)是沒有重複的物件集合，所有的元素都是唯一的。

Scala 集合分為可變的和不可變的集合。

預設情況下，Scala 使用的是不可變集合，若想使用可變集合，需要引用 scala.collection.mutable.Set 包。
預設引用 scala.collection.immutable.Set
eg:

若需要使用可變集合需要引入 scala.collection.mutable.Set：

eg：

注意： 雖然可變Set和不可變Set都有新增或刪除元素的操作，但是有一個非常大的差別。

對不可變Set進行操作，會產生一個新的set，原來的set並沒有改變，這與List一樣。
而對可變Set進行操作，改變的是該Set本身，與ListBuffer類似。

集合基本操作

Scala集合有三個基本操作：

對於Scala集合的任何操作都可以使用這三個基本操作來表達。例項如下:

eg：

head 返回集合第一個元素
tail 返回一個集合，包含除了第一元素之外的其他元素
isEmpty 在集合為空時返回true

連線集合

可以使用 ++ 運算子或 Set.++() 方法來連線兩個集合。如果元素有重複的就會移除重複的元素。

eg：

object Test {
  def main(args: Array[String]){
    val site1 =Set("Runnob","Google","Baidu")
    val site2 = Set("Facebook","Taobao")

    //++作為運算子使用
    var site = site1 ++ site2
    println(site)      //Set(Google, Baidu, Taobao, Facebook, Runnob)

    //使用++作為方法使用
    site = site1.++(site2)
    println(site)     //Set(Google, Baidu, Taobao, Facebook, Runnob)
  }
}

查詢集合中最大與最小元素

使用 Set.min 方法來查詢集合中的最小元素，使用 Set.max 方法查詢集合中的最大元素。

eg：

object Test {
  def main(args: Array[String]){
    val num = Set(4,7,9,25,7,13,75)
    //查詢集合中的最值元素
    println("max:" + num.max)     //max:75
    println("min:" + num.min)     //min:4
  }
}

交集

可以使用 Set.& 方法或 Set.intersect 方法來檢視兩個集合的交集元素。

object Test {
  def main(args: Array[String]){
    val num1 = Set(4,7,9,25,7,13,75)
    val num2 = Set(7,25,45,13,54,6,3)

    //交集
    println("Set.&:" + num1.&(num2))       //Set.&:Set(13, 7, 25)
    println("Set.intersect:" + num1.intersect(num2))     //Set.intersect:Set(13, 7, 25)
  }
}

Scala Set 常用方法

下表列出了 Scala Set 常用的方法：

序號	方法及描述
1	def +(elem: A): Set[A] 為集合新增新元素，x並建立一個新的集合，除非元素已存在
2	def -(elem: A): Set[A] 移除集合中的元素，並建立一個新的集合
3	def contains(elem: A): Boolean 如果元素在集合中存在，返回 true，否則返回 false。
4	def &(that: Set[A]): Set[A] 返回兩個集合的交集
5	def &~(that: Set[A]): Set[A] 返回兩個集合的差集
6	*def +(elem1: A, elem2: A, elems: A): Set[A]** 通過新增傳入指定集合的元素建立一個新的不可變集合
7	def ++(elems: A): Set[A] 合併兩個集合
8	*def -(elem1: A, elem2: A, elems: A): Set[A]** 通過移除傳入指定集合的元素建立一個新的不可變集合
9	def addString(b: StringBuilder): StringBuilder 將不可變集合的所有元素新增到字串緩衝區
10	def addString(b: StringBuilder, sep: String): StringBuilder 將不可變集合的所有元素新增到字串緩衝區，並使用指定的分隔符
11	def apply(elem: A) 檢測集合中是否包含指定元素
12	def count(p: (A) => Boolean): Int 計算滿足指定條件的集合元素個數
13	def copyToArray(xs: Array[A], start: Int, len: Int): Unit 複製不可變集合元素到陣列
14	def diff(that: Set[A]): Set[A] 比較兩個集合的差集
15	def drop(n: Int): Set[A]] 返回丟棄前n個元素新集合
16	def dropRight(n: Int): Set[A] 返回丟棄最後n個元素新集合
17	def dropWhile(p: (A) => Boolean): Set[A] 從左向右丟棄元素，直到條件p不成立
18	def equals(that: Any): Boolean equals 方法可用於任意序列。用於比較系列是否相等。
19	def exists(p: (A) => Boolean): Boolean 判斷不可變集合中指定條件的元素是否存在。
20	def filter(p: (A) => Boolean): Set[A] 輸出符合指定條件的所有不可變集合元素。
21	def find(p: (A) => Boolean): Option[A] 查詢不可變集合中滿足指定條件的第一個元素
22	def forall(p: (A) => Boolean): Boolean 查詢不可變集合中滿足指定條件的所有元素
23	def foreach(f: (A) => Unit): Unit 將函式應用到不可變集合的所有元素
24	def head: A 獲取不可變集合的第一個元素
25	def init: Set[A] 返回所有元素，除了最後一個
26	def intersect(that: Set[A]): Set[A] 計算兩個集合的交集
27	def isEmpty: Boolean 判斷集合是否為空
28	def iterator: Iterator[A] 建立一個新的迭代器來迭代元素
29	def last: A 返回最後一個元素
30	def map[B](f: (A) => B): immutable.Set[B] 通過給定的方法將所有元素重新計算
31	def max: A 查詢最大元素
32	def min: A 查詢最小元素
33	def mkString: String 集合所有元素作為字串顯示
34	def mkString(sep: String): String 使用分隔符將集合所有元素作為字串顯示
35	def product: A 返回不可變集合中數字元素的積。
36	def size: Int 返回不可變集合元素的數量
37	def splitAt(n: Int): (Set[A], Set[A]) 把不可變集合拆分為兩個容器，第一個由前 n 個元素組成，第二個由剩下的元素組成
38	def subsetOf(that: Set[A]): Boolean 如果集合中含有子集返回 true，否則返回false
39	def sum: A 返回不可變集合中所有數字元素之和
40	def tail: Set[A] 返回一個不可變集合中除了第一元素之外的其他元素
41	def take(n: Int): Set[A] 返回前 n 個元素
42	def takeRight(n: Int):Set[A] 返回後 n 個元素
43	def toArray: Array[A] 將集合轉換為陣列
44	def toBuffer[B >: A]: Buffer[B] 返回緩衝區，包含了不可變集合的所有元素
45	def toList: List[A] 返回 List，包含了不可變集合的所有元素
46	def toMap[T, U]: Map[T, U] 返回 Map，包含了不可變集合的所有元素
47	def toSeq: Seq[A] 返回 Seq，包含了不可變集合的所有元素
48	def toString(): String 返回一個字串，以物件來表示

3、Map（對映）

Map ：鍵值對對映的結合，每一個元素都包括一個key和一個value

Map(對映)是一種可迭代的鍵值對（key/value）結構。
所有的值都可以通過鍵來獲取。
Map 中的鍵都是唯一的。
Map 也叫雜湊表（Hash tables）。

Map 有兩種型別，可變與不可變，區別在於可變物件可以修改它，而不可變物件不可以。

預設情況下 Scala 使用不可變 Map。如果需要使用可變集合，需要顯式的引入 import scala.collection.mutable.Map 類
在 Scala 中可以同時使用可變與不可變 Map，不可變的直接使用 Map，可變的使用 mutable.Map。

eg：

//不可變map
//空雜湊表，鍵為字串，值為整型
var A:Map[Char,Int] = Map()
//鍵值對演示
val colors = Map("red" -> "#FF0000","azure" -> "#F0FFFF")

定義 Map 時，需要為鍵值對定義型別。如果需要新增 key-value 對，可以使用 + 號

   eg：A += ('I' -> 1)   此處注意I用的是單引號

Map 基本操作

Scala Map 有三個基本操作：

方法	描述
keys	返回 Map 所有的鍵(key)
values	返回 Map 所有的值(value)
isEmpty	在 Map 為空時返回true

eg：

Map 合併

可以使用 ++ 運算子或 Map.++() 方法來連線兩個 Map，Map 合併時會移除重複的 key。

eg：

輸出 Map 的 keys 和 values

eg：通過 foreach 迴圈輸出 Map 中的 keys 和 values：

檢視 Map 中是否存在指定的 Key

可以使用 Map.contains 方法來檢視 Map 中是否存在指定的 Key。

eg：

object Test {
  def main(args: Array[String]){
    val sites = Map("runnob" -> "http://www.runnob.com",
                    "baidu" -> "http://www.baidu.com",
                    "taobao" -> "http://www.taobao.com")

    if (sites.contains("runnob")){
      println("runnob鍵存在，對應的值為：" + sites("runnob"))
    }else{
      println("runnob鍵不存在！")
    }
  }
}

執行結果：runnob鍵存在，對應的值為：http://www.runnob.com

Scala Map 方法

下表列出了 Scala Map 常用的方法：

序號	方法及描述
1	def ++(xs: Map[(A, B)]): Map[A, B] 返回一個新的 Map，新的 Map xs 組成
2	*def -(elem1: A, elem2: A, elems: A): Map[A, B]** 返回一個新的 Map, 移除 key 為 elem1, elem2 或其他 elems。
3	def --(xs: GTO[A]): Map[A, B] 返回一個新的 Map, 移除 xs 物件中對應的 key
4	def get(key: A): Option[B] 返回指定 key 的值
5	def iterator: Iterator[(A, B)] 建立新的迭代器，並輸出 key/value 對
6	def addString(b: StringBuilder): StringBuilder 將 Map 中的所有元素附加到StringBuilder，可加入分隔符
7	def addString(b: StringBuilder, sep: String): StringBuilder 將 Map 中的所有元素附加到StringBuilder，可加入分隔符
8	def apply(key: A): B 返回指定鍵的值，如果不存在返回 Map 的預設方法
9	def clear(): Unit 清空 Map
10	def clone(): Map[A, B] 從一個 Map 複製到另一個 Map
11	def contains(key: A): Boolean 如果 Map 中存在指定 key，返回 true，否則返回 false。
12	def copyToArray(xs: Array[(A, B)]): Unit 複製集合到陣列
13	def count(p: ((A, B)) => Boolean): Int 計算滿足指定條件的集合元素數量
14	def default(key: A): B 定義 Map 的預設值，在 key 不存在時返回。
15	def drop(n: Int): Map[A, B] 返回丟棄前n個元素新集合
16	def dropRight(n: Int): Map[A, B] 返回丟棄最後n個元素新集合
17	def dropWhile(p: ((A, B)) => Boolean): Map[A, B] 從左向右丟棄元素，直到條件p不成立
18	def empty: Map[A, B] 返回相同型別的空 Map
19	def equals(that: Any): Boolean 如果兩個 Map 相等(key/value 均相等)，返回true，否則返回false
20	def exists(p: ((A, B)) => Boolean): Boolean 判斷集合中指定條件的元素是否存在
21	def filter(p: ((A, B))=> Boolean): Map[A, B] 返回滿足指定條件的所有集合
22	def filterKeys(p: (A) => Boolean): Map[A, B] 返回符合指定條件的不可變 Map
23	def find(p: ((A, B)) => Boolean): Option[(A, B)] 查詢集合中滿足指定條件的第一個元素
24	def foreach(f: ((A, B)) => Unit): Unit 將函式應用到集合的所有元素
25	def init: Map[A, B] 返回所有元素，除了最後一個
26	def isEmpty: Boolean 檢測 Map 是否為空
27	def keys: Iterable[A] 返回所有的key/p>
28	def last: (A, B) 返回最後一個元素
29	def max: (A, B) 查詢最大元素
30	def min: (A, B) 查詢最小元素
31	def mkString: String 集合所有元素作為字串顯示
32	def product: (A, B) 返回集合中數字元素的積。
33	def remove(key: A): Option[B] 移除指定 key
34	def retain(p: (A, B) => Boolean): Map.this.type 如果符合滿足條件的返回 true
35	def size: Int 返回 Map 元素的個數
36	def sum: (A, B) 返回集合中所有數字元素之和
37	def tail: Map[A, B] 返回一個集合中除了第一元素之外的其他元素
38	def take(n: Int): Map[A, B] 返回前 n 個元素
39	def takeRight(n: Int): Map[A, B] 返回後 n 個元素
40	def takeWhile(p: ((A, B)) => Boolean): Map[A, B] 返回滿足指定條件的元素
41	def toArray: Array[(A, B)] 集合轉陣列
42	def toBuffer[B >: A]: Buffer[B] 返回緩衝區，包含了 Map 的所有元素
43	def toList: List[A] 返回 List，包含了 Map 的所有元素
44	def toSeq: Seq[A] 返回 Seq，包含了 Map 的所有元素
45	def toSet: Set[A] 返回 Set，包含了 Map 的所有元素
46	def toString(): String 返回字串物件

4、元組

元組是不同型別的值的集合

與列表一樣，元組也是不可變的，但與列表不同的是元組可以包含不同型別的元素。
元組的值是通過將單個的值包含在圓括號中構成的。

eg：

val a = (1,3.14,"Fred")
val b = new Tuple3(1,3.14,"Fred")

元組的實際型別取決於它的元素的型別

目前 Scala 支援的元組最大長度為 22。對於更大長度可以使用集合，或者擴充套件元組。

可以通過數字索引訪問元組的元素

eg：可以使用 t._1 訪問第一個元素， t._2 訪問第二個元素

object Test {
  def main(args: Array[String]){
    val t = (4,3,2,1)
    val sum = t._1+t._2+t._3+t._4
    println("元素之和：" + sum)    //元素之和：10

  }
}

迭代元組

可以使用 Tuple.productIterator() 方法來迭代輸出元組的所有元素：

eg：

object Test {
  def main(args: Array[String]){
    val t = (4,3,2,1)
    t.productIterator.foreach{i => println("value = " + i)}
     /*執行結果：
      value = 4
      value = 3
      value = 2
      value = 1
      */
  }
}

元組轉為字串

可以使用 Tuple.toString() 方法將元組的所有元素組合成一個字串

eg：

object Test {
  def main(args: Array[String]){
    val t = new Tuple3(1,"hello",Console)
    println("連線後的字串：" + t.toString())   //連線後的字串：(1,hello,[email protected])
  }
}

元素交換

可以使用 Tuple.swap 方法來交換元組的元素。

eg：

object Test {
  def main(args: Array[String]){
    val t = new Tuple2("www.google.com","www.runnob.com")
    println("交換後的元組：" + t.swap)   //交換後的元組：(www.runnob.com,www.google.com)
  }
}

5、Option

Option[T] 表示有可能包含值的容器，也可能不包含值。

Scala Option(選項)型別用來表示一個值是可選的（有值或無值)。
Option[T] 是一個型別為 T 的可選值的容器：如果值存在， Option[T] 就是一個 Some[T] ，如果不存在， Option[T] 就是物件 None 。

eg：

object Test {
  def main(args: Array[String]){
    val myMap:Map[String,String] = Map("key1" -> "value")
    val value1:Option[String] = myMap.get("key1")
    val value2:Option[String] = myMap.get("key2")

    println(value1)   //Some(value)
    println(value2)   //None
  }
}

在上面的程式碼中，myMap 一個是一個 Key 的型別是 String，Value 的型別是 String 的 hash map，但不一樣的是他的 get() 返回的是一個叫 Option[String] 的類別。

eg：

Scala 使用 Option[String] 來告訴你：「我會想辦法回傳一個 String，但也可能沒有 String 給你」。
myMap 裡並沒有 key2 這筆資料，get() 方法返回 None。
Option 有兩個子類別，一個是 Some，一個是 None，當他回傳 Some 的時候，代表這個函式成功地給了你一個 String，而你可以透過 get() 這個函式拿到那個 String，如果他返回的是 None，則代表沒有字串可以給你。

val sites = Map("runnob" -> "www.runnob.com","google" -> "www.google.com")
 println(sites.get("runnob"))  //Some(www.runnob.com)
 println(sites.get("baidu"))    //None

也可以通過模式匹配來輸出匹配值：

eg：

object Test {
  def show(x:Option[String])= x match {
    case Some(s) => s
    case None => "?"
  }
  def main(args: Array[String]){
   val sites = Map("runnob" -> "www.runnob.com","google" -> "www.google.com")
    println(show(sites.get("runnob")))  //www.runnob.com
    println(show(sites.get("baidu")))    //?
  }
}

getOrElse() 方法

可以使用 getOrElse() 方法來獲取元組中存在的元素或者使用其預設的值

object Test {
  def main(args: Array[String]){
   val a:Option[Int] = Some(5)
    val b:Option[Int] = None

    println(a.getOrElse(0))      //5
    println(b.getOrElse(10))     //10
  }
}

isEmpty() 方法

可以使用 isEmpty() 方法來檢測元組中的元素是否為 None

object Test {
  def main(args: Array[String]){
   val a:Option[Int] = Some(5)
    val b:Option[Int] = None

    println(a.isEmpty)      //false
    println(b.isEmpty)     //true
  }
}

Scala Option 常用方法

下表列出了 Scala Option 常用的方法：

序號	方法及描述
1	def get: A 獲取可選值
2	def isEmpty: Boolean 檢測可選型別值是否為 None，是的話返回 true，否則返回 false
3	def productArity: Int 返回元素個數， A(x_1, ..., x_k), 返回 k
4	def productElement(n: Int): Any 獲取指定的可選項，以 0 為起始。即 A(x_1, ..., x_k), 返回 x_(n+1) ， 0 < n < k.
5	def exists(p: (A) => Boolean): Boolean 如果可選項中指定條件的元素存在且不為 None 返回 true，否則返回 false。
6	def filter(p: (A) => Boolean): Option[A] 如果選項包含有值，而且傳遞給 filter 的條件函式返回 true， filter 會返回 Some 例項。否則，返回值為 None 。
7	def filterNot(p: (A) => Boolean): Option[A] 如果選項包含有值，而且傳遞給 filter 的條件函式返回 false， filter 會返回 Some 例項。否則，返回值為 None 。
8	def flatMap[B](f: (A) => Option[B]): Option[B] 如果選項包含有值，則傳遞給函式 f 處理後返回，否則返回 None
9	def foreach[U](f: (A) => U): Unit 如果選項包含有值，則將每個值傳遞給函式 f，否則不處理。
10	def getOrElse[B >: A](default: => B): B 如果選項包含有值，返回選項值，否則返回設定的預設值。
11	def isDefined: Boolean 如果可選值是 Some 的例項返回 true，否則返回 false。
12	def iterator: Iterator[A] 如果選項包含有值，迭代出可選值。如果可選值為空則返回空迭代器。
13	def map[B](f: (A) => B): Option[B] 如果選項包含有值，返回由函式 f 處理後的 Some，否則返回 None
14	def orElse[B >: A](alternative: => Option[B]): Option[B] 如果一個 Option 是 None ， orElse 方法會返回傳名引數的值，否則，就直接返回這個 Option。
15	def orNull 如果選項包含有值返回選項值，否則返回 null。

三、Iterator（迭代器）

迭代器不是一個容器，更確切的說是逐一訪問容器內元素的方法。

Scala Iterator（迭代器）不是一個集合，它是一種用於訪問集合的方法。
迭代器 it 的兩個基本操作是 next 和 hasNext。
呼叫 it.next() 會返回迭代器的下一個元素，並且更新迭代器的狀態。
呼叫 it.hasNext() 用於檢測集合中是否還有元素。

讓迭代器 it 逐個返回所有元素最簡單的方法是使用 while 迴圈：

eg：

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

執行結果：

Baidu
Google
Runnob
Taobao

查詢最大與最小元素

使用 it.min 和 it.max 方法從迭代器中查詢最大與最小元素

eg：

object Test {
  def main(args: Array[String]){
    var ita = Iterator(20,40,3,20,6,30)
    var itb = Iterator(20,40,3,20,6,30)
    println("max:" + ita.max)
    println("min:" + itb.min)
  }
}

獲取迭代器的長度

使用 it.size 或 it.length 方法來檢視迭代器中的元素個數。

eg：

object Test {
  def main(args: Array[String]){
    var ita = Iterator(20,40,3,20,6,30)
    var itb = Iterator(20,40,3,20,6,30)
    println("size:" + ita.size)      //size:6
    println("length:" + itb.length)   // length:6
  }
}

Scala Iterator 常用方法

下表列出了 Scala Iterator 常用的方法：

序號	方法及描述
1	def hasNext: Boolean 如果還有可返回的元素，返回true。
2	def next(): A 返回迭代器的下一個元素，並且更新迭代器的狀態
3	def ++(that: => Iterator[A]): Iterator[A] 合併兩個迭代器
4	def ++[B >: A](that :=> GenTraversableOnce[B]): Iterator[B] 合併兩個迭代器
5	def addString(b: StringBuilder): StringBuilder 新增一個字串到 StringBuilder b
6	def addString(b: StringBuilder, sep: String): StringBuilder 新增一個字串到 StringBuilder b，並指定分隔符
7	def buffered: BufferedIterator[A] 迭代器都轉換成 BufferedIterator
8	def contains(elem: Any): Boolean 檢測迭代器中是否包含指定元素
9	def copyToArray(xs: Array[A], start: Int, len: Int): Unit 將迭代器中選定的值傳給陣列
10	def count(p: (A) => Boolean): Int 返回迭代器元素中滿足條件p的元素總數。
11	def drop(n: Int): Iterator[A] 返回丟棄前n個元素新集合
12	def dropWhile(p: (A) => Boolean): Iterator[A] 從左向右丟棄元素，直到條件p不成立
13	def duplicate: (Iterator[A], Iterator[A]) 生成兩個能分別返回迭代器所有元素的迭代器。
14	def exists(p: (A) => Boolean): Boolean 返回一個布林值，指明迭代器元素中是否存在滿足p的元素。
15	def filter(p: (A) => Boolean): Iterator[A] 返回一個新迭代器，指向迭代器元素中所有滿足條件p的元素。
16	def filterNot(p: (A) => Boolean): Iterator[A] 返回一個迭代器，指向迭代器元素中不滿足條件p的元素。
17	def find(p: (A) => Boolean): Option[A] 返回第一個滿足p的元素或None。注意：如果找到滿足條件的元素，迭代器會被置於該元素之後；如果沒有找到，會被置於終點。
18	def flatMap[B](f: (A) => GenTraversableOnce[B]): Iterator[B] 針對迭代器的序列中的每個元素應用函式f，並返回指向結果序列的迭代器。
19	def forall(p: (A) => Boolean): Boolean 返回一個布林值，指明 it 所指元素是否都滿足p。
20	def foreach(f: (A) => Unit): Unit 在迭代器返回的每個元素上執行指定的程式 f
21	def hasDefiniteSize: Boolean 如果迭代器的元素個數有限則返回true（預設等同於isEmpty）
22	def indexOf(elem: B): Int 返回迭代器的元素中index等於x的第一個元素。注意：迭代器會越過這個元素。
23	def indexWhere(p: (A) => Boolean): Int 返回迭代器的元素中下標滿足條件p的元素。注意：迭代器會越過這個元素。
24	def isEmpty: Boolean 檢查it是否為空, 為空返回 true，否則返回false（與hasNext相反）。
25	def isTraversableAgain: Boolean Tests whether this Iterator can be repeatedly traversed.
26	def length: Int 返回迭代器元素的數量。
27	def map[B](f: (A) => B): Iterator[B] 將 it 中的每個元素傳入函式 f 後的結果生成新的迭代器。
28	def max: A 返回迭代器迭代器元素中最大的元素。
29	def min: A 返回迭代器迭代器元素中最小的元素。
30	def mkString: String 將迭代器所有元素轉換成字串。
31	def mkString(sep: String): String 將迭代器所有元素轉換成字串，並指定分隔符。
32	def nonEmpty: Boolean 檢查容器中是否包含元素（相當於 hasNext）。
33	def padTo(len: Int, elem: A): Iterator[A] 首先返回迭代器所有元素，追加拷貝 elem 直到長度達到 len。
34	def patch(from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B] 返回一個新迭代器，其中自第 from 個元素開始的 replaced 個元素被迭代器所指元素替換。
35	def product: A 返回迭代器所指數值型元素的積。
36	def sameElements(that: Iterator[_]): Boolean 判斷迭代器和指定的迭代器引數是否依次返回相同元素
37	def seq: Iterator[A] 返回集合的系列檢視
38	def size: Int 返回迭代器的元素數量
39	def slice(from: Int, until: Int): Iterator[A] 返回一個新的迭代器，指向迭代器所指向的序列中從開始於第 from 個元素、結束於第 until 個元素的片段。
40	def sum: A 返回迭代器所指數值型元素的和
41	def take(n: Int): Iterator[A] 返回前 n 個元素的新迭代器。
42	def toArray: Array[A] 將迭代器指向的所有元素歸入陣列並返回。
43	def toBuffer: Buffer[B] 將迭代器指向的所有元素拷貝至緩衝區 Buffer。
44	def toIterable: Iterable[A] Returns an Iterable containing all elements of this traversable or iterator. This will not terminate for infinite iterators.
45	def toIterator: Iterator[A] 把迭代器的所有元素歸入一個Iterator容器並返回。
46	def toList: List[A] 把迭代器的所有元素歸入列表並返回
47	def toMap[T, U]: Map[T, U] 將迭代器的所有鍵值對歸入一個Map並返回。
48	def toSeq: Seq[A] 將代器的所有元素歸入一個Seq容器並返回。
49	def toString(): String 將迭代器轉換為字串
50	def zip[B](that: Iterator[B]): Iterator[(A, B) 返回一個新迭代器，指向分別由迭代器和指定的迭代器 that 元素一一對應而成的二元組序列

Collection方法集合(hasNext(),next())，關於迭代器

/*Iterator iterator(),獲取集合所依賴的迭代器物件通過迭代器中的方法完成集合的迭代注意：這種方式是所有集合通用的遍歷方式*/import java.util.*;public class fuck3{public static void main(Stri

scala陣列、Scala Collection（集合）、Iterator（迭代器）

一、scala陣列陣列：用來儲存固定大小的同類型元素，通過索引來訪問指定元素，索引index從0開始宣告陣列定義陣列--語法格式： var z:Array[String] = new Array[String](3) 或 var z = new Array[St

Iterator（迭代器）、增強for迴圈

二、Iterator介面三、Iterator的實現過程四、迭代器的併發修改異常五、增強的for迴圈一、迭代器（It

python3.5進階（三）-------------實現多工之協程（生成器，迭代器）

1.迭代器：迭代是訪問集合元素的一種方式，迭代器是可以記住遍歷的位置的物件，迭代器物件從集合的第一個元素開始訪問，直到所有訪問結束，迭代器只能前進不能後退。判斷一個數據型別是否可以迭代，看是否能for迴圈。如（字串，列表，元祖...）序列可以迭代，數字不能迭代，或通過isintance([11,12

生成器（自身就是一個迭代器）

對於python中兩種延遲生成值的結構：生成器函式生成器表示式我相信生成器函式各位都是不陌生的，就是在函式返回值前用yield,但是注意一點，這裡我並沒有說用yield代替return，兩個意義其實是不同的，所以不存在代替的問題，兩者可以共存。例如：

python初學一（迭代器）

一、迭代器的基本知識： 1、迭代器的建立：（1）系統函式iter（） &nb

設計模式是什麼鬼（迭代器）講得形象化，圖形加助理解和記憶

文章出處：https://www.javazhiyin.com/tag/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F 作者：凸凹裡歐方法迭代：代的更迭，從初代到末代的遍歷，指對某類集合中的每個元素按順序取出

Java 知識點整理-9.Java集合框架集合概述+Collection介面+Iterator介面+迭代器+List介面+併發修改異常+ListIterator介面+Vector類+List子類

本章會用大量程式碼做具體演示。統一說明：返回型別E在JDK1.5之前是Object，1.5之後等泛型再講。先介紹一個偶然發現的快捷鍵和一個很實用的快捷鍵： Alt + Shift + N 快速呼叫建立選單。直接按開頭的首字母進行建立即可，某些時候感覺比Ctrl + N更快捷。

牛客小白D題（STL的迭代器）

「只要我拉動繩線，你就得隨之起舞。」 ——泰茲瑞泰茲瑞來到卡拉德許之後，由於他精湛的神器製造技

（五）設計模式之迭代器模式（Iterator）

前言：參考圖書：軟體設計模式與體系結構參考部落格：https://www.cnblogs.com/wanson/articles/9277813.html 正題：迭代器（iterator）有時又稱遊標

少說話多寫程式碼之Python學習051——類的成員（實現迭代器）

在Python類中，實現迭代器，要定義這個方法，__iter__。這個方法返回一個迭代器，其實質是帶有一個next方法的物件。為形象起見，我們定義一個斐波那契數列類。如下， class MyFibs: def __init__(self): &nb

Python基礎（8）：python中的特性進階篇（迭代，列表生成式，生成器，迭代器）

python中還包括一些高階特性，以下簡單介紹。迭代定義：用for迴圈來遍歷物件的過程，叫做迭代。作用物件：可迭代物件如何判斷是否為可迭代物件：isinstance(xxx,Iterable)，Iterable型別來源於collections模組。應用場景： 1

1021 個位數統計（15 分）（迭代器）

1021 個位數統計（15 分）給定一個 k 位整數 N=dk−110k−1+⋯+d1101+d0 (0≤di≤9, i=0,⋯,k−1, dk−1>0)，請編寫程

1021 個位數統計（15 分）（迭代器）

1021 個位數統計（15 分）給定一個 k 位整數 N=dk−110k−1+⋯+d1101+d0 (0≤di≤9, i=0,⋯,k−1, dk−1>0)，請編寫程式統計每種不同的個位數字出現的次數。例如：給定 N=100

學習筆記 c++ （迭代器）

迭代器迭代器是演算法和容器的橋樑迭代器用作訪問容器中的元素演算法不直接操作容器中的資料，而是通過迭代器間接操作演算法和容器獨立增加新的演算法，無需影響容器的實現增加新的容器，原有的演算法也能適用輸入流迭代器和輸出流迭代器輸入流迭代

設計模式（迭代器）

1 迭代模式 1.1能順序訪問聚合（一群物件）中的各個元素，而又不暴露其內部的表示 1.2 類圖下面通過展現一個例子說明迭代模式，早餐選單的選單項是一個ArrayList型別，而午餐選單的選單項是一個數組型別，如果要遍歷他們，就得通過封裝遍歷。

python學習筆記10（迭代器）

可迭代物件與迭代器可迭代物件：可以直接作用於for迴圈的物件統稱為可迭代物件(Iterable)。可以用isinstance()去判斷一個物件是否是Iterable物件可以直接作用於for迴圈的資料型別一般分兩種 1、集合資料型別，如list、tuple、dict、set、st

17 python 初學（迭代器）

生成器都是迭代器，迭代器不一定是生成器迭代器滿足兩個條件： 1. 有iter方法 2. 有next方法 # list, tuple, dict, string: iterable(他們都有iter方法，所以都是可迭代物件) # 呼叫 iter 方法返回的 d 就是一個迭代器 # l

Iterator（迭代器）的使用

最近使用Hibernate，在多對一對映中需要用到Set<T> 物件，為了把物件中的資料輸出，用到了Iterator物件。 Iterator是一個輕量級（建立代價很小）物件，它可以遍歷序列

Python高階特性（切片迭代列表生成式生成器迭代器）學習筆記

在Python中，程式碼不是越多越好，而是越少越好。程式碼不是越複雜越好，而是越簡單越好。基於這一思想，Python中有非常有用的高階特性，1行程式碼能實現的功能，決不寫5行程式碼。請始終牢記，程式碼越少，開發效率越高。切片（Slice）切

scala陣列、Scala Collection（集合）、Iterator（迭代器）

一、scala陣列

宣告陣列

處理陣列

多維陣列

合併陣列

建立區間陣列

Scala 陣列方法

二、Scala Collection

1、List（列表）

列表基本操作

連線列表

List.fill()

List.tabulate()

List.reverse

Scala List 常用方法

2、Set（集合）

集合基本操作

連線集合

查詢集合中最大與最小元素

交集

Scala Set 常用方法

3、Map（對映）

Map 基本操作

Map 合併

輸出 Map 的 keys 和 values

檢視 Map 中是否存在指定的 Key

Scala Map 方法

4、元組

迭代元組

元組轉為字串

元素交換

5、Option

getOrElse() 方法

isEmpty() 方法

Scala Option 常用方法

三、Iterator（迭代器）

查詢最大與最小元素

獲取迭代器的長度

Scala Iterator 常用方法

相關推薦