scala数组、Scala Collection(集合)、Iterator(迭代器)

笔记 专栏收录该内容
27 篇文章 0 订阅

一、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

列表转换为字符串

更多方法可参考API文档:https://www.scala-lang.org/api/current/scala/collection/immutable/List.html

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

返回一个字符串,以对象来表示

 

更多方法可参考API文档:https://www.scala-lang.org/api/current/scala/collection/immutable/Set.html

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

返回字符串对象

更多方法可参考API文档:https://www.scala-lang.org/api/current/scala/collection/immutable/Map.html

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,scala.Console$@256216b3)
  }
}

元素交换

可以使用 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 的两个基本操作是 nexthasNext
  • 调用 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 元素一一对应而成的二元组序列

  • 2
    点赞
  • 0
    评论
  • 6
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值