Scala(二)：元组、数组、映射

来源：cnblogs　　作者：奋斗的only　　时间：2018/12/14 10:47:13　　对本文有异议

元组：Tuple,不同类型值的聚集。
将固定数量的项目组合在一起，以便它们可以作为一个整体传递。 与数组或列表不同，元组可以容纳不同类型的对象，但它们也是不可变的。
元祖的实际类型取决于它的分量的类型，比如下面的类型实际为 Tuple3[Int,String,String]
索引是从1开始的

object Tuple {
  def main(args: Array[String]): Unit = {
    val triple1 = (100, "Scala", "Spark")
    println(triple1._1)
    println(triple1._2)
    println(triple1._3)
    //它们也可用于将数据值列表作为并发编程中的参与者之间的消息传递。
    val triple2 = (4, 3, 2, 1)
    val sum = triple2._1 + triple2._2 + triple2._3 + triple2._4
    println("Sum of elements: " + sum)
    //元组的迭代
    val triple3 = (4, 3, 2, 1)
    triple3.productIterator.foreach { i => println("Value = " + i) }
    //元组转换为字符串：可以使用Tuple.toString()方法将元组的所有元素连接成字符串
    val triple4 = new Tuple3(1, "hello", Console) //此处为显式的使用
    println("Concatenated String: " + triple4.toString())
    //交换元素：可以使用Tuple.swap方法交换Tuple2中的元素
    val triple5 = new Tuple2("Scala", "hello")
    println("Swapped Tuple: " + triple5.swap)
  }
}

数组：Array
    1.定长数组
      val nums = new Array[Int](10) 长度为10 初始元素为0
    2.变长数组
      ArrayBuffer
    3.常用算法
      sum、max、sorted
    4.多维数组
      多维数组是通过数组的数组来实现的
    5.数组转换
      Scala中数组转换不会改变原来的数组，只会产生一个新的数组

object ArrayOps {
  def main(args: Array[String]): Unit = {
    //ArrayBuffer
    val arraybuffer = ArrayBuffer[Int]()
    //添加元素
    arraybuffer += 1
    //用+=在尾部添加元素
    arraybuffer += (2,3,4,5)
    //添加多个元素,可以用++=添加任意集合
    arraybuffer ++= Array(6,7,8)
    //移除元素,可以从头部或者尾部
    arraybuffer.trimStart(1)
    arraybuffer.trimEnd(3)
    //你也可以用从任意位置插入或者溢出元素，这种操作不高效
    arraybuffer.insert(2,11)//第一个参数为索引，第二个参数为插入值
    arraybuffer.remove(3,2)//第一个参数为索引，第二个参数为移除的个数
    //有时你需要构建一个Array，但是不知道需要装多少元素，可以构建一个数组缓冲
    arraybuffer.toArray
    //数组的遍历
    val array = Array(1, 2, 3, 4, 5)
    //until是RichInt类的方法，返回所有小于上限的数据
    for (i <- 0 until array.length) {
      println(array(i))
    }
    //如果在循环体中不需要使用下标，我们可以直接访问数组元素
    for(elem <- array){
      println(elem)
    }
    arraybuffer.sum
    arraybuffer.max
    arraybuffer.sorted
    //多维数组
    //这个Double的多维数组类型为Array[Array[Double]],构造这个数组使用ofDim方法
    val matrix1 = Array.ofDim[Double](3,4)//3行，4列
    //访问元素
    //matrix1(row)(column)
    //不规则的数组，每一行长度不相同
    val  matrix2=new Array[Array[Int]](10)
    for(i <- 0 until matrix2.length){
      matrix2(i) = new Array[Int](i+1)
    }
    //数组的转换
    //yield
    val a = Array(2,3,5,6)
    val result = for(elem <- a) yield  2 * elem
    //如果不满足，可以通过守卫
    val result1 = for(elem <- a if elem % 2==0) yield  2 * elem
  }
}

程序员名言：“如果只能有一种数据结构，那就用哈希表吧”
映射：Map(k,v)
    1.构造映射 mutable.Map[String ,Int];immutable.Map[String ,Int]
    2.获取及更新映射值
    3.迭代映射  for((k,v) -> 映射) 处理k,v
    4.已排序映射

object MapOps {
  def main(args: Array[String]): Unit = {
    var scores1=Map("john" -> 10,"Alice" -> 20,"Bob" -> 30)
    //上述代码构造了一个不可变映射Map[String,Int],其值不能被改变,因为Map默认调用的是immutable包下的，源码为：val Map = immutable.Map
    //可变映射
    val scores2=scala.collection.mutable.Map("john" -> 10,"Alice" -> 20,"Bob" -> 30)
    //空映射，需要选定类型
    val scores3=new scala.collection.mutable.HashMap[String ,Int]
    //获取映射中的值：可以根据键获取值
    val johnScore=scores1("john")//类似Java中的scores.get("john")
    //检查映射中是否包含某个值
    val bobScore = if(scores1.contains("Bob")) scores1("Bob") else 0
    //快捷写法
    val aliceScore = scores1.getOrElse("Alice",0)
    //更新映射中的值，需要在可变映射中
    scores2("john")=80
    scores2 += ("Boole" -> 50,"LiLei" -> 45)
    //虽然不可变映射顾名思义不可变，但是你可以这样
    val newScores=scores1 + ("HanMei" -> 99)
    //同理，你需要从不可变映射中移除某个值可以使用-去掉该键的映射
    scores1 = scores1 - "Alice"
 
    //迭代映射：你可以在Scala的for循环中使用模式匹配
    //如果只需要访问键和值，你可以使用keySet和values，values方法返回的是一个Iterable，你可以在循环中使用这个Iterable
    scores1.keySet //一个类似Set的("john","Alice","Bob" )这样的集
    for(i <- scores1.values) println(i)
    //已排序映射:默认情况下，Scala给的是哈希表，需要顺序的访问所有的键，我们需要一个树形映射
    val scores4 = scala.collection.immutable.SortedMap("john" -> 10,"Alice" -> 20,"Bob" -> 30)
    //如果要插入顺序访问所有键
    val scores5 = scala.collection.mutable.LinkedHashMap("john" -> 10,"Alice" -> 20,"Bob" -> 30)
  }
}