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

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

import scala.collection.mutable.ArrayBuffer
object 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)
  }