scala 入门（3）

学习笔记（三）

Scala元组、集合、数组和迭代器

Scala元组

在Scala中，元组是一个可以容纳不同类型元素的类。元组是不可变的。

元组的最大长度是22。当我们需要从函数返回多个类型的多个值时，元组会派上用场。

创建元组的方式

// 方式1
val ingredient = ("Sugar" , 25):Tuple2[String, Int]
// 方式2
val ingredient1 = (1, 3.14, "Fred") 
// 方式3
val ingredient2 = new Tuple3(1, 3.14, "Fred")

元组的访问

println(ingredient._1) // Sugar

println(ingredient._2) // 25

解构（Pattern matching 直译模式匹配）元组数据

样例1

val (name, quantity) = ingredient
println(name) // Sugar
println(quantity) // 25

样例2(高级用法)

val planets =
  List(("Mercury", 57.9), ("Venus", 108.2), ("Earth", 149.6),
       ("Mars", 227.9), ("Jupiter", 778.3))
planets.foreach{
  case ("Earth", distance) =>
    println(s"Our planet is $distance million kilometers from the sun")
  case _ =>
}

val numPairs = List((2, 5), (3, -7), (20, 56))
for ((a, b) <- numPairs) {
  println(a * b)
}

主要方法

元组对象自带几个方法

可以使用 Tuple.productIterator() 方法来迭代输出元组的所有元素

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

可以使用 Tuple.swap 方法来交换元组的元素

数组

Scala 语言中提供的数组是用来存储固定大小的同类型元素，数组对于每一门编辑应语言来说都是重要的数据结构之一。

Scala 的数组和java的数组差别不大

数组定义

数组操作

和别的语言没啥差别，使用索引选择数组内元素

数组方法

序号	方法	描述
1	def apply( x: T, xs: T* ): Array[T]	创建指定对象 T 的数组
2	def concatT: 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 iterateT( f: (T) => T ): Array[T]	返回指定长度数组，每个数组元素为指定函数的返回值
6	更多请查看api	……

(Scala Array API)[https://www.scala-lang.org/api/current/scala/Array.html]

集合

Scala集合是scala提供的集合实现，不同于java的集合实现，Scala的集合实现有一些特殊的方法，而且构造也和标准的java集合不同 Scala的集合分为可变（mutable）和不可变（immutable）集合

可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。

而不可变集合类，相比之下，永远不会改变。不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。

Scala List

注意哦，和java不同，List不是java里面的接口，List不是Scala里的train，而是集合的实现，一种不可变集合，Scala里面还有别的list，但是没有ArrayList，有LinkedList双链列表。

常用方法

反序 .reverse()
填充 .fill(次数)(填充元素)
通过索引获取元素
过滤
排序
转换
查找
迭代

Scala是多范式语言，Scala是支持函数式编程，而且支持程度非常高。比jdk8的steam化更彻底。

Scala Set

Set在Scala中有可变的和不可变的两种。 注意，Set是Train不是具体实现，但是由于存在类型推倒能力，可以直接使用Set而不指定具体的实现类。 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类似。

Scala 集合有三个基本操作

head 返回集合第一个元素
tail 返回一个集合，这个集合包含除第一个的其他元素
isEmpty 判断集合是否为空

Scala里面，集合可以使用运算符号的，比如 +、-、++

Scala Map

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

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

Map 中的键都是唯一的。 Map 有两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以。

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

在 Scala 中你可以同时使用可变与不可变 Map，不可变的直接使用 Map，可变的使用 mutable.Map。以下实例演示了不可变 Map 的应用：

// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()

// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

Scala Map 有三个基本操作:

keys 返回Map所有的键（key）
values 返回Map所有的值（value）
isEmpty 在Map为空时返回true

Scala Option

这个概念和jdk1.8之后引入的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 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())
      }
   }
}

学习笔记 （三）