Scala从入门到放弃（三）Scala的数组、映射、元组和集合

1.数组

1.1定长数组和变长数组

object ArrayDemo {
  def main(args: Array[String]): Unit = {
    //初始化一个长度为8的定长数组，其数组元素均为0
    val arr1 = new Array[Int](8)
    //直接打印定长数组，内容为数组的hashcode值
    println(arr1)
    //将数组转换成数组缓冲，就可以看到原数组中的内容了
    //toBuffer会将数组转成数组缓冲
    println(arr1.toBuffer)

    //注意：如果new ，相当于调用了数组的apply方法，直接为数组赋值
    //初始化一个长度为1的定长数组
    val arr2 = Array[Int](10)
    println(arr2.toBuffer)
    println(arr2(0)) //相当于只是填入了Array

    //定义一个长度为3的定长数组
    val arr3 =Array("hadoop","storm","spark")
    //使用（）来访问元素
    println(arr3(1)) //运行结果:storm 下标从0开始

    println("==================变长数组=====================")

    val ab = ArrayBuffer[Int]()
    //向数组缓冲的尾部追加一个元素
    //+=尾部追加元素
    ab+=1
    //追加多个元素
    ab+=(2,3,4,5)
    //追加一个数组 ++=
    ab ++= Array(6,7)
    //追加一个数组缓冲
    ab ++=ArrayBuffer(8,9)

    //打印数组缓冲ab
    println(ab)
    //下标为 0~1之间插入 0
    ab.insert(1,0,3,5,7,9) //运行结果:在下标为1的位置插入0 3 5 7 9
    //删除数组某个位置的元素用remove 后面的2 为remove 下标为8  9 两个元素 游标
    ab.remove(8,2)
    println(ab)

  }

}

运行结果

1.2 遍历数组

• 增强for循环
• 好用的until会生成脚标， 0 until 10 包含0不包含10
  
  

    println("==================遍历数组=====================")

    //初始化一个数组
    val array1 = Array(1,2,3,4,5,6,7,8)
    //增强for循环
    for (i <- array1)
      print(i+"\t")
    println()

    //好用的until会生成一个Range
    //reverse是将前面生成的Range反转
    for (i <- (0 until array1.length).reverse)
      print(i+"\t")

1.3 数组转换

yield 关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变

object ArrayYieldDemo {
  def main(args: Array[String]): Unit = {
    //定义一个数组
    val arr =Array(1,2,3,4,5,6,7,8,9)
    //将偶数取出乘以10后再生成一个新的数组
    val res = for(e <- arr if e % 2==0 ) yield e * 10
    println(res.toBuffer)

    //更高级的写法,用着更爽
    //filter是过滤器，接受一个返回值boolean的函数
    //map相当于将数组中的每一个元素取出来，应用传进去的函数

    val r = arr.filter(_ % 2 ==0).map(_*10)
    println(r.toBuffer)
  }
}

1.4 常用数组的算法

在Scala中，数组上的某些方法对数组进行相应的操作非常方便！

2 映射（Map）

在Scala中，把哈希表这种数据结构叫做映射

2.1 构建映射

2.2 获取和修改映射中的值

好用的getorElse



注意：在Scala中，有两个Map，一个是immutable包下的Map，该Map中的内容不可变，另一个是mutable包下的Map，该Map中的内容可变

注意：通常我们在创建一个集合时会用val这个关键字修饰一个变量（相当于java中的final）,那么就意味着变量的引用不可变，该引用的内容是不是可变的，取决于这个引用指向的集合的类型

2.3 将对偶的集合转换成映射

3 元组

映射是k/v对偶的集合，对偶是元组的最简单的形式，元组可以装着多个不同类型的值

3.1 创建元组

3.2 获取元组中的值

3.3拉链操作

zip命令可以将多个值绑定在一起（有点python 风~）



注意：如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素的个数

4 集合

Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质

在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable 类型的集合初始化后就不能改变了（注意与val修饰的变量进行区分）

4.1 序列

不可变的序列 import scala.collection.immutable._

在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表

9::List（5，2）::操作符是将给定的头和尾创建一个新的列表

注意： ::操作符是右结合的，如9 ::5 ::2 ::Nil 相当于 9::(5::(2::Nil))

object ImmutListDemo {
  def main(args: Array[String]): Unit = {
    //创建一个不可变的集合
    val lst1 = List(1,2,3)
    //将0插入到lst1的前面生成一个新的list
    val lst2 = 0::lst1
    val lst3 = lst1.::(0)
    val lst4 = 0+:lst1
    val lst5 = lst1.+:(0)

    //将一个元素添加到lst1的后面产生一个新的集合
    val lst6 = lst1 :+3

    val lst0 = List(4,5,6)

    //将2个list合并成一个新的List
    val lst7 = lst1 ++ lst0

    //将lst1插入到lst0前面生成一个新的集合
    val lst8 = lst1 ++: lst0

    //将lst0插入到lst1前面生成一个新的集合
    val lst9 = lst1. :::(lst0)
    println(lst9)
  }

}

4.2 Set

4.3 Map