Scala（六）_listbuffer遍历scala-优快云博客

本文链接：https://blog.youkuaiyun.com/2401_82413059/article/details/147043700

本节课学习了数组、列表、Set集合、Map集合、元组、集合中常用的函数等等。

数组包括可变数组、不可变数组，学习了如何定义和创建数组、可变数组和不可变数组之间的转换、多维数组、数组遍历

列表学习了如何添加元素、合并集合、如何访问元素、遍历列表

Set集合学习了可变Set和不可变Set，以及如何遍历Set

Map集合同样也学习了可变Map和不可变Map，以及如何访问Map中的数据

元组学习了如何创建、如何访问

集合中常用的函数学习了获取集合的相关属性、获取特定元素相关、排序相关等

数组

一、定义

（一）定义一

val arr1 = new Array[Int](10)

（1）new 是关键字

（2）[Int]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定Any

（3）(10)，表示数组的大小，确定后就不可以变化

例子：

（二）定义二

val arr1 = Array(1, 2)

（1）在定义数组时，直接赋初始值

（2）使用apply 方法创建数组对象

例子：

二、可变数组

1.定义变长数组

val arr01 = ArrayBuffer[Any](3, 2, 5)

（1）[Any]存放任意数据类型

（2）(3, 2, 5)初始化好的三个元素

（3）ArrayBuffer 需要引入 scala.collection.mutable.ArrayBuffer

2.例子

import scala.collection.mutable.ArrayBuffer

object TestArrayBuffer {
  def main(args: Array[String]): Unit = {
    //（1）创建并初始赋值可变数组
    val arr01 = ArrayBuffer[Any](1, 2, 3)

    //（2）遍历数组
    for (i <- arr01) {
      println(i)
    }
    println(arr01.length) // 3
    println("arr01.hash=" + arr01.hashCode())

    //（3）增加元素
    //（3.1）追加数据
    arr01 += 4
    //（3.2）向数组最后追加数据
    arr01.append(5, 6)
    //（3.3）向指定的位置插入数据
    arr01.insert(0, 7, 8)
    println("arr01.hash=" + arr01.hashCode())

    //（4）修改元素
    arr01(1) = 9 // 修改第 2 个元素的值
    println()

    for (i <- arr01) {
      println(i)
    }
    println(arr01.length) // 现在长度应该是 8 而不是 5
  }
}

三、可变数组和不可变数组的转换

1.说明

arr1.toBuffer //不可变数组转可变数组

arr2.toArray //可变数组转不可变数组

2.例子：

import scala.collection.mutable.ArrayBuffer

object ArrayConversionExample {
  def main(args: Array[String]): Unit = {
    // 创建一个不可变数组
    val arr1 = Array(1, 2, 3)
    println("原始不可变数组 arr1: " + arr1.mkString(", "))

    // 不可变数组转可变数组
    val mutableArr = arr1.toBuffer
    println("转换后的可变数组 mutableArr: " + mutableArr)

    // 向可变数组中添加元素
    mutableArr.append(4)
    println("添加元素后的可变数组 mutableArr: " + mutableArr)
    println("转换后原始不可变数组 arr1 未改变: " + arr1.mkString(", "))

    // 创建一个可变数组
    val arr2 = ArrayBuffer(5, 6, 7)
    println("原始可变数组 arr2: " + arr2)

    // 可变数组转不可变数组
    val immutableArr = arr2.toArray
    println("转换后的不可变数组 immutableArr: " + immutableArr.mkString(", "))

    // 尝试向不可变数组添加元素会编译错误，这里注释掉以展示不可行性
    // immutableArr :+ 8  // 此操作会生成新数组，原数组不变，且不能直接修改原数组

    println("转换后原始可变数组 arr2 未改变: " + arr2)
  }
}

四、多维数组

1.多维数组定义

val arr = Array.ofDim[Double](3,4)

说明：二维数组中有三个一维数组，每个一维数组中有四个元素

2.例子

列表

一、不可变列表list

例子

object TestList {
  def main(args: Array[String]): Unit = {
    //（1）List 默认为不可变集合
    //（2）创建一个 List（数据有顺序，可重复）
    val list: List[Int] = List(1, 2, 3, 4, 3)
    //（7）空集合 Nil
    val list5 = 1 :: 2 :: 3 :: 4 :: Nil
    //（4）List 增加数据
    //（4.1）::的运算规则从右向左
    val list1 = 7 :: 6 :: 5 :: list
    //（4.2）添加到第一个元素位置
    val list2 = list.+:(5)
    //（5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化
    val list3 = List(8, 9)
    // 使用 ::: 进行扁平化合并
    val list4 = list3 ::: list1
    //（6）取指定数据
    println(list(0))
    //（3）遍历 List
    list.foreach(println)
    list1.foreach(println)
    list3.foreach(println)
    list4.foreach(println)
    list5.foreach(println)
  }
}

二、可变ListBuffer

例子

import scala.collection.mutable.ListBuffer

object TestList {
  def main(args: Array[String]): Unit = {
    //（1）创建一个可变集合
    val buffer = ListBuffer(1, 2, 3, 4)
    //（2）向集合中添加数据
    buffer += 5
    buffer.append(6)
    buffer.insert(1, 2)
    //（3）打印集合数据
    println("添加元素后的集合：")
    buffer.foreach(println)
    //（4）修改数据
    buffer(1) = 6
    buffer.update(1, 7)
    println("修改元素后的集合：")
    buffer.foreach(println)
    //（5）删除数据
    buffer -= 5
    buffer.remove(5)
    println("删除元素后的集合：")
    buffer.foreach(println)
  }
}

Set集合

一、不可变 Set

例子

二、可变mutable.Set

例子

Map集合

一、不可变 Map

例子

二、可变Map

例子

元组

1.说明

元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组。

注意：元组中最大只能有 22 个元素。

2.例子

object TestTuple {
  def main(args: Array[String]): Unit = {
    //（1）声明元组的方式：(元素 1，元素 2，元素 3)
    val tuple: (Int, String, Boolean) = (40, "bobo", true)
    //（2）访问元组
    //（2.1）通过元素的顺序进行访问，调用方式：_顺序号
    println("通过顺序号访问元组元素：")
    println(tuple._1)
    println(tuple._2)
    println(tuple._3)
    //（2.2）通过索引访问数据
    println("通过索引访问元组元素：")
    println(tuple.productElement(0))
    //（2.3）通过迭代器访问数据
    println("通过迭代器访问元组元素：")
    for (elem <- tuple.productIterator) {
      println(elem)
    }
    //（3）Map 中的键值对其实就是元组，只不过元组的元素个数为 2，称之为对偶
    val map = Map("a" -> 1, "b" -> 2, "c" -> 3)
    val map1 = Map(("a", 1), ("b", 2), ("c", 3))
    println("遍历 Map 中的键值对：")
    map.foreach(tuple => {
      println(tuple._1 + "=" + tuple._2)
    })
  }
}

集合常用函数

一、基本属性和常用操作

例子：

object TestList {
  def main(args: Array[String]): Unit = {
    val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7)

    //（1）获取集合长度
    println("集合长度：" + list.length)

    //（2）获取集合大小，等同于 length
    println("集合大小：" + list.size)

    //（3）循环遍历
    println("通过 foreach 循环遍历集合：")
    list.foreach(println)

    //（4）迭代器
    println("通过迭代器遍历集合：")
    for (elem <- list.iterator) {
      println(elem)
    }

    //（5）生成字符串
    println("将集合元素用逗号连接成字符串：" + list.mkString(","))

    //（6）是否包含
    println("集合是否包含元素 3：" + list.contains(3))
  }
}

二、衍生集合

例子：

object TestList {
  def main(args: Array[String]): Unit = {
    val list1: List[Int] = List(1, 2, 3, 4, 5, 6, 7)
    val list2: List[Int] = List(4, 5, 6, 7, 8, 9, 10)

    //（1）获取集合的头
    println("list1 的头元素: " + list1.head)

    //（2）获取集合的尾（不是头的就是尾）
    println("list1 的尾元素集合: " + list1.tail)

    //（3）集合最后一个数据
    println("list1 的最后一个元素: " + list1.last)

    //（4）集合初始数据（不包含最后一个）
    println("list1 除去最后一个元素的集合: " + list1.init)

    //（5）反转
    println("list1 反转后的集合: " + list1.reverse)

    //（6）取前（后）n 个元素
    println("list1 的前 3 个元素: " + list1.take(3))
    println("list1 的后 3 个元素: " + list1.takeRight(3))

    //（7）去掉前（后）n 个元素
    println("list1 去掉前 3 个元素后的集合: " + list1.drop(3))
    println("list1 去掉后 3 个元素后的集合: " + list1.dropRight(3))

    //（8）并集
    println("list1 和 list2 的并集: " + list1.union(list2))

    //（9）交集
    println("list1 和 list2 的交集: " + list1.intersect(list2))

    //（10）差集
    println("list1 相对于 list2 的差集: " + list1.diff(list2))

    //（11）拉链 注:如果两个集合的元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用
    println("list1 和 list2 拉链后的集合: " + list1.zip(list2))

    //（12）滑窗
    println("list1 滑窗操作的结果:")
    list1.sliding(2, 5).foreach(println)
  }
}

三、集合计算简单函数

例子：

object TestList {
  def main(args: Array[String]): Unit = {
    val list: List[Int] = List(1, 5, -3, 4, 2, -7, 6)

    //（1）求和
    println("列表元素的和为: " + list.sum)

    //（2）求乘积
    println("列表元素的乘积为: " + list.product)

    //（3）最大值
    println("列表中的最大值为: " + list.max)

    //（4）最小值
    println("列表中的最小值为: " + list.min)

    //（5）排序
    // （5.1）按照元素大小排序
    println("按元素大小排序后的列表: " + list.sortBy(x => x))

    // （5.2）按照元素的绝对值大小排序
    println("按元素绝对值大小排序后的列表: " + list.sortBy(x => x.abs))

    // （5.3）按元素大小升序排序
    println("按元素大小升序排序后的列表: " + list.sortWith((x, y) => x < y))

    // （5.4）按元素大小降序排序
    println("按元素大小降序排序后的列表: " + list.sortWith((x, y) => x > y))
  }
}