scala-数组与元组

数组与元组

数组定义

数组几乎是所有语言中最基础的数据结构，数组可索引、类型一致、长度不变

Scala数组分为定长数组和变长数组

• 定长数组：Array
• 变长数组：ArrayBuffer

package hhb.cn.part03

/**
 * @description:数组
 * 在Scala中，分为定长数组和可变数组
 * 定长数组：Array，长度是不变的
 * 变长数组：ArrayBuffer，长度是可变的
 * @author: huanghongbo
 * @date: 2020-09-23 15:09
 **/
object ArrayDemo {

  def main(args: Array[String]): Unit = {
    println("===========定长数组=============")
    //定义长度为10的整型定长数组，初始值为0
    val nums = new Array[Int](10)

    //定义长度为10的字符串型定长数组，初始值为 null
    val strs = new Array[String](10)

    //通过索引访问数组元素，索引从0开始，使用 () 而不是 []
    println(strs(0))

    //省略了关键词new，那么Scala会进行自动类型推断
    val arrays: Array[Int] = Array(1, 2, 3, 4, 5)
    val arrays2: Array[Nothing] = Array()
    println(arrays.length)

    //通过toArray快速定义数组，用于测试
    val array = (1 to 10).toArray
  }
}

变长数组

长度按需要变换的数组ArrayBuffer。Scala 中很多数组类型都有可变、不可变两个版本，推荐使用不可变的数组类型，使用可变数组类型时需要显示声明；

使用ArrayBuffer时，需要导包 import scala.collection.mutable.ArrayBuffer；

println("===========变长数组=============")
//定义一个空的Int变长数组
//注意，后面要有小括号
val arrayBuffer = ArrayBuffer[Int]()
//通过+= 在尾端添加一个或者多个元素
arrayBuffer += 1
arrayBuffer += (2, 3, 4, 5)
//通过 ++= 在尾端添加集合
arrayBuffer ++= (6 to 10).toArray
arrayBuffer.foreach(println(_))
println("========================")

// 还可通过 -= 和 --= 对变长数组进行删减
arrayBuffer -= 10
arrayBuffer --= (1 to 5).toArray
arrayBuffer.foreach(println(_))
println("========================")
//使用append 追加元素
arrayBuffer.append(1)
arrayBuffer.appendAll(Array(1, 2, 3))
arrayBuffer.foreach(println(_))

println("========================")
//使用insert 在某个索引之前插入元素
arrayBuffer.insert(0, 0)
arrayBuffer.insertAll(1, Array(8, 9, 10))
arrayBuffer.foreach(println(_))
println("========================")
//移除元素
//移除最后N个元素
arrayBuffer.trimEnd(3)
arrayBuffer.foreach(println(_))
println("========================")
//移除最开始的N个元素
arrayBuffer.trimStart(2)
arrayBuffer.foreach(println(_))
println("========================")

// 通过remove 从某个索引处移除一个或多个元素
arrayBuffer.remove(3)
arrayBuffer.remove(2, 4)
arrayBuffer.foreach(println(_))
println("========================")

数组操作

数组转换

//使用 toArray把变长数组转换成定长数组
val array1 = arrayBuffer.toArray
//使用toBuffer把定长数组转换成变长数组
val buffer = array1.toBuffer

数组遍历

//使用until进行数组遍历
for (i <- 0 until arrayBuffer.length) {
  println(arrayBuffer(i))
}
//使用to进行数组遍历
for (i <- 0 to arrayBuffer.length - 1) {
  println(arrayBuffer(i))
}
// 使用增加的for循环进行数组遍历
for (ele <- arrayBuffer) println(ele)
//使用forEach进行数组遍历
arrayBuffer.foreach(println(_))

常见算法

在Scala中对数组进行转换非常简单方便，这些转换动作不会修改原始数组，而是产生一个全新的数组。

package hhb.cn.part03

/**
 * @description:
 * @date: 2020-09-23 21:17
 **/
object OperatorDemo {
  def main(args: Array[String]): Unit = {
    //将数组中的偶数加倍，奇数丢弃
    val nums = 1 to 10
    val array1 = for (num <- nums if num % 2 == 0) yield num * 2
    val array2 = for (num <- nums) yield if (num % 2 == 0) num * 2 else 0
    array1.foreach(println(_))
    println("===================")
    array2.foreach(println(_))
    println("===================")
    //使用scala高阶函数
    nums.filter(_ % 2 == 0).map(_ * 2).foreach(println(_))
    println("===================")
    //取出数组中的第一个元素
    println(nums.head)
    //取出数组中的最后一个元素
    println(nums.end)
    //取出数组中除了第一个剩下的所有元素
    println(nums.tail.toBuffer)
    //取出数组中除了最后一个剩下的所有元素
    println(nums.init.toBuffer)

    //求和
    println(nums.sum)
    //求最大值
    println(nums.max)
    //求最小值
    println(nums.min)

    val nums2 = Array(2, 1, 4, 3)
    //排序
    println(nums2.sorted.toBuffer)
    //数组的元素相乘
    println(nums2.product)

    val nums3 = Array(2, 1, 4, 3, 1, 2, 3)
    //把数组里面的每一个元素都乘2
    println(nums3.map(_ * 2).toBuffer)
    //对数组所有的元素进行累加
    println(nums3.reduce(_ + _))
    //对数组进行去重
    println(nums3.distinct.toBuffer)
    //求数组长度
    println(nums3.length)
    println(nums3.size)
    //获取每个元素的索引
    println(nums3.indices)
    //使用mkString进行输出
    //输出元素，且元素与元素之间使用&分割
    println(nums3.mkString(" & "))
    // //输出元素，以 < 开头，以 > 结尾，且元素与元素之间使用&分割
    println(nums3.mkString("<", " & ", ">"))

    //count基数，注意：count后面必须有条件
    //统计数组中大于2的数量
    println(nums3.count(_ > 2))
    //统计数组中偶数的数量
    println(nums3.count(_ % 2 == 0))

    //filter:过滤出符合条件的参数，filterNot：过滤出不符合条件的参数
    //过滤出所有大于2的
    println(nums3.filter(_ > 2).toBuffer)
    //过滤出所有奇数
    println(nums3.filterNot(_ % 2 == 0).toBuffer)
    println("=========================")

    //提取前N个元素
    println(nums3.take(3).toBuffer)
    //提取后N个元素
    println(nums3.takeRight(4).toBuffer)
    //从左向右开始提取，提取符合条件的元素，如果条件不成立，则终止
    println(nums3.takeWhile(_ < 4).toBuffer)

    println("=========================")
    //删除前N个元素
    println(nums3.drop(3).toBuffer)
    //删除后N个元素
    println(nums3.dropRight(4).toBuffer)
    //从左向右开始删除，提取符合条件的元素，如果条件不成立，则终止
    println(nums3.dropWhile(_ < 4).toBuffer)
    println("=========================")
    //将数组分为两部分，前N个为一部分，剩下的为一部分
    val tuple = nums3.splitAt(3)
    println(tuple._1.toBuffer + ",,," + tuple._2.toBuffer)
    //将数组进行节前，以索引为2开始，到4结束，不包括第五个
    println(nums3.slice(2, 5).toBuffer)
    println("=========================")

    //对数组进行拉链操作
    val array_1 = Array("A", "B", "C")
    val array_2 = Array(1, 2, 3, 4)
    //拉链操作，当两个数组长度不一样时，截取相同长度
    val newArray: Array[(String, Int)] = array_1.zip(array_2)
    println(newArray.toBuffer)
    //拉链操作，当两个数组长度不一样时，array_1 用*填充，array_2用-1填充
    val newArray2: Array[(String, Int)] = array_1.zipAll(array_2, "*", -1)
    println(newArray2.toBuffer)

    //拉链操作，当两个数组长度不一样时，array_1 用 -1 填充，array_2用 * 填充
    val newArray3 = array_2.zipAll(array_1, "*", -1)
    println(newArray3.toBuffer)
    //用数组索引进行填充
    val newArray4 = array_1.zipWithIndex
    println(newArray4.toBuffer)
    println("=========================")
    //使用unzip进行数组拆分

    val (l1, l2) = newArray4.unzip
    println(l1.toBuffer)
    println(l2.toBuffer)

    val unzip = Array((1, "one", '1'), (2, "two", '2'), (3, "three", '3')).unzip3
    println(unzip._1.toBuffer)
    println(unzip._2.toBuffer)
    println(unzip._3.toBuffer)

    //数组的操作符： :+  +: ++
    //:+ 在数组的尾部加入元素
    //+: 在数组的头部加入元素
    //++ 拼接两个数组
    val num1 = (1 to 5).toArray
    val num2 = (6 to 9).toArray
    val num3 = num1 :+ 10
    val num4 = 10 +: num2
    val num5 = num1 ++ num2
    println(num3.toBuffer)
    println(num4.toBuffer)
    println(num5.toBuffer)
    println("=========================")
    //排序
    val numSort = Array(1, 5, 2, 6, 3, 7, 4, 9, 8)
    //升序
    println(numSort.sorted.toBuffer)
    println(numSort.sortWith(_ < _).toBuffer)
    //降序
    println(numSort.sorted.reverse.toBuffer)
    println(numSort.sortWith(_ > _).toBuffer)
  }
}

多维数组

通过Array的ofDim方法来定义一个多维的数组，多少行，多少列，都是自己说了算。

package hhb.cn.part03

/**
 * @description:
 * @date: 2020-09-23 22:35
 **/
object DimArrayDemo {

  def main(args: Array[String]): Unit = {
    //创建一个3行4列数据类型为Double的数组
    val array = Array.ofDim[Double](3, 4)
    array(1)(2) = 3.14
    for (i <- 0 to 2; j <- 0 to 3) {
      print(array(i)(j) + "\t")
      if (j == 3) println()
    }
  }
}

元组及操作

Tuple，元组。Map是键值对的集合。对偶是元组的最简单形态；元组是不同类型的值的集合，元组中的元素可以是不同的数据类型，元组在Scala中的应用非常广泛。

package hhb.cn.part03

/**
 * Tuple 元组可以存放不同数据类型的元素
 * 索引是从1开始的，而不是从0开始的
 * 元组在Scala中应用非常广泛，在Spark源码中会经常看见
 * 在Scala中已经事先定义好了22个Tuple，从Tuple1～Tuple22
 * 在Tuple22中最多只能有22个元素
 * @date: 2020-09-23 22:44
 **/
object TupleDemo {

  def main(args: Array[String]): Unit = {
    //定义一个元组
    val tuple1 = (1, 2.5, "spark", 'a', true)
    val tuple2 = (1, 2.5, "spark", 'a', true)
    println(tuple1 == tuple2)
    val tuple3 = (12, 2.5, "spark", 'a', true)
    println(tuple1 == tuple3)
    println(tuple1._3)

    val (t1, t2, t3, t4, t5), t = tuple1
    println(s"$t1  $t2  $t3  $t4  $t5")

    val (l1, _, l3, _, l5), l = tuple1
    println(s"$l1   $l3  $l5")

    //遍历
    for (ele <- tuple1.productIterator) {
      print(ele + "\t")
    }
    println()
    println("==============================")
    tuple1.productIterator.foreach(print(_))
  }
}

第三个模块错题集.png