scala入门学习（4）列表List-集合Set-映射Map等

一、列表List

1、List类型定义及List的特点

Scala 列表类似于数组，它们所有元素的类型都相同，但是它们也有所不同：列表是不可变的，值一旦被定义了就不能改变，其次列表 具有递归的结构（也就是链接表结构）而数组不是。

//字符串类型List
scala> val fruit=List("Apple","Banana","Orange")
fruit: List[String] = List(Apple, Banana, Orange)

//前一个语句与下面语句等同
scala> val fruit=List.apply("Apple","Banana","Orange")
fruit: List[String] = List(Apple, Banana, Orange)

//数值类型List
scala> val nums=List(1,2,3,4,5)
nums: List[Int] = List(1, 2, 3, 4, 5)

//多重List，List的子元素为List
scala> val diagMatrix=List(List(1,0,0),List(0,1,0),List(0,0,1))
diagMatrix: List[List[Int]] = List(List(1, 0, 0), List(0, 1, 0), List(0, 0, 1))

//遍历List
scala> for (i <- nums) println("List Element: "+i)

2、List常用构造方法

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

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

//采用::及Nil进行列表构建
scala> val nums = 1 :: (2 :: (3 :: (4 :: Nil)))
nums: List[Int] = List(1, 2, 3, 4)

//由于::操作符的优先级是从右往左的，因此上一条语句等同于下面这条语句
scala> val nums=1::2::3::4::Nil
nums: List[Int] = List(1, 2, 3, 4)

3、List基本操作

包括列表元素的判断（是否为空，是否以某个序列结尾、开头或者存在返回相应索引，）、增删、取值、取子列表、计算（求和、最大、最小、长度等），排序等基本操作

scala> var a=List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
//为列表预添加元素 +:和:+ 的用法区别
scala> 5 +: a
res50: List[Int] = List(5, 1, 2, 3, 4)
scala> List(5,4) +: a
res62: List[Any] = List(List(5, 4), 1, 2, 3, 4)
scala> a +: 5
<console>:28: error: value +: is not a member of Int
scala> a :+ 5
res59: List[Int] = List(1, 2, 3, 4, 5)
scala>a :+ List(5,4)
res60: List[Any] = List(1, 2, 3, 4, List(5, 4))

//判断是否为空
scala> a.isEmpty
res108: Boolean = false

//取第一个无素
scala> a.head
res43: Int = 1

//取除第一个元素外剩余的元素，返回的是列表
scala> a.tail
res44: List[Int] = List(2, 3, 4)

//取列表第二个元素
scala> a.tail.head
res115: Int = 2

//插入排序算法实现
def isort(xs: List[Int]): List[Int] =
if (xs.isEmpty) Nil
else insert(xs.head, isort(xs.tail))

def insert(x: Int, xs: List[Int]): List[Int] =
if (xs.isEmpty || x <= xs.head) x :: xs
else xs.head :: insert(x, xs.tail)

//List连接操作
scala> List(1,2,3):::List(4,5,6)
res116: List[Int] = List(1, 2, 3, 4, 5, 6)

//取除最后一个元素外的元素，返回的是列表
scala> a.init
res117: List[Int] = List(1, 2, 3)

//取列表最后一个元素，返回元素值
scala> a.last
res118: Int = 4

//列表元素倒置，返回新列表
scala> a.reverse.tail
res45: List[Int] = List(3, 2, 1)
scala> a.reverse.head
res46: Int = 4

//丢弃前n个元素,返回新列表
scala> a drop 1
res124: List[Int] = List(2, 3, 4)
scala> a.drop(3)
res0: List[Int] = List(4)
//dropRight(n: Int): List[A] 丢弃最后n个元素，并返回新列表
//获取前n个元素
scala> a take 1
res125: List[Int] = List(1)
scala> a.take(3)
res126: List[Int] = List(1, 2, 3)

//去除列表的重复元素，并返回新列表
scala> a=a:+4;a.distinct
a: List[Int] = List(1, 2, 3, 4, 4)
res94: List[Int] = List(1, 2, 3, 4)

//dropWhile(p: (A) => Boolean): List[A]
//从左向右丢弃元素，直到条件p不成立
scala> a.dropWhile(_==1)
res136: List[Int] = List(2, 3, 4, 4)
scala> a.dropWhile(_==2)
res137: List[Int] = List(1, 2, 3, 4, 4)
scala> a.dropWhile(_==a.head)
res138: List[Int] = List(2, 3, 4, 4)

//endsWith[B](that: Seq[B]): Boolean
//检测列表是否以指定序列结尾
scala> a.endsWith(List(4,3))
res145: Boolean = false
scala> a.endsWith(List(4,4))
res146: Boolean = true
scala> a.endsWith(List(4))
res147: Boolean = true
scala> a.endsWith(List(3))
res148: Boolean = false

//startsWith[B](that: Seq[B], offset: Int): Boolean
//检测列表在指定位置是否包含指定序列
scala> a.startsWith(List(3,4),2)
res95: Boolean = true
scala> a.startsWith(List(3),2)
res96: Boolean = true
scala> a.startsWith(List(3),4)
res97: Boolean = false
scala> a.startsWith(List(3),1)
res98: Boolean = false

//equals(that: Any): Boolean
//判断是否相等
scala> a.equals(List(1,2,3))
res150: Boolean = false
scala> a.equals(List(1,2,3,4,4))
res151: Boolean = true

//exists(p: (A) => Boolean): Boolean
//判断列表中指定条件的元素是否存在。
scala> a.exists(x=> x>3)
res159: Boolean = true
scala> a.exists(_>3)
res160: Boolean = true
scala> a.exists(_>5)
res161: Boolean = false

//检测列表中是否包含指定的元素
scala> a.contains(5)
res76: Boolean = false

//计算列表长度，最大最小值
scala> a.length
res2: Int = 4
scala> a.max
res3: Int = 4
scala> a.min
res4: Int = 1
scala> a.sum
res5: Int = 10

//排序
scala> a.sorted
res81: List[Int] = List(1, 2, 3, 4, 5)

4、List常用方法

列表的apply、range方法，列表链接，列表交集，列表的函数操作，列表元素的元素索引，列表分割

//apply方法
scala>  List.apply(1, 2, 3)
res139: List[Int] = List(1, 2, 3)

//range方法，构建某一值范围内的List
scala>  List.range(2, 6)
res140: List[Int] = List(2, 3, 4, 5)
//步长为2
scala>  List.range(2, 6,2)
res141: List[Int] = List(2, 4)

//列表连接
scala> List.concat(List('a', 'b'), List('c'))
res148: List[Char] = List(a
, b, c)
//字符串要加双引号
var b=List("woe","wow","adabosting","bostong","randormforest")
b: List[String] = List(woe, wow, adabosting, bostong, randormforest)
//filter(p: (A) => Boolean): List[A]
//输出符号指定条件的所有元素。
scala> b.filter(_.length==3)
res5: List[String] = List(woe, wow)
//条件元素可以用字母=>字母 形式，也可以用_
scala> b.filter(x=>x.length==3)
res6: List[String] = List(woe, wow)

//indexOf(elem: A, from: Int): Int
//从指定位置 from 开始查找元素第一次出现的位置
scala> b.indexOf("bost",0)
res20: Int = -1
scala> b.indexOf("bostong",1)
res22: Int = 3

// intersect(that: Seq[A]): List[A]
//计算多个集合的交集
scala> var d=List(b.head)
d: List[String] = List(woe)
scala> b.intersect(d)
res33: List[String] = List(woe)

//lastIndexOf(elem: A, end: Int): Int
//在指定的位置 end 开始查找元素最后出现的位置
scala> b.lastIndexOf("woe",4)
res63: Int = 0
//截止第5个，最后一次出现的位置在0，
scala> b.lastIndexOf("woe",5)
res64: Int = 5
//返回值-1，说明不存在
scala> b.lastIndexOf("bostong",2)
res65: Int = -1

//map[B](f: (A) => B): List[B]
通过给定的方法将所有元素重新计算
scala> b.map(_.length)
res70: List[Int] = List(3, 3, 10, 7, 13, 3)

//Zip操作
scala> val a=List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
scala> val chars=List('1','2','3','4')
chars: List[Char] = List(1, 2, 3, 4)

//返回的是List类型的元组(Tuple）
scala> a zip chars
res130: List[(Int, Char)] = List((1,1), (2,2), (3,3), (4,4))

//将列表进行分割
scala> a.splitAt(2)
res127: (List[Int], List[Int]) = (List(1, 2),List(3, 4))

//前一个操作与下列语句等同
scala> (a.take(2),a.drop(2))
res128: (List[Int], List[Int]) = (List(1, 2),List(3, 4))

5、数据类型间的转换

列表元素类型转换，列表与其他类型（数组，集合，序列等）的转换

//将列表的元素复制到数组中。
scala> var b=Array(5,6,7,8,9)
b: Array[Int] = Array(5, 6, 7, 8, 9)
scala> a.copyToArray(b,0,2)
scala> b //其中a为1,2,3,4
res88: Array[Int] = Array(1, 2, 7, 8, 9)

//List toString方法
scala> a.toString
res131: String = List(1, 2, 3, 4，5)

//List mkString方法
scala> a.mkString
res132: String = 12345
scala> a.mkString("-")
res77: String = 1-2-3-4-5

//转换成数组,可变数组
scala> a.toArray
res103: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.toBuffer
res106: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)

//转换成序列
scala> a.toSeq
res108: scala.collection.immutable.Seq[Int] = List(1, 2, 3, 4, 5)
//转换成集合
scala> a.toSet
res110: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

二、Set(集合)

1、Set类型定义

Scala Set(集合)是没有重复的对象集合，所有的元素都是唯一的。

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

默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包。

//默认引用 scala.collection.immutable.Set，不可变集合
scala> val set = Set(1,2,3)
set: scala.collection.immutable.Set[Int] = Set(1, 2, 3)
scala> println(set.getClass.getName)
scala.collection.immutable.Set$Set3
scala> println(set.exists(_ % 2 == 0))
true
scala> println(set.drop(1))
Set(2, 3)

//引入可变集合
import scala.collection.mutable.Set // 可以在任何地方引入 可变集合
scala> val mutableSet = Set(1,2,3)
mutableSet: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
scala> println(mutableSet.getClass.getName)
scala.collection.mutable.HashSet

2、基本操作

包括Set的增删、取值、取子集、计算（求和、最大、最小、长度等），判断（是否为空，是否存在满足条件的元素，集合是否相等）等基本操作

//添加、删除元素，并创建一个新的集合，对于可变不可变均可如此操作，+/-变为+=/-=就是在原集合上增删，且可以多个元素
scala> a+5
res13: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)
scala> a-5
res14: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)
//注意：可变与不可变集合加入后，元素位置不一样
scala> a-(1,2)
res19: scala.collection.immutable.Set[Int] = Set(3, 4)

//取集合的第一个元素/最后一个元素，返回值为元素
scala> a.head
res137: Int = 1
scala> a.last
res145: Int = 4
//取集合的除第一个元素的所有，返回值为集合
scala> a.tail
res158: scala.collection.mutable.Set[Int] = Set(2, 3, 4)
//取集合的除最后一个元素的所有，返回值为集合
scala> a.init
res138: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

//drop返回丢弃前n个元素新集合,dropRight返回丢弃最后n个元素新集合
scala> a.drop(2)
res103: scala.collection.mutable.Set[Int] = Set(3, 4)
scala> a.dropRight(2)
res104: scala.collection.mutable.Set[Int] = Set(1, 2)

//返回前 n 个元素/后n个元素,返回值为集合
scala> a.take(2)
res159: scala.collection.mutable.Set[Int] = Set(1, 2)
scala> a.takeRight(2)
res160: scala.collection.mutable.Set[Int] = Set(3, 4)

//遍历集
scala> for(i<-a)println(i)
1
2
3
4

//比较序列是否相等，equals、==
scala> a.equals(Set(1,2,3,4))
res127: Boolean = true
scala> a.equals(3)
res128: Boolean = false
scala> a==b
res130: Boolean = false

//判断集合是否为空
scala> a.isEmpty
res139: Boolean = false

//求最大、最小，和、长度（size）与数组的length不一样
scala> a.max
res147: Int = 4
scala> a.min
res148: Int = 1
scala> a.sum
res149: Int = 10
scala> a.size
res151: Int = 4
//求积
scala> a.product
res154: Int = 24

//判断元素在集合中是否存在，返回布尔型
scala> a.contains(3)
res35: Boolean = true
scala> a(3)
res36: Boolean = true
scala> a.apply(5)
res79: Boolean = false
//判断满足条件的元素是否存在
scala> a.exists(_>3)
res131: Boolean = true
//判断所有元素是否满足条件
scala> a.forall(_>1)
res135: Boolean = false

3、常见操作

Set的交集、并集、差集，是否为子集，集合元素的计算、统计，条件查询删除等操作。

//计算满足指定条件的集合元素个数
scala> a.count(_>3)
res84: Int = 1
scala> a.count(x=>x>3)
res85: Int = 1

//通过给定的方法将所有元素重新计算
scala> a.map(_*2)
res146: scala.collection.mutable.Set[Int] = Set(2, 6, 4, 8)

//交集
scala> var a=Set(1,2,3,4);var a1=Set(7,8,9)
a: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
a1: scala.collection.mutable.Set[Int] = Set(9, 7, 8)
scala> var b1=Set("c","d","e");var b=Set("a","b","c")
b1: scala.collection.mutable.Set[String] = Set(c, d, e)
b: scala.collection.mutable.Set[String] = Set(c, a, b)
//可以使用 Set.& 方法或 Set.intersect 方法来查看两个集合的交集元素，返回集合。但是两个集合元素类型相同
scala> a.&(a1)
res69: scala.collection.mutable.Set[Int] = Set()
scala> a.intersect(a1)
res70: scala.collection.mutable.Set[Int] = Set()
//但是两个集合元素类型相同
scala> a.intersect(b)
<console>:25: error: type mismatch;
found   : scala.collection.mutable.Set[String]
required: scala.collection.GenSet[Int]
a.intersect(b)
//++ 可以合并两个集合，集合元素类型任意
scala> a++b
res76: scala.collection.mutable.Set[Any] = Set(c, 1, 2, 3, a, 4, b)
//注意类型变为了Any

//差集&~、diff
scala> a.&~(a1)
res74: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
scala> b.&~(b1)
res75: scala.collection.mutable.Set[String] = Set(a, b)
scala> b.diff(b1)
res100: scala.collection.mutable.Set[String] = Set(a, b)

//从左向右丢弃元素，直到条件p不成立,如下的取摸运算
scala> a.dropWhile(_%1==0)
res120: scala.collection.mutable.Set[Int] = Set()
scala> a.dropWhile(_%2==1)
res121: scala.collection.mutable.Set[Int] = Set(2, 3, 4)
//输出集合元素中符合指定条件的子集,返回值为集合
scala> a.filter(_>3)
res132: scala.collection.mutable.Set[Int] = Set(4)
//查找集合中满足指定条件的第一个元素,返回元素，并非下标索引
scala> a.find(_>1)
res136: Option[Int] = Some(2)

//集合是否是另一个集合的子集
scala> var b=Set(1,6,2,3,4,5);a.subsetOf(b)
b: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
res34: Boolean = true
scala> var b=Set(1,6,2,3);a.subsetOf(b)
b: scala.collection.immutable.Set[Int] = Set(1, 6, 2, 3)
res35: Boolean = false

4、数据类型间的转换

Set元素的转换，set与数组、列表、序列间的转换。

//集合所有元素作为字符串显示
scala> a.mkString
res152: String = 1234
scala> a.mkString("-")
res153: String = 1-2-3-4

//复制集合元素到数组
scala> var c=Array(5,6,7,8,9);a.copyToArray(c,0,2);
c: Array[Int] = Array(1, 2, 7, 8, 9)

//把集合拆分为两个容器，第一个由前 n 个元素组成，第二个由剩下的元素组成
scala> a.splitAt(2)
res157: (scala.collection.mutable.Set[Int], scala.collection.mutable.Set[Int]) = (Set(1, 2),Set(3, 4))

//转为数组，可变和不可变均可
scala> a.toBuffer
res162: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4)
scala> a.toArray
res163: Array[Int] = Array(1, 2, 3, 4)

//转换为列表
scala> a.toList
res164: List[Int] = List(1, 2, 3, 4)

//转为序列
scala> a.toSeq
res165: Seq[Int] = ArrayBuffer(1, 2, 3, 4)

//返回一个字符串，以对象来表示
scala> a.toString
res166: String = Set(1, 2, 3, 4)

三、Map(映射)

1、Map定义

Map(映射)是一种可迭代的键值对（key/value）结构。

所有的值都可以通过键来获取。

Map 中的键都是唯一的。

Map 也叫哈希表（Hash tables）。

Map 有两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以。

默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合，你需要显式的引入 import scala.collection.mutable.Map 类

在 Scala 中 你可以同时使用可变与不可变 Map：

// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()
// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

// 空哈希表，默认是可变映射，可以使用 + 号添加 key-value 对;
scala> A += ('I' -> 1)
scala> A
res5: Map[Char,Int] = Map(I -> 1)
//其他的默认非可变，会报错
scala> colors+= ("L" ->"xx")
<console>:23: error: value += is not a member of scala.collection.immutable.Map[String,String]
colors+= ("L" ->"xx")

//判断Map是否为空
scala> colors.isEmpty
res18: Boolean = false
//返回 Map 所有的键(key)
scala> colors.keys
res16: Iterable[String] = Set(red, azure)
//返回 Map 所有的值(value)
scala> colors.values
res17: Iterable[String] = MapLike(#FF0000, #F0FFFF)

2、基本操作

Map的增删（元素和集合），取值或者丢弃值（返回元素，子Map）还有按条件取值或丢弃，最大、最小等基本运算，判断和条件判断（equals、contains、exists），过滤（filter、filterKeys、find）

import scala.collection.mutable.Map
scala> var maps=Map("a"->1,"b"->2,"c"->3,"d"->4,"e"->5)
maps: scala.collection.mutable.Map[String,Int] = Map(e -> 5, b -> 2, d -> 4, a -> 1, c -> 3)

//添加、删除元素，并创建一个新的集合，对于可变不可变均可如此操作，+/-变为+=/-=就是在原集合上增删
//注意：增加时必须是key-value；删除操作只需且仅要key，且可以多个元素的
scala> maps+=("f"->6)
res35: scala.collection.mutable.Map[String,Int] = Map(e -> 5, b -> 2, d -> 4, a -> 1, c -> 3, f -> 6)
scala> maps-=("f")
res42: scala.collection.mutable.Map[String,Int] = Map(e -> 5, b -> 2, d -> 4, a -> 1, c -> 3)
scala> maps+("f"->6,"g"->7)
res57: scala.collection.mutable.Map[String,Int] = Map(b -> 2, d -> 4, g -> 7, a -> 1, c -> 3, f -> 6)

//返回指定 key 的值,可以有get，apply方法，注意返回数据类型不同
scala> maps.get("a")
res61: Option[Int] = Some(1)
scala> maps.apply("b")
res64: Int = 2
scala> maps("c")
res65: Int = 3

//返回丢弃前n个元素新集合,dropWhile(p: ((A, B)) => Boolean): Map[A, B]从左向右丢弃元素，直到条件p不成立
scala> maps.drop(1)
res66: scala.collection.mutable.Map[String,Int] = Map(b -> 2, d -> 4, a -> 1, c -> 3)
//返回丢弃最后n个元素新集合
scala> maps.dropRight(1)
res68: scala.collection.mutable.Map[String,Int] = Map(e -> 5, b -> 2, d -> 4, a -> 1)
//返回所有元素，除了最后一个
scala> maps.init
res74: scala.collection.mutable.Map[String,Int] = Map(e -> 5, b -> 2, d -> 4, a -> 1)
//返回一个集合中除了第一元素之外的其他元素
scala> maps.tail
res89: scala.collection.mutable.Map[String,Int] = Map(b -> 2, d -> 4, a -> 1, c -> 3)
//返回前 n 个元素,takeWhile(p: ((A, B)) => Boolean): Map[A, B] 返回满足指定条件的元素
scala> maps.take(2)
res90: scala.collection.mutable.Map[String,Int] = Map(e -> 5, b -> 2)
//返回后 n 个元素
scala> maps.takeRight(2)
res91: scala.collection.mutable.Map[String,Int] = Map(a -> 1, c -> 3)
//返回最后一个元素
scala> maps.last
res75: (String, Int) = (c,3)
//查找最大最小元素
scala> maps.max
res76: (String, Int) = (e,5)
scala> maps.min
res77: (String, Int) = (a,1)
//移除指定 key
scala> maps.remove("a")
//返回 Map 元素的个数
scala> maps.size
res87: Int = 5

//如果两个 Map 相等(key/value 均相等)，返回true，否则返回false
scala> maps.equals(maps1)
res58: Boolean = true

//判断Map 中是否存在指定 key，返回布尔型
scala> maps.contains("c")
res38: Boolean = true
scala> maps.contains("f")
res39: Boolean = false

//判断集合中指定条件的元素是否存在
scala> maps1.exists(_=="a"->1)
res59: Boolean = true

//返回满足指定条件的所有集合,filter和filterKeys
scala> maps1.filter(_=="a"->1)
res60: scala.collection.mutable.Map[String,Int] = Map(a -> 1)
scala> maps1.filterKeys(_>"a")
res63: scala.collection.Map[String,Int] = Map(e -> 5, b -> 2, d -> 4, c -> 3)

//查找集合中满足指定条件的第一个元素,注意返回值数据类型
scala> maps1.find(_=="a"->1)
res67: Option[(String, Int)] = Some((a,1))

3、常见操作

Map的复制，函数应用，合并和删除，计数count，以及清空返回Map。

//从一个 Map 复制到另一个 Map
scala> var maps1=maps.clone
maps1: scala.collection.mutable.Map[String,Int] = Map(e -> 5, b -> 2, d -> 4, a -> 1, c -> 3)

//将函数应用到集合的所有元素
scala> maps.keys.foreach{i=>
| print(i);maps(i)*=2;println(maps(i))
| }
e10
b4
d8
a2
c6

//Map 合并,可以使用 ++ 运算符或 Map.++() 方法来连接两个 Map，Map 合并时会移除重复的 key
scala> maps++maps1
res74: scala.collection.mutable.Map[String,Int] = Map(e -> 5, b -> 2, d -> 4, a -> 1, c -> 3)

//通过++/--将其他类型的元素添加删除进来，数组集合等皆可
scala> maps++=(Array("f"->6,"g"->7))
res56: scala.collection.mutable.Map[String,Int] = Map(b -> 2, d -> 4, g -> 7, a -> 1, c -> 3, f -> 6)
scala> maps--=(Array("f","g"))
res59: scala.collection.mutable.Map[String,Int] = Map(b -> 2, d -> 4, a -> 1, c -> 3)
scala> maps++=(Set("f"->6,"g"->7))
res60: scala.collection.mutable.Map[String,Int] = Map(b -> 2, d -> 4, g -> 7, a -> 1, c -> 3, f -> 6)

//计算满足指定条件的集合元素个数
scala> maps.count(_=="a"->1)
res35: Int = 1
scala> maps.values.count(_>1)
res36: Int = 4

//清空 Map
scala> maps.clear
scala> maps
res63: scala.collection.mutable.Map[String,Int] = Map()
//返回相同类型的空 Map
scala> maps.empty

4、类型转换

Map和元素转换，转换为字符串，数组，集合，列表，序列。

//复制Map值或者key到数组
scala> var c=Array(5,6,7,8,9);maps.values.copyToArray(c)
c: Array[Int] = Array(5, 2, 4, 1, 3)

//集合所有元素作为字符串显示
scala> maps.mkString
res83: String = e -> 10b -> 4d -> 8a -> 2c -> 6
scala> maps.mkString(",")
res84: String = e -> 10,b -> 4,d -> 8,a -> 2,c -> 6

//转为数组，可变和不可变均可
scala> maps.toArray
res85: Array[(String, Int)] = Array((e,10), (b,4), (d,8), (a,2), (c,6))
scala> maps.toBuffer
res86: scala.collection.mutable.Buffer[(String, Int)] = ArrayBuffer((e,10), (b,4), (d,8), (a,2), (c,6))

//转列表
scala> maps.toList
res87: List[(String, Int)] = List((e,10), (b,4), (d,8), (a,2), (c,6))

//转序列Seq
scala> maps.toSeq
res88: Seq[(String, Int)] = ArrayBuffer((e,10), (b,4), (d,8), (a,2), (c,6))

//转集合Set
scala> maps.toSet
res89: scala.collection.immutable.Set[(String, Int)] = Set((b,4), (d,8), (a,2), (c,6), (e,10))

///返回一个字符串，以对象来表示
scala> maps.toString
res90: String = Map(e -> 10, b -> 4, d -> 8, a -> 2, c -> 6)

四、元组、Option、Iterator迭代器

1、元组

1.1 元组的定义和访问

与列表一样，元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素。

元组的值是通过将单个的值包含在圆括号中构成的。可以用如下两种方式定义：

val t = (1, 3.14, "Fred")
val t = new Tuple3(1, 3.14, "Fred")

元组的实际类型取决于它的元素的类型，访问元组的元素可以通过数字索引，如我们可以使用 t._1 访问第一个元素， t._2 访问第二个元素

scala> val t = (4,3,2,1)
t: (Int, Int, Int, Int) = (4,3,2,1)
scala> val sum = t._1 + t._2 + t._3 + t._4
sum: Int = 10

1.2 元组的操作

迭代元组

元组转为字符串

元素交换

//迭代元组
//可以使用 Tuple.productIterator() 方法来迭代输出元组的所有元素
scala> t.productIterator.foreach{ i =>println("Value = " + i )}
Value = 4
Value = 3
Value = 2
Value = 1

//元组转为字符串
//可以使用 Tuple.toString() 方法将元组的所有元素组合成一个字符串
scala> val t = new Tuple3(1, "hello", Console)
t: (Int, String, Console.type) = (1,hello,scala.Console$@1ad4bd6)
scala> println("连接后的字符串为: " + t.toString() )
连接后的字符串为: (1,hello,scala.Console$@1ad4bd6)

//元素交换
//可以使用 Tuple.swap 方法来交换元组的元素。
scala> val t = new Tuple2("www.google.com", "www.runoob.com")
t: (String, String) = (www.google.com,www.runoob.com)
scala> println("交换后的元组: " + t.swap )
交换后的元组: (www.runoob.com,www.google.com)

2、Option(选项)

2.1 Option(选项)定义

Scala Option(选项)类型用来表示一个值是可选的（有值或无值)。

Option[T] 是一个类型为 T 的可选值的容器： 如果值存在， Option[T] 就是一个 Some[T] ，如果不存在， Option[T] 就是对象 None 。

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("value1")
println(value2) // None

在上面的代码中，myMap 一个是一个 Key 的类型是 String，Value 的类型是 String 的 hash map，但不一样的是他的 get() 返回的是一个叫 Option[String] 的类别。

Scala 使用 Option[String] 来告诉你：「我会想办法回传一个 String，但也可能没有 String 给你」。

myMap 里并没有 key2 这笔数据，get() 方法返回 None。

Option 有两个子类别，一个是 Some，一个是 None，当他回传 Some 的时候，代表这个函式成功地给了你一个 String，而你可以透过 get() 这个函式拿到那个 String，如果他返回的是 None，则代表没有字符串可以给你。

2.2 Option(选项)操作方法

这一块接触不多，以后如果用到的话再详细学习。可以参考

http://www.runoob.com/scala/scala-options.html

3、Iterator（迭代器）

3.1 Iterator（迭代器）定义

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

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

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

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

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

scala> val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
it: Iterator[String] = non-empty iterator
scala> while (it.hasNext){
|    println(it.next())
| }
Baidu
Google
Runoob
Taobao

3.2 Iterator（迭代器）常用方法

Scala Iterator 常用的方法比较多，基本上跟集合数组的方法一样。下面例子为基本用法示例。具体不过多列举：

scala> var ita=Iterator(1,2,3,4,5);var itb=Iterator(10,20,30,40,50)
ita: Iterator[Int] = non-empty iterator
itb: Iterator[Int] = non-empty iterator

scala> println("最大元素是：" + ita.max );println("最小元素是：" + itb.min )
最大元素是：5
最小元素是：10

scala> ita.size
res9: Int = 5
//注意迭代器的特性，再次使用就是空值
scala> ita.size
res10: Int = 0

参考资料：1、《快学scala》

2、http://www.runoob.com/scala/scala-collections.html

3、http://blog.csdn.net/lovehuangjiaju/article/details/46984575