Scala007--Scala中的数据结构【元组】_scala定义元组-优快云博客

Scala中的元组和数组及列表有点相似，它里面也可以放入多个元素，并且元素也是使用小括号进行包裹。但是不同的是：①元组不能够像数组那样可以更改元组对应的值，这一点上和列表有点相似，同样是不可以修改序列中的元素；②去访问元组中的元素也和元组和列表不同，它访问元素是使用变量名_.索引，在数组和列表中访问元素则是直接使用变量名(索引)；③元组还有一种特殊的形式，就是tuple2-对偶元组，元组里面只有两个元素，可以分别对应map集合中的key和value。

接下来我们去使用代码查看具体的实现和效果。

二，定义元组

scala> val tuple1=(1,3,"张三",1.2)

三，访问元组中的元素

如上，我们可以发现，在元组中去访问元素的时候不像数组和列表中那样可以直接使用变量名加上小括号并向里面传入索引号进行访问，而是得需要使用下划线加上索引号才行。

四，对偶元组

很多时候我们并不需要元组中有很多元素，只需要有两个就行。类似于这种（x1，x2）小括号中只有两个元素的元组我们都称之为对偶元组。

对偶元组的形成一般是两个数组进行了zip拉链形成。如下：

scala> val ar_im_0=Array(1,2,3)
ar_im_0: Array[Int] = Array(1, 2, 3)

scala> val ar_im_1=Array(4,5,6)
ar_im_1: Array[Int] = Array(4, 5, 6)

scala> ar_im_0 zip ar_im_1    // 讲ar_im_0中的元素穿插到ar_im_1数组中，
res9: Array[(Int, Int)] = Array((1,4), (2,5), (3,6))

当我们交换两个数组进行zip的位置不同时，所得到的结果也会不同。

如下，当我们将 ar_im_1 放置在zip的前面，拉链之后的结果如下：

这种类型的元组有些时候我们会在编写代码的过程中遇到，并且需要灵活的使用它来实现我们想要的实现结果。接下来我们使用一个具体的案例综合使用这些知识内容。

五，习题

题目：

将一个Array(1,2,3,4,5,6,7,8)->得到一个字符串”2 1 4 3 6 5 8 7”

如上习题，我们可以发现，偶数索引位置的元素放置到了奇数索引位置之前，这个使用我们就可以使用zip拉链来解题。

package personal_tes
/**
 * @author:码到成龚
 * my motoo:"听闻少年二字，应与平庸相斥。"
 */
object TupleToString {
  def main(args: Array[String]): Unit = {
    // 将一个Array(1,2,3,4,5,6,7,8)->得到一个字符串"2 1 4 3 6 5 8 7"
    val ar_im_2=Array(1,2,3,4,5,6,7,8)
    var str_ou=""  // 用于存储偶数下标的元素
    var str_ji=""  // 用于存储奇数下标的元素
    for(i <- 0 until  ar_im_2.length){  // 循环守卫，找到数组中下标为偶数的元素
      if (i % 2 ==0){
        str_ou+=(ar_im_2(i)+"," )  // 字符串拼接
      }
      else {
        str_ji+=(ar_im_2(i)+",")
      }
    }
//    println(str_ou)  // 打印含有偶数索引元素的字符串
//    println(str_ji)  // 打印含有奇数索引元素的字符串
    val ar_ou=str_ou.split(",")         // 返回数组
    val ar_ji=str_ji.split(",")
//    println(ar_ou.toBuffer)   // 查看数组中的元素
//    println(ar_ji.toBuffer)
    val ar_tuples = ar_ji zip ar_ou  // 两个数组进行拉链,得到对偶元组
//    println(ar_tuples.toBuffer)    // 查看两个数组拉链形成的数据中的元素
    var store_str=""  // 用来存储结果的字符串
    for(ele <- ar_tuples){
      store_str+=(" "+ele._1+" "+ele._2)
    }
    println(store_str)
  }
}

六，元组，数组，列表三者打印的不同

元组和列表一样都是可以直接使用print打印出来，因为它们底层都重写了toString方法，但是我们的数组没有重写，所以使用print方法打印出来的就是该对象数据的地址，如下：

package personal_test

/**
 * @author:码到成龚
 * my motoo:"听闻少年二字，应与平庸相斥。"
 */
object Tuple1 {
  def main(args: Array[String]): Unit = {
    val tuple1=(1,3,4)   // 元组
    val arr=Array(1,2,3)  // 数组
    val lis=List(1,5,7)  // 列表
    println(tuple1)
    println(arr)
    println(lis)
  }
}

相信大家还有映像，就是我们如果想要查看数组中有哪些元素的话可以使用toBuffer方法将数组转换成可变数组，或者是t使用oList方法将数组转换成列表，就可以将数组打印出来：

package personal_test

/**
 * @author:码到成龚
 * my motoo:"听闻少年二字，应与平庸相斥。"
 */
object Tuple1 {
  def main(args: Array[String]): Unit = {
    val arr=Array(1,2,3)  // 数组
    println(arr)
    println(arr.toList)  // 将数组转换成列表
    println(arr.toBuffer)  // 将不可变数组转换成可变数组
  }
}

七，数组的拉链

1，两个同类序列进行拉链【zip函数】

Scala秉持的就是函数式编程，并且也为了显得更加简洁优雅，有些时候在调用函数的时候我们也可以不写.点号，直接在函数的左右空一格即可，如下：

scala> val arr_im=Array(1,2,3)  //  静态声明不可变数组
arr_im: Array[Int] = Array(1, 2, 3)

scala> val arr_im1=Array(5,6,7)
arr_im1: Array[Int] = Array(5, 6, 7)

scala>  val  zip_arrT=arr_im zip arr_im1   // 使用zip函数将 两个数组进行拉链，形成对偶数组
zip_arrT: Array[(Int, Int)] = Array((1,5), (2,6), (3,7))

如果觉得这种函数的调用不大习惯也可以如下编写：

scala>  val  zip_arrT=arr_im.zip(arr_im1 )  // 使用zip函数将两个数组进行拉链，形成对偶数组
zip_arrT: Array[(Int, Int)] = Array((1,5), (2,6), (3,7))

2，数组和自己的下标进行拉链【zipWithIndex函数】

对偶序列不一定是两个同类序列使用了zip函数形成，也不一定是使用直接声明和定义，也可以是该序列和自己的下标使用zipWithIndex函数进行了拉链，如下，我们让数组arr_im2和自己的下标进行拉链，就会得到一个包含有对偶元组的数组：

scala> val arr_im2=Array(77,99,100)
arr_im2: Array[Int] = Array(77, 99, 100)

scala> arr_im2.zipWithIndex // 数组和自己的下标拉链
res65: Array[(Int, Int)] = Array((77,0), (99,1), (100,2))

scala>

八，利用数组进行组合赋值

我们在使用变量的时候常常需要为多个变量同时赋值，这个时候就需要使用到数组或者是元组进行组合赋值，我们先来了解数组的组合赋值，之后再去看元组的组合赋值。

所谓的利用数组进行组合赋值就是左右两边都声明有一个数组，并且数组里面的参数个数一样，之后如果想要这个数组的话，还可以在第一个声明数组即左边第一个写上一个变量来接收生成的数组，如下，使用了num_ar来接收array数组：

scala> val  num_ar,Array(num1,num2,num3)=Array(66,77,88)   // 利用数组进行组合赋值
num_ar: Array[Int] = Array(66, 77, 88)       //  赋值成功后就会返回各变量对应的值
num1: Int = 66
num2: Int = 77
num3: Int = 88

scala> num_ar    // 查看被赋值后的变量
res0: Array[Int] = Array(66, 77, 88)

scala> num1
res1: Int = 66

scala> num2
res2: Int = 77

scala> num3
res3: Int = 88

scala>

九，利用元组进行组合赋值

元组的组合赋值和数组的差不多，接下来我们使用相关的代码来查看具体的效果：

scala> val num_t,(num1,num2,num3)=(99,100,66)  // 利用元组进行组合赋值
num_t: (Int, Int, Int) = (99,100,66)
num1: Int = 99
num2: Int = 100
num3: Int = 66

scala> num_t
res4: (Int, Int, Int) = (99,100,66)

scala> num1
res5: Int = 99

scala> num2
res6: Int = 100

scala> num3
res7: Int = 66