集合学习内容总结

集合简介

1、Scala 的集合有三大类：序列 Seq、集Set、映射 Map，所有的集合都扩展自 Iterable

特质。

2、对于几乎所有的集合类，Scala 都同时提供了可变和不可变的版本，分别位于以下两个包

不可变集合：scala.collection.immutable

可变集合： scala.collection.mutable

3、Scala 不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于 java 中的 String

4、对象可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似于 java 中 StringBuilder 对象

数组

不可变数组

1、第一种方式定义数组

定义：val arr1 = new Array[Int](10)

（1）new 是关键字

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

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

Scala 复制代码

object FixedArrayDemo {
  def main(args: Array[String]): Unit = {
    // 严格遵循要求的定义
    val arr1 = new Array[Int](10) // (1) new关键字 (2) [Int]类型 (3) 固定长度10
    
    // 类型验证演示
    val anyArr = new Array[Any](3) // 可存任意类型的版本
    
    // 初始值验证（Int数组初始化为0）
    println("初始数组值：")
    println(arr1.mkString(", "))  // 输出：0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    
    // 合法操作演示
    arr1(0) = 100      // 修改第一个元素
    arr1(arr1.length-1) = 999  // 修改最后一个元素（索引9）
    
    // 类型安全验证（这行如果取消注释会编译报错）
    // arr1(1) = "hello"  // 类型不匹配，因为声明的是Int数组
    
    // 长度不可变验证（这行如果取消注释会运行时报错）
    // arr1(10) = 1000    // 索引越界（有效索引0-9）
    
    // 最终结果输出
    println("\n修改后的数组值：")
    println(arr1.mkString(", "))  // 输出：100, 0, ..., 999
  }
}

2、第二种方式定义数组

val arr1 = Array(1, 2)

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

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

Scala 复制代码

object TestArray{

   def main(args: Array[String]): Unit = {

      var arr02 = Array(1, 3, "bobo")
      println(arr02.length)
      for (i <- arr02) {
          println(i)
      }
   }
}

可变数组

定义变长数组

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

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

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

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

Scala 复制代码

import scala.collection.mutable.ArrayBuffer

object VariableArrayDemo {
  def main(args: Array[String]): Unit = {
    // 严格按要求定义可变数组
    val arr01 = ArrayBuffer[Any](3, 2, 5)  // (1) [Any]类型 (2) 初始化3个元素 (3) 需要显式导入
    
    // 打印初始状态
    println("初始数组:")
    println(s"长度: ${arr01.length}, 内容: ${arr01.mkString(", ")}")  // 长度: 3, 内容: 3, 2, 5
    
    // 演示添加混合类型元素（利用Any特性）
    arr01 += "hello"           // 添加String类型
    arr01 += true              // 添加Boolean类型
    arr01 += Array(7.5, 8.5)   // 添加嵌套数组
    
    // 动态修改演示
    arr01(0) = "替换后的值"       // 修改第一个元素为字符串
    arr01 -= 2                 // 删除元素2（值删除而非索引）
    
    // 打印修改后状态
    println("\n修改后的数组:")
    println(s"长度: ${arr01.length}, 内容: ${arr01.mkString(", ")}")
    // 长度: 6, 内容: 替换后的值, 5, hello, true, [D@哈希值
    
    // 典型操作验证（注释部分为错误示例）
    // arr01(10) = 100       // 索引越界（当前最大索引5）
    // arr01 += 1.23         // 合法操作（Double属于Any）
    // arr01 += List(1,2,3) // 合法操作（List属于Any）
  }
}

不可变数组与可变数组的转换

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

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

arr2.toArray 返回结果才是一个不可变数组，arr2 本身没有变化
arr1.toBuffer 返回结果才是一个可变数组，arr1 本身没有变化

Scala 复制代码

object TestArrayBuffer {

   def main(args: Array[String]): Unit = {

       //（1）创建一个空的可变数组
       val arr2 = ArrayBuffer[Int]()

       //（2）追加值arr2.append(1, 2, 3)
       println(arr2) // 1,2,3

      //（3）ArrayBuffer ==> Array
      //（3.1）arr2.toArray 返回的结果是一个新的定长数组集合
      //（3.2）arr2 它没有变化
      val newArr = arr2.toArray println(newArr)

      //（4）Array ===> ArrayBuffer
      //（4.1）newArr.toBuffer 返回一个变长数组 newArr2
      //（4.2）newArr 没有任何变化，依然是定长数组val newArr2 = newArr.toBuffer 
      newArr2.append(123)

      println(newArr2)
  }
}

列表（List）

列表是 Scala 中最常用的集合类型之一，默认为不可变集合。

不可变 List ‌：使用 List 类创建，一旦创建就不能修改。

Scala 复制代码

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 =  5::list 
   val list1 = 7::6::5::list
   //（4.2）添加到第一个元素位置
   val list2 = list.+:(5)

   //（5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化val list3 = List(8,9)
   //val list4 = list3::list1 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 ‌：使用 ListBuffer 类创建，可以动态修改。

Set 集合

Set 集合是无序且不包含重复元素的集合。

不可变 Set ‌：使用 Set 类创建。

‌可变 Set ‌：使用 mutable.Set 类创建。

Map 集合

Map 集合是键值对（key-value）的集合，类似于 Java 中的 HashMap。

不可变 Map ‌：使用 Map 类创建。

‌可变 Map ‌：使用 mutable.Map 类创建。

元组（Tuple）

元组是一个可以包含多个不同类型元素的容器，最大可以有 22 个元素。

‌声明元组 ‌：使用小括号和逗号分隔元素，如 (1, "a", true)。

访问元组 ‌：通过下划线 _ 和元素的索引来访问，如 tuple._1。

集合常用函数

Scala 复制代码

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）循环遍历
    list.foreach(println)

    //（4）迭代器
    for (elem <- list.itera tor)
      { println(elem)
    }

    //（5）生成字符串
    println(list.mkString(","))

    //（6）是否包含
    println(list.contains(3))
  }
}

Scala 集合提供了丰富的操作函数，包括遍历、过滤、映射、排序等。

‌基本属性和常用操作 ‌：如 length、size、foreach、mkString、contains 等。

衍生集合 ‌：如 head、tail、last、init、reverse、take、drop 等。

集合计算简单函数 ‌：如 sum、product、max、min、sortBy、sortWith 等。

‌集合计算高级函数 ‌：如 filter、map、flatten、flatMap、groupBy、reduce、fold 等。