spark学习进度4——Scala中的元组

一、Scala中的集合

1、按照常用性进行排序：

• 1-元组

• 2-数组（Array，在scala中Array是单独存在的，直接声明Array[type]）

• 3-List

• 4-Map

• 5-Set (去重)

2、以上的集合数据都分为两种（除了元组）： 

•  mutable 可变集合——集合声明以后，元素个数和值等可以改变（需要导包）

•  immutable不可变集合——集合声明以后，元素个数和值等不能改变

 在scala.collection.mutable/immutable 包中

---

 

二、元组

 1、基本概念

（1）(  ) 声明元组。 元组没有可变的，都是不可变的，声明以后只能使用，不能修改（tuple）。

（2）元组对象的关键字： tuple。  Tuple是一个类，是一个关键字。

 

 

（3） 概念：一系列数据的集合，可以理解成array，但是比较特殊，可以将不同的类型的数据绑定在一起，同时也可以理解成对象。

（4）元组是一个类，对参数的个数要求是： 1 - 22 个，不能不给参数。

（5） 使用场景： 方法的返回值是不同数据类型的时候可以绑定在元组中。

2、声明方式——使用小括号进行声明（元组数据1，元组数据2...)

（1）存放相同数据类型

val tuple01:(Int,Int,Int)=(1,2,3)

（2）存放不同数据类型

val tuple02:(String,Int,Int)=("zhangsan",20,3000)

（3）使用new进行创建，但是必须给参数，参数个数是1—22个

val tuple03:(String,Int,Int)=new Tuple3("zhangsan",20,3000)

（4）元组中嵌套元素

val tuple04=(tuple01,tuple01,tuple01)

3、元组取值

（1）通过元组中参数的位置或者下标（index不能越界）进行取值

  def main(args: Array[String]): Unit = {
    val tuple02:(String,Int,Int)=("zhangsan",20,3000)
    //通过元素位置进行取值，获取zhangsan
    println(tuple02._1)
    //或者
    println(tuple02 _1)
  }

 

 （2）如果元组中嵌套元组的取值

  def main(args: Array[String]): Unit = {
    val t1:(String,Int,Int)=("zhangsan",20,3000)
    val t2=(t1,t1,t1)
    println(t2._1._1)
  }

 

 4、元组遍历

（1）productIterator

def main(args: Array[String]): Unit = {
    val t1=Tuple3("zhangsan",20,3000)
    for(a<-t1.productIterator){
      println(a)
    }
}

（2） productArity + productElement 

  def main(args: Array[String]): Unit = {
    val t1=Tuple3("zhangsan",20,3000)
    for(b<-0 to t1.productArity-1){
      var value=t1.productElement(b)
      println(s"第${b+1}的元素的值是${value}")
    }
  }

 

 5、对偶元组——Tuple2就是对偶元组

（1）两个参数的元组称为对偶元组

（2）对偶元组是map集合中的元素，所以比较特殊

6、操作方法

（1）swap 方法： 将对偶元组中的数据位置互换；

def main(args: Array[String]): Unit = {
    val t1=("1001","zhangsan")
    val t2=t1.swap
    println(t2)
  }

（2）zip方法：拉链方法，可以将两个数组进行拉链操作变成对偶元组：

def main(args: Array[String]): Unit = {
    var arr1:Array[Int]=Array(1,2,3,4,5)
    var arr2: Array[String] =Array("zhangsan","lisi","wangwu")
    val tuple: Array[(Int, String)] =arr1.zip(arr2)
    //打印完成以后发现都是对偶元组
    tuple.foreach(println)
    //获取下标为0的数组中的第二个元素：zhangsan
    println(tuple(0)._2)
  }

注：元素个数不匹配的，超出的拉不上

（3）zipWithIndex 给数组中的元素添加下标，变成对偶元组：

  def main(args: Array[String]): Unit = {
    var arr1: Array[String] =Array("zhangsan","lisi","wangwu")
    val tuple: Array[(String,Int)] =arr1.zipWithIndex
    //将下标+1输出
    val tuples = tuple.map(a => (a._1, a._2 + 1))
    for (elem <- tuples) {
      println(elem.swap)
    }
  }