Scala学习之路之篇五（集合、迭代器）

// ===============Scala集合=============
// **Scala 集合分为可变的和不可变的集合：
// 1、【可变集合】可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。
// 2、而【不可变集合】类，相比之下，永远不会改变；
//	  不过，你仍然可以模拟添加，移除或更新操作，但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。

// =========== 几种常用集合类型的应用=========
// 1、List的特征是其元素以线性方式存储，集合中可以存放重复对象。
Scala List(列表)

// 2、Set是最简单的一种集合。集合中的对象不按特定的方式排序，并且没有重复对象。	
Scala Set(集合)

// 3、Map 是一种把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象。	
Scala Map(映射)

// 4、元组是不同类型的值的集合	
Scala 元组

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

// ------以下代码判断，演示了所有以上集合类型的定义实例：
// 定义整型 List
val x = List(1,2,3,4)

// 定义 Set
val 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)

// ==============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())
      }
   }
}

// ------查找最大与最小元素---------
// 可以使用 it.min 和 it.max 方法从迭代器中查找最大与最小元素，实例如下:
object Test {
   def main(args: Array[String]) {
      val ita = Iterator(20,40,2,50,69, 90)
      val itb = Iterator(20,40,2,50,69, 90)
      
      println("最大元素是：" + ita.max )
      println("最小元素是：" + itb.min )

   }
}

// --------获取迭代器的长度---------
// 可以使用 it.size 或 it.length 方法来查看迭代器中的元素个数。实例如下：
object Test {
   def main(args: Array[String]) {
      val ita = Iterator(20,40,2,50,69, 90)
      val itb = Iterator(20,40,2,50,69, 90)
      
      println("ita.size 的值: " + ita.size )
      println("itb.length 的值: " + itb.length )

   }
}

// ============Scala Iterator 常用方法===========
// 1、如果还有可返回的元素，返回true。	
def hasNext: Boolean

// 2、返回迭代器的下一个元素，并且更新迭代器的状态	
def next(): A

// 3、合并两个迭代器	
def ++(that: => Iterator[A]): Iterator[A]

// 4、合并两个迭代器	
def ++[B >: A](that :=> GenTraversableOnce[B]): Iterator[B]

// 5、添加一个字符串到 StringBuilder b	
def addString(b: StringBuilder): StringBuilder

// 6、添加一个字符串到 StringBuilder b，并指定分隔符	
def addString(b: StringBuilder, sep: String): StringBuilder

// 7、迭代器都转换成 BufferedIterator	
def buffered: BufferedIterator[A]

// 8、检测迭代器中是否包含指定元素	
def contains(elem: Any): Boolean

// 9、将迭代器中选定的值传给数组
def copyToArray(xs: Array[A], start: Int, len: Int): Unit

// 10、返回迭代器元素中满足条件p的元素总数。	
def count(p: (A) => Boolean): Int

// 11、返回丢弃前n个元素新集合	
def drop(n: Int): Iterator[A]

// 12、从左向右丢弃元素，直到条件p不成立	
def dropWhile(p: (A) => Boolean): Iterator[A]

// 13、生成两个能分别返回迭代器所有元素的迭代器。
def duplicate: (Iterator[A], Iterator[A])

// 14、返回一个布尔值，指明迭代器元素中是否存在满足p的元素。
def exists(p: (A) => Boolean): Boolean

// 15、返回一个新迭代器 ，指向迭代器元素中所有满足条件p的元素。	
def filter(p: (A) => Boolean): Iterator[A]

// 16、返回一个迭代器，指向迭代器元素中不满足条件p的元素。	
def filterNot(p: (A) => Boolean): Iterator[A]

// 17、返回第一个满足p的元素或None。注意：如果找到满足条件的元素，迭代器会被置于该元素之后；如果没有找到，会被置于终点。
def find(p: (A) => Boolean): Option[A]

// 18、针对迭代器的序列中的每个元素应用函数f，并返回指向结果序列的迭代器。
def flatMap[B](f: (A) => GenTraversableOnce[B]): Iterator[B]

// 19、返回一个布尔值，指明 it 所指元素是否都满足p。	
def forall(p: (A) => Boolean): Boolean

// 20、在迭代器返回的每个元素上执行指定的程序 f	
def foreach(f: (A) => Unit): Unit

// 21、如果迭代器的元素个数有限则返回true（缺省等同于isEmpty）	
def hasDefiniteSize: Boolean

// 22、返回迭代器的元素中index等于x的第一个元素。注意：迭代器会越过这个元素。	
def indexOf(elem: B): Int

// 23、返回迭代器的元素中下标满足条件p的元素。注意：迭代器会越过这个元素。	
def indexWhere(p: (A) => Boolean): Int

// 24、检查it是否为空, 为空返回 true，否则返回false（与hasNext相反）。	
def isEmpty: Boolean

// 25、Tests whether this Iterator can be repeatedly traversed.
def isTraversableAgain: Boolean

// 26、返回迭代器元素的数量。
def length: Int

// 27、将 it 中的每个元素传入函数 f 后的结果生成新的迭代器。	
def map[B](f: (A) => B): Iterator[B]

// 28、返回迭代器迭代器元素中最大的元素。
def max: A

// 29、返回迭代器迭代器元素中最小的元素。	
def min: A

// 30、将迭代器所有元素转换成字符串。	
def mkString: String

// 31、将迭代器所有元素转换成字符串，并指定分隔符。	
def mkString(sep: String): String

// 32、检查容器中是否包含元素（相当于 hasNext）。	
def nonEmpty: Boolean

// 33、首先返回迭代器所有元素，追加拷贝 elem 直到长度达到 len。	
def padTo(len: Int, elem: A): Iterator[A]

// 34、返回一个新迭代器，其中自第 from 个元素开始的 replaced 个元素被迭代器所指元素替换。	
def patch(from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B]

// 35、返回迭代器所指数值型元素的积。	
def product: A

// 36、判断迭代器和指定的迭代器参数是否依次返回相同元素	
def sameElements(that: Iterator[_]): Boolean

// 37、返回集合的系列视图	
def seq: Iterator[A]

// 38、返回迭代器的元素数量	
def size: Int

// 39、返回一个新的迭代器，指向迭代器所指向的序列中从开始于第 from 个元素、结束于第 until 个元素的片段。
def slice(from: Int, until: Int): Iterator[A]

// 40、返回迭代器所指数值型元素的和	
def sum: A

// 41、返回前 n 个元素的新迭代器。	
def take(n: Int): Iterator[A]

// 42、将迭代器指向的所有元素归入数组并返回。
def toArray: Array[A]

// 43、将迭代器指向的所有元素拷贝至缓冲区 Buffer。	
def toBuffer: Buffer[B]

// 44、Returns an Iterable containing all elements of this traversable or iterator. This will not terminate for infinite iterators.	
def toIterable: Iterable[A]

// 45、把迭代器的所有元素归入一个Iterator容器并返回。	
def toIterator: Iterator[A]

// 46、把迭代器的所有元素归入列表并返回	
def toList: List[A]

// 47、将迭代器的所有键值对归入一个Map并返回。	
def toMap[T, U]: Map[T, U]

// 48、将代器的所有元素归入一个Seq容器并返回。	
def toSeq: Seq[A]

// 49、将迭代器转换为字符串	
def toString(): String

// 50、返回一个新迭代器，指向分别由迭代器和指定的迭代器 that 元素一一对应而成的二元组序列
def zip[B](that: Iterator[B]): Iterator[(A, B)