Scala学习（五）

最新推荐文章于 2021-12-23 09:43:12 发布
最新推荐文章于 2021-12-23 09:43:12 发布
阅读量1k 收藏
点赞数
分类专栏： Scala 文章标签： Scala

目录

Scala 数组

声明

处理

多维数组

合并数组

创建区间数组

Scala 数组方法

Scala Collection

List（列表）

列表基本操作

连接列表

List.fill()

List.tabulate()

List.reverse

Scala List 常用方法

Scala Set(集合)

集合基本操作

连接集合

查找集合中最大与最小元素

交集

Scala Set 常用方法

Scala Map(映射)

基本操作

Map 合并

输出 Map 的 keys 和 values

查看 Map 中是否存在指定的 Key

Scala Map 方法

Scala 元组

迭代元组

元组转为字符串

元素交换

Scala Option(选项)

getOrElse() 方法

isEmpty() 方法

Scala Option 常用方法

Scala 数组

声明

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循环进行处理

object Test {
   def main(args: Array[String]) {
      var myList = Array(1.9, 2.9, 3.4, 3.5)
      
      // 输出所有数组元素
      for ( x <- myList ) {
         println( x )
      }

      // 计算数组所有元素的总和
      var total = 0.0;
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println("总和为 " + total);

      // 查找数组中的最大元素
      var max = myList(0);
      for ( i <- 1 to (myList.length - 1) ) {
         if (myList(i) > max) max = myList(i);
      }
      println("最大值为 " + max);
    
   }
}

多维数组

var myMatrix = ofDim[Int](3,3) //实例中数组中包含三个数组元素，每个数组元素又含有三个值。

合并数组

import Array._

object Test {
   def main(args: Array[String]) {
      var myList1 = Array(1.9, 2.9, 3.4, 3.5)
      var myList2 = Array(8.9, 7.9, 0.4, 1.5)

      var myList3 =  concat( myList1, myList2)
      
      // 输出所有数组元素
      for ( x <- myList3 ) {
         println( x )
      }
   }
}

创建区间数组

使用了 range() 方法来生成一个区间范围内的数组。range() 方法最后一个参数为步长，默认为 1

import Array._

object Test {
   def main(args: Array[String]) {
      var myList1 = range(10, 20, 2)
      var myList2 = range(10,20)

      // 输出所有数组元素
      for ( x <- myList1 ) {
         print( " " + x )
      }
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

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（列表）

类似于数组，它们所有元素的类型都相同，但不可变。列表 具有递归的结构（也就是链接表结构）而数组不是。

// 字符串列表
val site: List[String] = List("Runoob", "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 = "Runoob" :: ("Google" :: ("Baidu" :: Nil))

// 整型列表
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))

// 空列表
val empty = Nil

// 二维列表
val dim = (1 :: (0 :: (0 :: Nil))) ::
          (0 :: (1 :: (0 :: Nil))) ::
          (0 :: (0 :: (1 :: Nil))) :: Nil

列表基本操作

  • head 返回列表第一个元素
  • tail 返回一个列表，包含除了第一元素之外的其他元素
  • isEmpty 在列表为空时返回true 
    object Test {
   def main(args: Array[String]) {
      val site = "Runoob" :: ("Google" :: ("Baidu" :: Nil))
      val nums = Nil

      println( "第一网站是 : " + site.head )
      println( "最后一个网站是 : " + site.tail )
      println( "查看列表 site 是否为空 : " + site.isEmpty )
      println( "查看 nums 是否为空 : " + nums.isEmpty )
   }
}

     

连接列表

使用 ::: 运算符或 List.:::() 方法或 List.concat() 方法

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

      // 使用 ::: 运算符
      var fruit = site1 ::: site2
      println( "site1 ::: site2 : " + fruit )
      
      // 使用 List.:::() 方法
      fruit = site1.:::(site2)
      println( "site1.:::(site2) : " + fruit )

      // 使用 concat 方法
      fruit = List.concat(site1, site2)
      println( "List.concat(site1, site2) : " + fruit  )
      

   }
}

List.fill()

创建一个指定重复数量的元素列表

object Test {
   def main(args: Array[String]) {
      val site = List.fill(3)("Runoob") // 重复 Runoob 3次
      println( "site : " + site  )

      val num = List.fill(10)(2)         // 重复元素 2, 10 次
      println( "num : " + num  )
   }
}

List.tabulate()

通过给定的函数来创建列表，第一个参数为元素的数量，可以是二维的，第二个参数为指定的函数，我们通过指定的函数计算结果并返回值插入到列表中，起始值为 0

object Test {
   def main(args: Array[String]) {
      // 通过给定的函数创建 5 个元素
      val squares = List.tabulate(6)(n => n * n)
      println( "一维 : " + squares  )

      // 创建二维列表
      val mul = List.tabulate( 4,5 )( _ * _ )       // _ _行号和列号   
      println( "多维 : " + mul  )
   }
}

List.reverse

反转列表

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

列表转换为字符串

Scala Set(集合)

 没有重复的对象集合，所有的元素都是唯一的。集合分为可变的和不可变的集合。

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

  • 默认引用 scala.collection.immutable.Set，不可变集合
val set = Set(1,2,3)
println(set.getClass.getName) // 

println(set.exists(_ % 2 == 0)) //true
println(set.drop(1)) //Set(2,3)
  • 可变集合需要引入 scala.collection.mutable.Set：
import scala.collection.mutable.Set // 可以在任何地方引入 可变集合

val mutableSet = Set(1,2,3)
println(mutableSet.getClass.getName) // scala.collection.mutable.HashSet

mutableSet.add(4)
mutableSet.remove(1)
mutableSet += 5
mutableSet -= 2

println(mutableSet) // Set(5, 3, 4)

val another = mutableSet.toSet
println(another.getClass.getName) // scala.collection.immutable.Set

虽然可变Set和不可变Set都有添加或删除元素的操作，但是有一个非常大的差别。对不可变Set进行操作，会产生一个新的set，原来的set并没有改变，这与List一样。 而对可变Set进行操作，改变的是该Set本身，与ListBuffer类似。

集合基本操作

  • head 返回集合第一个元素
  • tail 返回一个集合，包含除了第一元素之外的其他元素
  • isEmpty 在集合为空时返回true
object Test {
   def main(args: Array[String]) {
      val site = Set("Runoob", "Google", "Baidu")
      val nums: Set[Int] = Set()

      println( "第一网站是 : " + site.head )
      println( "最后一个网站是 : " + site.tail )
      println( "查看列表 site 是否为空 : " + site.isEmpty )
      println( "查看 nums 是否为空 : " + nums.isEmpty )
   }
}

连接集合

使用 ++ 运算符或 Set.++() 方法，移除重复元素

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

      // ++ 作为运算符使用
      var site = site1 ++ site2
      println( "site1 ++ site2 : " + site )

      //  ++ 作为方法使用
      site = site1.++(site2)
      println( "site1.++(site2) : " + site )
   }
}

查找集合中最大与最小元素

Set.min 方法、Set.max 方法

object Test {
   def main(args: Array[String]) {
      val num = Set(5,6,9,20,30,45)

      // 查找集合中最大与最小元素
      println( "Set(5,6,9,20,30,45) 集合中的最小元素是 : " + num.min )
      println( "Set(5,6,9,20,30,45) 集合中的最大元素是 : " + num.max )
   }
}

交集

Set.& 方法或 Set.intersect 方法

object Test {
   def main(args: Array[String]) {
      val num1 = Set(5,6,9,20,30,45)
      val num2 = Set(50,60,9,20,35,55)

      // 交集
      println( "num1.&(num2) : " + num1.&(num2) )
      println( "num1.intersect(num2) : " + num1.intersect(num2) )
   }
}

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

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

Scala Map(映射)

Map(映射)，也叫哈希表（Hash tables），是一种可迭代的键值对（key/value）结构。所有的值都可以通过键来获取。且键唯一。

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")

基本操作

方法描述
keys返回 Map 所有的键(key)
values返回 Map 所有的值(value)
isEmpty在 Map 为空时返回true
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 )
   }
}

Map 合并

使用 ++ 运算符或 Map.++() 方法

object Test {
   def main(args: Array[String]) {
      val colors1 = Map("red" -> "#FF0000",
                        "azure" -> "#F0FFFF",
                        "peru" -> "#CD853F")
      val colors2 = Map("blue" -> "#0033FF",
                        "yellow" -> "#FFFF00",
                        "red" -> "#FF0000")

      //  ++ 作为运算符
      var colors = colors1 ++ colors2
      println( "colors1 ++ colors2 : " + colors )

      //  ++ 作为方法
      colors = colors1.++(colors2)
      println( "colors1.++(colors2)) : " + colors )

   }
}

输出 Map 的 keys 和 values

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

      sites.keys.foreach{ i =>  
                           print( "Key = " + i )
                           println(" Value = " + sites(i) )}
   }
}

查看 Map 中是否存在指定的 Key

使用 Map.contains 

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

返回字符串对象

Scala 元组

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

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

元组的实际类型取决于它的元素的类型，可以使用 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 )
   }
}

迭代元组

使用 Tuple.productIterator() 方法

object Test {
   def main(args: Array[String]) {
      val t = (4,3,2,1)
      
      t.productIterator.foreach{ i =>println("Value = " + i )}
   }
}

元组转为字符串

使用 Tuple.toString() 方法

object Test {
   def main(args: Array[String]) {
      val t = new Tuple3(1, "hello", Console)
      
      println("连接后的字符串为: " + t.toString() )
   }
}

元素交换

使用 Tuple.swap 方法

object Test {
   def main(args: Array[String]) {
      val t = new Tuple2("www.google.com", "www.runoob.com")
      
      println("交换后的元组: " + t.swap )
   }
}

Scala Option(选项)

Scala Option(选项)类型用来表示一个值是可选的（有值或无值)。Option[T] 是一个类型为 T 的可选值的容器： 如果值存在， Option[T] 就是一个 Some[T] ，如果不存在， Option[T] 就是对象 None 。

// 虽然 Scala 可以不定义变量的类型，不过为了清楚些，我还是
// 把他显示的定义上了
 
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

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

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

object Test {
   def main(args: Array[String]) {
      val sites = Map("runoob" -> "www.runoob.com", "google" -> "www.google.com")
      
      println("sites.get( \"runoob\" ) : " +  sites.get( "runoob" )) // Some(www.runoob.com)
      println("sites.get( \"baidu\" ) : " +  sites.get( "baidu" ))  //  None
   }
}

通过模式匹配来输出匹配值

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

getOrElse() 方法

获取元组中存在的元素或者使用其默认的值

object Test {
   def main(args: Array[String]) {
      val a:Option[Int] = Some(5)
      val b:Option[Int] = None 
      
      println("a.getOrElse(0): " + a.getOrElse(0) )
      println("b.getOrElse(10): " + b.getOrElse(10) )
   }
}

isEmpty() 方法

检测元组中的元素是否为 None

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。

 

 

 

 

 

 

 

 

 

Echo_y_q
关注
专栏目录
180125_scala笔记1
qq_38382397的博客
01-26 318
HelloWorld.scala[与对象名一致] object HelloWorld[首字母大写，驼峰] class MyFirstScalaClass[首字母大写，驼峰] def myMethodName()[首字母小写，驼峰] def main(args: Array[String])[入口函数，格式固定] package com.runoob {//包中含有的类   cl
Scala学习（一）
qq_42337039的博客
03-02 2471
Scala基础语法 Scala与Java的最大区别是：Scala语句末尾的分号是可选的 我们可以认为Scala程序是对象的集合，通过调用彼此的方法来实现消息传递，理解类，对象，方法，实例变量的概念 对象：对象有属性和行为，对象是一个类的实例 类：类是对象的抽象，而对象是类的具体实例 方法：方法描述的基本的行为，一个类可以包含多个方法 字段：每个对象都有它唯一的实例变量集合，即字段，对象的属性通过给字段赋值来创建 交互式编程 脚本形式 创建一个HelloWorld.scala的文件来执行代码 objec
Scala常用语法
stone_tomcate的博客
12-23 326
## 2、变量和常量 ~~~~scala object TestVar { def main(args: Array[String]): Unit = { // 1 ）声明变量时，类型可以省略，编译器 自动推导，即类型推导 var age = 18 age = 30 // 2 ）类型确定后，就不能修改，说明 Scala 是强数据类型语言。 // age = "tom" // 错误 // 3 ）变量声明时，必须要 有 初始值 // var na...
Scala学习初步
蕉下客
07-13 263
Scala基础语法入门实战首先，参照相关攻略，在Linux下分别下载安装Java、Scala，然后配置Java和Scala环境变量。安装完毕，在终端敲入scala即可进入Scala命令行，如下所示：root@Master:~# scalaWelcome to Scala version 2.10.4 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_66
scala方法练习
多哥仁慈的骆驼
04-16 416
package com.gsau.util.Chapter5import java.io.IOException/**  * 方法的默认权限是public  * private[this]   对当前实例可见  * private         对当前类的所有实例可见  * protected       对当前类及其子类的实例可见  * private[packageName]  对packa...
Scala04
liweihope的博客
05-07 287
1.关于s…$ 一般我们要输出，什么东西直接这样写： object StringApp { def main(args: Array[String]): Unit = { val name = "zhangsan" println("name : " + name) //这个地方直接 +name } } 但是上面这种写法，不友好 在scala中有种叫做 字符串插值 ...
Scala学习笔记（二）
AidenBrett7的博客
11-08 321
Scala学习笔记（）1. 类和对象1.1 创建类和对象1.2 简写方式2. 定义和访问成员变量3. 使用下划线初始化成员变量4. 定义成员方法5. 访问修饰符6. 类的构造器6.1 主构造器6.2 辅助构造器7. 单例对象（Object）7.1 定义单例对象7.2 在单例对象中定义成员方法7.3 工具类案例8. main方法8.1 定义main方法8.2 实现App Trait来定义入口9. 伴...
Scala入门学习教程.docx
最新发布
09-22
知识点五：Scala 语言的 import 语句 Scala 语言的 import 语句与 Java 语言非常相似，但有一些重要的区别。例如，Scala 语言可以使用大括号来导入同一个包里的多个类，而 Java 语言则需要使用星号（*）来导入所有...
Scala学习
05-30 316
Scala程序结构 1.Object是一个关键字，表示一个伴生对象； 2.如该文件只出现了一个object HelloScala 就会在编译后两个 .class文件； 3.第一个文件是HelloScala.class这个表示他的伴生类，但是空的； 4.第二个文件是HelloScala$.class对应的是Object HelloScala，但是本质是调用但是本质调用它对应的一个静态 属性MODULE$ 5.这两个文件的关系和main函数 object HelloScala { // 1. d.
Scala学习之运算符
M_Ene的学习日志
06-17 196
算术运算符 基本语法 对于除号"/"，他的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。 对于一个数取模a%b，和Java的取模规则一样 package com.gm.chapter02 /** * @Author: Gm * @Date: 2021/6/17 9:33 */ object TestOperator { def main(args: Array[String]): Unit = { //对于除号“/”，他的整数除和小数除是有区别的
Programming.in.Scala.pdf
08-04
根据提供的文件信息，以下是从标题、描述、标签以及部分内容中提炼的知识点： ...此外，书中对于Scala与Java的对比分析，以及对Scala标准库的介绍，都极大地帮助读者在学习过程中把握Scala的特点和优势。
Scala学习笔记五：变长参数
一壶清茶的专栏
03-11 228
1.变长参数 在scala中，有时需要将函数定义为参数个数可变的形式，则此时便可使用变长参数来定义函数 def sum(nums:Int*)={ var res = 0 for(num <- nums){ res += num } res } [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ObX8JxHJ-1615420958809)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-202
idea 警告can not find the method of println
Dan的博客
10-31 1868
话不多说直接上图 转载自——https://stackoverflow.com/questions/3914139/intellij-9-unable-to-recognize-implicit-object-methods-in-jsps
Scala - error: not found: value SortedMap
weixin_33794672的博客
01-20 671
先 IMPORT!!!! scala> import scala.collection._import scala.collection._ scala> SortedMap("2"->"jx","1"->"hxf","3"->"hl")res0: scala.collection.SortedMap[String,String] = Map(1 -&gt...
运行spark时出现：<console>:10: error: not found: value sc
热门推荐
Mr Zhu's little cute
08-06 1万+
运行spark时出现：:10: error: not found: value sc 出现错误的界面如下图所示： **描述：明明早上以及前几天都用得好好的，下午就频频报错，网上的解决方法挺少，不过，发现了个网站的方法挺齐全。链接如下：最详细的解决方法 当然，这几个方法并不适用于我的，毕竟我出错的地方实在是由于本人的马大哈造成的。 最后的解决方法： 我打开的scala是scla路径下的Scala，...
error: not found: value SparkSession
微电子学与固体电子学-俞驰
05-05 3559
报错如下 ： error: not found: value SparkSession 解决方案: import org.apache.spark.sql.SparkSession
maven 打包scala报错问题：error: not found: object xxx
祁东握力的博客
05-13 1492
我的完整报错是：E:\daydayup\spark\src\main\scala\com\tt\KafkaSparkStreamTest.scala:3: error: not found: object kafka 就这些信息根本看不出啥。。还是靠百度，找到一篇资料说是maven仓库移动一下，然后他的文章中我看他的仓库是从路径有中文的移动到了全英文的路径下。。然后就没问题了，我也移动了maven仓库到英文路径下，然后idea setting重新设置仓库位置为英文下的那个，然后就成功了。，，可气.
在Spark-shell中写程序出现error:not found :value StorageLevel
说文科技，做有态度的研究。
04-10 5148
1.具体环境如下： 在Centos 6.5系统，使用Spark-shell编写Scala程序，使用RDD的persist方法时，出现报错如下： &lt;console&gt;:27: error: not found: value StorageLevel 2.可能有两种错误原因 对象并非RDD，而只是一个普通的变量 没有导入Spark的程序包，所以导致无法加载出StorageLevel...
Spark报错：error: not found: value metrics
Mr Zhu's little cute
06-01 1142
跑一下代码： import org.apache.spark.ml.linalg.{Vector, Vectors} import org.apache.spark.ml.stat.Summarizer val data = Seq( (Vectors.dense(2.0, 3.0, 5.0), 1.0), (Vectors.dense(4.0, 6.0, 7.0), 2.0) ) val df = data.toDF("features", "weight") val (meanVal,
Scala学习与Docker公益讲堂：王家林老师带你探索大数据云开发
Scala学习相关 在大数据时代，Scala已经成为了一个备受瞩目的编程语言，尤其在云计算和容器化技术中发挥着重要作用。随着Docker的崛起，其在现代软件开发中的地位日益凸显。在这个背景下，云计算Docker虚拟化公益大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值