一、Collection
文件地址：https://www.w3cschool.cn/scaladevelopmentguide
| 序号 | 集合及描述 |
|---|---|
| 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
val x = Set(1,3,5,7)
// 定义 Map
val x = Map("one" -> 1, "two" -> 2, "three" -> 3)
// 创建两个不同类型元素的元组
val x = (10, "tom")
// 定义 Option
val x:Option[Int] = Some(5)
1. List
创建列表
scala> val days = List("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday")
days: List[String] = List(Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday)
创建空列表
val l = Nil
l: scala.collection.immutable.Nil.type = List()
scala> val l = List()
l: List[Nothing] = List()
用字符串创建列表
scala> val l = "Hello" :: "Hi" :: "Hah" :: "WOW" :: "WOOW" :: Nil
l: List[String] = List(Hello, Hi, Hah, WOW, WOOW)
用“:::”叠加创建新列表
scala> val wow = l ::: List("WOOOW", "WOOOOW")
wow: List[String] = List(Hello, Hi, Hah, WOW, WOOW, WOOOW, WOOOOW)
通过索引获取列表值
scala> l(3)
res0: String = WOW
获取值长度为3的元素数目
scala> l.count(s => s.length == 3)
res1: Int = 2
返回去掉l头两个元素的新列表
scala> l.drop(2)
res2: List[String] = List(Hah, WOW, WOOW)
scala> l
res3: List[String] = List(Hello, Hi, Hah, WOW, WOOW)
返回去掉l后两个元素的新列表
scala> l.dropRight(2)
res5: List[String] = List(Hello, Hi, Hah)
scala> l
res6: List[String] = List(Hello, Hi, Hah, WOW, WOOW)
判断l是否存在某个元素
scala> l.exists(s => s == "Hah")
res7: Boolean = true
滤出长度为3的元素
scala> l.filter(s => s.length == 3)
res8: List[String] = List(Hah, WOW)
判断所有元素是否以“H”打头
scala> l.forall(s => s.startsWith("H"))
res10: Boolean = false
判断所有元素是否以“H”结尾
scala> l.forall(s => s.endsWith("W"))
res11: Boolean = false
打印每个元素
scala> l.foreach(s => print(s + ' '))
Hello Hi Hah WOW WOOW
取出第一个元素
scala> l.head
res17: String = Hello
取出最后一个元素
scala> l.last
res20: String = WOOW
剔除最后一个元素，生成新列表
scala> l.init
res18: List[String] = List(Hello, Hi, Hah, WOW)
剔除第一个元素，生成新列表
scala> l.tail
res49: List[String] = List(Hi, Hah, WOW, WOOW)
判断列表是否为空
scala> l.isEmpty
res19: Boolean = false
获得列表长度
scala> l.length
res21: Int = 5
修改每个元素，再反转每个元素形成新列表
scala> l.map(s => {val s1 = s + " - 01"; s1.reverse})
res29: List[String] = List(10 - olleH, 10 - iH, 10 - haH, 10 - WOW, 10 - WOOW)
生成用逗号隔开的字符串
scala> l.mkString(", ")
res30: String = Hello, Hi, Hah, WOW, WOOW
反序生成新列表
scala> l.reverse
res41: List[String] = List(WOOW, WOW, Hah, Hi, Hello)
按字母递增排序
scala> l.sortWith(_.compareTo(_) < 0)
res48: List[String] = List(Hah, Hello, Hi, WOOW, WOW)
2. Set
Scala Set(集合)是没有重复的对象集合，所有的元素都是唯一的。
Scala 集合分为可变的和不可变的集合。
默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包。
默认引用 scala.collection.immutable.Set。
创建Set
scala> val a=Set(1,1,2,3)
a: scala.collection.immutable.Set[Int] = Set(1, 2, 3)
添加元素
scala> a+(4)
res119: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)
scala> a++List(5,6)
res121: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3)
注意： 虽然可变Set和不可变Set都有添加或删除元素的操作，但是有一个非常大的差别。对不可变Set进行操作，会产生一个新的set，原来的set并没有改变，这与List一样。 而对可变Set进行操作，改变的是该Set本身，与ListBuffer类似。
需要注意的是，加了一些元素之后，对于a是否会变化。主要到scala.collection.immutable
初始化
scala> val mutableSet =Set(1,2,3)
mutableSet: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
加元素
scala> mutableSet+(4)
res141: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
scala> mutableSet
res142: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
scala> mutableSet.add(4)
res143: Boolean = true
scala> mutableSet
res144: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
删除元素
scala> mutableSet-(4)
res146: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
scala> mutableSet
res147: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
scala> mutableSet.remove(4)
res148: Boolean = true
scala> mutableSet
res149: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
| 序号 | 方法及描述 | |
|---|---|---|
| 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 中的键都是唯一的。
Map 也叫哈希表（Hash tables）。
Map 有两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以。
默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合，你需要显式的引入 import scala.collection.mutable.Map 类
在 Scala 中 你可以同时使用可变与不可变 Map，不可变的直接使用 Map，可变的使用 mutable.Map。
// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()
// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")
示例：
···
object Test {
def main(args: Array[String]) {
val colors = Map("red" -> "#FF0000",
"azure" -> "#F0FFFF",
"peru" -> "#CD853F")
val nums: Map[Int, Int] = Map()
println( "colors 中的键为 : " + colors.keys )
println( "colors 中的值为 : " + colors.values )
println( "检测 colors 是否为空 : " + colors.isEmpty )
println( "检测 nums 是否为空 : " + nums.isEmpty )
}
}
···
4. Seq序列
创建Seq:
val s1 = Seq(1,2,3,4,5)
val s2 = Seq(6,7,8,9,10)
// 获取某个下标的值
索引和长度
scala> val s1=Seq(1,2,3)
s1: Seq[Int] = List(1, 2, 3)
scala> s1(1)
res0: Int = 2
scala> print(s1(1))
2
// 是否包括该下标，下标从0开始
scala> s1.isDefinedAt(1)
res2: Boolean = true
// seq长度，结果:res0: Int = 5
s1.length
// seq长度比n大则返回+1，比n少则返回-1，=n则返回0
s1.lengthCompare(5)
// 返回0--(s1.length-1) 的Range
// 结果: res0: scala.collection.immutable.Range = Range 0 until 5
s1.indices
查询下标
//查询元素1所在的下标
//结果 res0: Int = 0
s1.indexOf(1)
//查找该元素的最后一个索,res0: Int = 2
val s3 = Seq(1,2,2,4,5,2,2,4)
s3.lastIndexOf(2)
//右边seq在左边seq的开始匹配索引
//结果:res0: Int = 1
val s4 = Seq(2,2,4)
s3.indexOfSlice(s4)
////右边seq在左边seq的最后匹配索引
//结果:res0: Int = 5
s3.lastIndexOfSlice(s4)
//查找第一个满足条件的索引
//结果:res0: Int = 3
s3.indexWhere(_ > 2)
//从seq(n)开始，连续满足条件的个数
//结果:res0: Int = 2
s3.segmentLength(_ > 2,3)
//从seq(0)开始，连续满足条件的个数
//res0: Int = 8
s3.prefixLength(_ > 0)
添加
//把n加入到集合在头部
//结果：res0: Seq[Int] = List(6, 1, 2, 3, 4, 5)
6 +: s1
//把n加到集合后面
//结果:res0: Seq[Int] = List(1, 2, 3, 4, 5, 6)
s1 :+ 6
//第一个参数len,第二个参数value,如果集合长度达<len,则将集合扩展到len,并用value填充。否则什么都不做
//结果:res0: Seq[Int] = List(1, 2, 3, 4, 5, 2, 2)
s1 padTo (7,2)
更新
// 从下标为2[index]的元素开始，用集合s2所有元素替换掉1[n]个数。
// 结果:res0: Seq[Int] = List(1, 2, 6, 7, 8, 9, 10, 4, 5)
s1.patch(2,s2,1)
// 更新下标i的值
// 结果:res0: Seq[Int] = List(1, 2, 10, 4, 5)
s1.updated(2,10)
排序
val s3 = Seq(4,2,5,8,3,0)
//按自然升序排
//结果:res0: Seq[Int] = List(0, 2, 3, 4, 5, 8)
s3.sorted
//按自定义函数排序
//结果:res0: Seq[Int] = List(8, 5, 4, 3, 2, 0)
s3.sortWith((x,y) => x > y)
//从大到小,结果:res0: Seq[Int] = List(8, 5, 4, 3, 2, 0)
s3.sortBy(x => -x)
//从小到大，结果:res0: Seq[Int] = List(0, 2, 3, 4, 5, 8)
s3.sortBy(x => x)
反转
//把集合反转，结果:res0: Seq[Int] = List(5, 4, 3, 2, 1)
s1.reverse
//返回反转后的集合迭代器
//结果:54321
val it = s1.reverseIterator
while (it.hasNext) {
print(it.next())
}
//反转集合，按指定函数进行map
//结果:res0: Seq[Int] = List(6, 5, 4, 3, 2)
s1.reverseMap(x => x + 1)
比较
val s3 = Seq(1,2,3)
//判断是否以另一个集合开始,元素和顺序一致
//结果:res0: Boolean = true
s1.startsWith(s3)
//判断是否以另一个集合结尾，元素和顺序一致
//结果:res0: Boolean = true
val s4 = Seq(3,4,5)
s1.endsWith(s4)
//判断集合是否包含某个元素
//结果:res0: Boolean = true
s1.contains(2)
//判断是否包含另一个集合的连续字段
//结果:res0: Boolean = true
s1.containsSlice(s3)
//判断两个集合长度，按下标遍历，满足输入函数的返回true，不满足的返回false
//结果:res0: Boolean = true
val s5 = Seq(1,2,3,4,5)
s1.corresponds(s5)((x,y)=>x == y)
多集合操作
val s3 = Seq(0,1,2,3,4)
//获取两个集合的交集
//结果:res0: Seq[Int] = List(1, 2, 3, 4)
s1.intersect(s3)
//获取第一个集合有，第二个集合没有的
//结果:res0: Seq[Int] = List(5)
s1.diff(s3)
//两个集合合并
//结果：res0: Seq[Int] = List(1, 2, 3, 4, 5, 0, 1, 2, 3, 4)
s1.union(s3)
//集合去重
//结果:res0: Seq[Int] = List(1, 2, 3, 4)
val s4 = Seq(1,1,2,3,2,3,4)
s4.distinct
可变集合 添加
// 必须导入mutable包
import scala.collection.mutable
scala> import scala.collection.mutable
import scala.collection.mutable
scala> val buffer = mutable.Buffer(1,2,3,4,5)
buffer: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)
val buffer = mutable.Buffer(1,2,3,4,5)
val b2 = mutable.Buffer(7,8)
//向buffer增加一个元素
//结果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6)
buffer += 6
//向buffer增加几个元素
//结果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 7, 8, 9)
buffer += (7,8,9)
//添加集合
//结果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 7, 8)
buffer ++= b2
//把元素放在集合头部
//结果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(6, 1, 2, 3, 4, 5)
6 +=: buffer
//把集合放buffer头部
//结果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(7, 8, 1, 2, 3, 4, 5)
b2 ++=: buffer
//在下标i，插入元素
//结果:1210345
buffer.insert(2,10)
//从下标开始插入整个数组
//结果:12789345
val arr = Array(7,8,9)
buffer.insertAll(2,arr)
可变集合 删除
val s3 = Seq(0,1,2,3,4)
//获取两个集合的交集
//结果:res0: Seq[Int] = List(1, 2, 3, 4)
s1.intersect(s3)
//获取第一个集合有，第二个集合没有的
//结果:res0: Seq[Int] = List(5)
s1.diff(s3)
//两个集合合并
//结果：res0: Seq[Int] = List(1, 2, 3, 4, 5, 0, 1, 2, 3, 4)
s1.union(s3)
//集合去重
//结果:res0: Seq[Int] = List(1, 2, 3, 4)
val s4 = Seq(1,1,2,3,2,3,4)
s4.distinct
Scala的Seq将是Java的List，Scala的List将是Java的LinkedList。
5. range()
scala> (1 to 10).toList
res3: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
6. Tuple元组
元组是不同类型的值的集合
// 简单Tuple
val t = ("yxj", 30) // Tuple2
println(t._1) // 访问Tuple中的数据，从1开始，带上下划线
println(t._2)
val student = new Tuple3(1, "yxj", 30) // Tuple3
println(student)
//zip操作
val names = Array("t", "tt", "ttt")
val ages = Array(10, 20, 30)
val nameAges = names.zip(ages)
println(nameAges) // [Lscala.Tuple2;@13deb50e
println(nameAges.mkString(",")) // (t,10),(tt,20),(ttt,30)
// 增强for循环
for ((name, age) <- nameAges) {
println("name=" + name + ",age=" + age)
}
val students = Array((1, "yxj", 30), (2, "yxj2", 32), (3, "yxj3", 33))
for ((id, name, age) <- students) {
println("id=" + id + ",name=" + name + ",age=" + age)
}
二、Iterator（迭代器）
Scala Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法。
迭代器 it 的两个基本操作是 next 和 hasNext。
调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。
调用 it.hasNext() 用于检测集合中是否还有元素。
让迭代器 it 逐个返回所有元素最简单的方法是使用 while 循环：
bject Test {
def main(args: Array[String]) {
val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
while (it.hasNext){
println(it.next())
}
}
}
三、集合操作符
:: +: :+ ++ ++: :::
这些符号全都是连接的作用，将元素与集合、集合与集合相连接。
::操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于9 :: (5 :: (2 :: Nil))。所以:: +: :::这些操作符都是在前面插入（ ++: 除外）。:+ ++ ++:这些是追加、拼接。
| 符号 | 操作 | 结果 | 位置解释 |
|---|---|---|---|
| :: | a :: b | List(List(1, 2, 3), 4, 5, 6) | 前插 把a当成一个元素，前插到b集合 |
| +: | a +: b | List(List(1, 2, 3), 4, 5, 6) | 前插 同上 |
| :+ | a :+ b | List(1, 2, 3, List(4, 5, 6)) | 后插 把b当成一个元素，后插到a集合 |
| ++ | a ++ b | List(1, 2, 3, 4, 5, 6) | 拼接 a和b集合顺序合并 |
| ++: | a ++:b | List(1, 2, 3, 4, 5, 6) | 拼接 同上 |
| ::: | a::::b | List(1, 2, 3, 4, 5, 6) | 拼接 同上 |
scala> val a = List(1,2,3)
a: List[Int] = List(1, 2, 3)
scala> val b = List(4,5,6)
b: List[Int] = List(4, 5, 6)
scala> a :: b
res20: List[Any] = List(List(1, 2, 3), 4, 5, 6)
网友评论