Scala中的数组、映射、元组、集合

一、数组
1. 数组有   定长数组：Array
                   变长数组：ArrayBuffer
不可变的集合或数组一般在immutable包下面，scala默认将这个包导入进来了
；可变的集合或数组一般在mutable包下，需要手动导入
。
Array 是一个不可变长数组，但是数组中角标对应的元素是可变的

import scala.collection.mutable.ArrayBufferobject Demo1 {  def main(args: Array[String]) {    //初始化一个长度为8的定长数组，其所有的元素为0    val arr1 = new Array[Int](8)    //直接打印定长数组，内容为数组的hashcode值    println(arr1)    // 将数组转化为数组缓冲，就可以看到原数组中的内容    println(arr1.toBuffer)    println(arr1.length)   val arr2 = Array("hadoop", "hive", "spark")    // 下面的这种写法会报错，上述定义定长数组，本质上通过伴生对象的apply（）实现初始化    // val ARR3 = new Array("hadoop","hive","spark")    println(arr2.toBuffer)    println(arr2(0))    //变长数组    val ab = ArrayBuffer[Int]()    //向数组缓冲的尾部追加一个元素    ab += 1    //追加多个元素    ab +=(2, 3, 4)    //追加一个数组 ++=    ab ++= Array(6, 7)    //追加一个数组缓冲    ab ++= ArrayBuffer(8, 9)    println(ab)  }}

2.遍历数组

object ForArrayDemo {  def main(args: Array[String]) {    //使用for循环遍历    val arr1 = Array("jack", "tom", "rose")    for (i <- arr1) println(i)    //使用until遍历，与java里面的for(int i; i < arr.length; i ++)类似    val arr2 = Array("scala", "spark", "hadoop")    for (i <- (0 until (arr2.length)))      println(i + "---" + arr2(i))    //反转数组    for (i <- (0 until arr2.length).reverse)      println(i + "---" + arr2(i))  }    println(arr1.max)    println(arr1.min)    println(arr1.sum)    println(arr1.head)   //取第一个元素    println(arr1.last)   //取最后一个元素    arr1.update(0, 0)    //更新指定角标的元素的值}}

3.数组转换

object TransDemo {  def main(args: Array[String]) {    val arr1 = Array(1,2,3,4,5)    //yield 把每一个元素遍历后，处理放到一个新的区间里面去    val arr2 = for(i <-arr1 if i % 2 == 0)yield i * 10    println(arr2.toBuffer)    //map 是把原来数组的每一个元素拿出来（自己完成遍历操作），然后处理了得到一个新的数组    println(arr1.map(_*100).toBuffer)    //filter 是对元素进行筛选（自己内部加了if条件），然后放入一个新的数组中    val arr3 =arr1.filter(_%2==0).map(_+100)    println(arr3.toBuffer)  }}

二、映射
scala中把映射
scala中把hash表这种数据结构叫映射
构建映射有两种方式，一种是箭头 ->，一种是元组（）

object MapDemo {  def main(args: Array[String]) {    /*注意：在Scala中，有两种Map，一个是immutable包下的Map，    该Map中的内容不可变；另一个是mutable包下的Map，该Map中的内容可变*/    //不可变    val scor = Map(("tommy",80),("jackky",90),("rosey",100))    //可变    val scores = scala.collection.mutable.Map(("tom",80),("jack",90),("rose",100))    println(scores("tom"))    scores("tom") = 88    println(scores("tom"))    //可以先对key进行判断，如果存在则取出对应的value    if(scores.contains("tom")){      println(scores("tom"))    }    //get 方法返回的是一个Option对象，这个对象有两个小弟：Some和None    //如果有值则返回的是some，否则返回的是None    //通过Option的get方法可以取出Some里面的值    val maybeInt: Option[Int] = scores.get("tom")    println(maybeInt.get)    scores += (("kobe",100),("zms" , 99),("kuli",1))    println(scores("kobe"))    //用getOrElse ，如果取不到，可以返回一个给定的默认值    val star = scores.getOrElse("韦德","闪电侠")    val star1 = scores.getOrElse("kobe",0)    println(star)  //闪电侠    println(star1) //100  }}

三、元组
映射是K/V对偶的集合，对偶是元组最简单的形式，元组可以封装多个不同类型的值，注意元组的角标是从1 开始的。

object TupleDemo {  def main(args: Array[String]) {    val tuple2: (Int, String) = (3, "value")    val tuple3 = ("hi", "heiio", "baibai")    val tuple, (key, value) = ("key", "value")    println(tuple2._2)    val t1 = Array(1,2)    val t2 = Array("hah","ok")    //拉链操作，zip命令可以将多个值绑定在一起    val t3 : Array[(Any,Any)] = t1.zip(t2)     t3.foreach(x => println(x))//(1,hah) (2,ok)}}

四、集合
Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质
在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后）不能改变不（注意与val修饰的变量进行区别）
1. 不可变的序列 import scala.collection.immutable._
在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。
9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表
注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))

def main(args: Array[String]): Unit = {    val list = List(1, 2, 3)    //原来的list是不变的    val newList = list ++ List("dfasd", true)    //println(newList)    /**      * 给头部添加      */    val newList2 = list.::(4, 5)    val newList3 = list.+:(4, 5)    val newList4 = (4, 5) :: list    val newList5 = (4, 5) +: list    println(newList5)    /**      * 给尾部添加      */    val newList6 = list.:+(4, 5)    val newList7 = list ++ List(4, 5)    val newList8 = list ++: List(4, 5)    // println(newList8)    /**      * list 的常规操作      */    println(list.sum)    println(list.max)    println(list.min)    println(list.head)    println(list.last)    list.updated(0, 0)    list.reverse    list.mkString(",")    list.mkString("[", ",", "]")    /**      * list 的转换操作      */    list.map(x=>x).reverse.sortBy(x=>x).filter(x=>true).foreach(println(_))  }

2.

def main(args: Array[String]) {    //创建了一个lst0 有初始值    val lst0 = ListBuffer[Int](1,2,3)    //创建空的lst1    val lst1 = new ListBuffer[Int]      println("lst1:"+ lst1)    //改lst1 添加一个元素,从打印结果可以看出，添加元素的两种方式： append 与 +=    lst1.append(4)    lst1 += 5    println("lst1:"+ lst1)    //将lst1 里面的元素追加到lst0    lst0 ++=lst1    println("lst0:" + lst0)    // 注意：下面的情况会产生一个新的集合    val lst3 = lst0 ++ lst1    val lst4 = lst1 :+ 10    println("lst3:" + lst3)    println("lst4:" + lst4)  }}

3.Set

def main(args: Array[String]): Unit = {    /**      * 不可变的      */    val set0 = Set(1, 2, 3, 4)    val set1 = set0 + 9    val set2 = set0 ++ Set(5, 6, 7)    set0.foreach(println(_))    /**      * 可变的      */    val set3 = collection.mutable.Set(1, 2, 3, 4, 5)    set3 += 5    set3 ++= Set(6, 7, 8, 9)    println(set3)  }