Scala详解（5）

🕗 发布于 2024-04-20 13:33 scala 开发语言 后端

Scala

集合

概述

集合本质上就是一个用于存储1个到多个数据的容器。在Scala中，集合可以分为三大类：Seq(序列)，Set(集合)和Map(映射)。基于这三大类，衍生出来众多的子类
1. 序列：元素有序可重复
2. 集合：元素无序不可重复
3. 映射：键值对结构数据
在Scala中，所有的集合都混入了Iterable特质，意味着所有的集合都可以被迭代遍历
Scala中的集合分为可变集合(scala.collection.mutable)和不可变集合(scala.collection.immutable)
1. 所谓的不可变集合，指的是集合被创建好之后，长度不可变，且其中的元素也不能改变。如果对不可变集合中的元素进行增删操作，那么不会改变原集合，而是会产生一个新的集合
2. 所谓的可变集合，指的是集合创建好之后，依然可以对元素进行增删操作，并且不会产生新集合，而是修改原集合

数组

不可变数组(`Array`)

不可变数组定义好之后，长度不能发生变化，元素也不能增删；如果增删元素，那么会产生一个新的数组

定义方式

package com.fesco.array

object ArrayDemo {

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

    // 不可变数组定义方式

    // 方式一：val 数组名:Array[元素类型] = new Array[元素类型](数组长度)
    // 数组定义好之后，每一个位置都会有默认值
    val arr: Array[Int] = new Array[Int](5)
    arr(0) = 3
    // 将数组转化为字符串
    println(arr.mkString(","))

    // 方式二：
    // int[] arr = new int[]{3,4,1,4,5}
    val arr2: Array[Int] = Array(3, 1, 7, 8, 4)
    println(arr2.mkString(","))

  }

}

应用一

package com.fesco.array

object ArrayDemo2 {

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

    // 不可变数组定义好之后长度不可变
    val arr = Array(2, 4, 8, 7, 1, 5, 6)

    // 应用一：修改数组中元素的值
    // 方式一：数组名(下标) = 数据
    arr(3) = 4
    // 方式二：提供了update方法来修改元素数据
    arr.update(2, 5)

    // 应用二：遍历数组
    // 方式一：转化为字符串
    val str = arr.mkString(", ")
    println(str)
    // 方式二：通过下标来遍历
    for (i <- 0 until arr.length) println(arr(i))
    // 方式三：增强for循环
    // 增强for循环本质上就是在对元素进行迭代遍历
    for (i <- arr) println(i)
    // 方式四：迭代遍历
    val it = arr.iterator
    while (it.hasNext) println(it.next())
    // 方式五：foreach方法
    arr.foreach(x => println(x))
    // 顺次使用参数，并且参数只使用了一次
    arr.foreach(println(_))
    // println(3,5, (x, y) => x+ y)
    // println(3,5, _ + _ )
    // 函数体只有一句，并且使用了已经存在函数，且参数是一一对应，那么此时参数列表可以省略
    arr.foreach(println)


  }

}

应用二

package com.fesco.array

object ArrayDemo3 {

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

    val arr = Array(2, 4, 8, 7, 1, 5, 6)

    // 应用三：数组扩容
    // Array类中提供了+:和:+的方式来对数组进行扩容，本质上都是产生一个新的数组
    // :+  在数组的末尾来新添元素，构成一个新的数组
    val r1 = arr :+ 3
    println(r1.mkString(", "))
    // +: 在数组的头部来新添元素，构成一个新的数组
    val r2 = arr.+:(3)
    println(r2.mkString(", "))
    val r3 = 3 +: arr
    println(r3.mkString(", "))
    val r4 = 4 +: arr :+ 3
    println(r4.mkString(", "))

    // 应用四：数组合并
    val nums1 = Array(1, 2, 3, 4, 5)
    val nums2 = Array(6, 7, 8, 9)
    // 方式一：通过++合并
    val v1 = nums1 ++ nums2
    println(v1.mkString(", "))
    // 方式二： ++: 或者 :++
    // ++:等价于++
    val v2 = nums1 ++: nums2
    println(v2.mkString(", "))
    val v3 = nums1 :++ nums2
    println(v3.mkString(", "))
    // 方式三：concat函数
    val v4 = nums1.concat(nums2)
    println(v4.mkString(", "))

  }

}

应用三

package com.fesco.array

object ArrayDemo4 {

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

    // 应用五：创建连续范围的数组
    val r1 = Array.range(1, 5)
    println(r1.mkString(", "))
    val r2 = Array.range(0, 10, 2)
    println(r2.mkString(", "))

    // 应用六：用指定数据来填充数组
    // 创建数组，数组的所有元素默认为10
    // 第一个()表示数组长度
    // 第二个()表示填充的元素
    val v1 = Array.fill(5)(10)
    println(v1.mkString(", "))
    // 填充由100以内的随机数构成的长度为7的数组
    val v2 = Array.fill(7)((Math.random() * 100).toInt)
    println(v2.mkString(", "))
    // ({})可以选择省略()或者{}
    val v3 = Array.fill(7) {
      (Math.random() * 100).toInt
    }
    println(v3.mkString(", "))

    // 应用七：数组翻转
    val v4 = v3.reverse
    println(v4.mkString(", "))

  }

}

练习：猴子报数。15只猴子围成一圈报数，报到数字7的猴子被淘汰，下一只猴子从1重新报数，最后剩余的是哪只猴子？

package com.fesco.array

object MonkeyExec {

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

    // 定义数组，表示15只猴子
    // 用true表示猴子的还活着，用false表示猴子被淘汰
    val monkeys = Array.fill(15)(true)
    // 定义变量来记录还剩余的猴子数量
    var n = 15
    // 定义变量来记录报数
    var i = 1
    // 定义变量来记录下标
    var index = 0
    // 只要剩余的猴子数量>1那么就需要继续报数
    while (n > 1) {
      // 先判断这只猴子是否存活
      if (monkeys(index)) {
        // 判断这只猴子是否会被淘汰
        if (i == 7) {
          // 这只猴子被淘汰
          monkeys(index) = false
          // 剩余猴子数量-1
          n -= 1
          // 下一只猴子重新报数
          i = 0
        }
        // 报数+1
        i += 1
      }
      // 下一只猴子准备
      index += 1
      if (index == monkeys.length) index = 0
    }
    println(monkeys.mkString(", "))
  }

}

可变数组(`ArrayBuffer`)

可变数组，类似于Java中的ArrayList，长度可以发生变化，并且可以对数组中的元素来进行增删

定义格式

package com.fesco.array

import scala.collection.mutable.ArrayBuffer

object ArrayBufferDemo {

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

    // 定义方式
    // 方式一：创建了可变数组，初始大小为0
    val r1 = new ArrayBuffer[Int]
    r1.+=(5)
    r1 += 3
    println(r1)
    // 方式二：创建可变数组，指定初始大小
    val r2 = new ArrayBuffer[Int](3)
    r2 += 4
    r2 += 2
    r2 += 5
    r2 += 7
    println(r2)
    // 方式三：创建可变数组，传入初始元素
    val r3 = ArrayBuffer[Int](2, 7, 8, 9, 1)
    println(r3)

  }

}

基本操作

package com.fesco.array

import scala.collection.mutable.ArrayBuffer

object ArrayBufferDemo2 {

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

    val arr = ArrayBuffer[Int](3, 4, 5, 6, 7)

    // 在末尾添加元素
    arr.+=(8)
    arr += 9
    arr.append(10)
    println(arr)
    // 在头部添加元素
    arr.prepend(2)
    println(arr)
    1 +=: arr
    println(arr)
    // 插入元素
    arr.insert(2, 11)
    println(arr)
    // 修改元素
    arr(0) = 0
    println(arr)
    arr.update(1, 3)
    println(arr)
    // 删除指定下标上的元素
    arr.remove(0)
    println(arr)
    // 删除元素3
    // 删除指定的元素(第一次出现)
    arr -= 3
    println(arr)
    // 遍历
    arr.foreach(println)

  }

}

转换

package com.fesco.array

import scala.collection.mutable.ArrayBuffer

object ArrayTransformDemo {

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

    // 可变数组 -> 不可变数组
    val arrBuffer = ArrayBuffer[Int](2, 3, 4, 5)
    val arr = arrBuffer.toArray
    println(arr)

    // 不可变数组 -> 可变数组
    val array = Array[Int](1, 2, 3, 4, 5)
    val buffer = array.toBuffer
    println(buffer)

  }

}

多维数组

定义格式

package com.fesco.array

object DimensionDemo {

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

    // 定义格式

    // 方式一：
    // 定义二维数组r1，包含了3个一维数组，每一个一维数组的大小是不确定的
    val r1: Array[Array[Int]] = new Array[Array[Int]](3)
    r1(0) = new Array[Int](5)
    r1(1) = Array[Int](1, 2, 3, 4)

    // 方式二：
    // 定义二维数组r2包含了2个一维数组
    val r2 = Array(Array(1, 2, 3), Array(1, 3, 4, 6))
    println(r2(0)(1))

    // 方式三：
    // 通过ofDim函数来构建二维数组
    // 定义二维数组r3，包含了3个一维数组，每一个一维数组包含了5个元素
    val r3 = Array.ofDim[Int](3, 5)
    r3(0)(0) = 3
    println(r3(0)(0))

    // 一维数组，可以包含4个整数
    val r4 = Array.ofDim[Int](4)
    // 三维数组，包含了4个二维数组，每一个二维数组中包含了3个一维数组，每一个一维数组可以包含5个整数
    var r5 = Array.ofDim[Int](4, 3, 5)
    // 四维数组，包含了3个三维数组，每一个三维数组中包含了4个二维数组，每一个二维数组中包含了5个一维数组，每一个一维数组可以有2个整数
    var r5 = Array.ofDim[Int](3, 4, 5, 2)

  }

}

如果每一个一维数组等大，那么推荐使用第三种方式；如果包含的一维数组不等大，使用方式一；如果已知元素，那么使用方式二
ofDim支持多维数组：一维~五维数组。Scala中不推荐超过5维的数组

练习：输入一个数字n表示行数，输出杨辉三角的前n行

package com.fesco.array

import scala.io.StdIn

object DimensionExec {

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

    /*
    1
    1 1
    1 2 1
    1 3 3 1
    1 4 6 4 1
    ...
     */
    // 获取整数n
    val n = StdIn.readInt()
    // 定义二维数组
    val arr = new Array[Array[Int]](n)
    // 遍历数组
    for (i <- 0 until n) {
      // 初始化第i行一维数组
      arr(i) = new Array[Int](i + 1)
      // 填充元素
      for (j <- 0 to i) {
        // 每一行第一个或者最后一个元素是1
        if (j == 0 || j == i) arr(i)(j) = 1
        else arr(i)(j) = arr(i - 1)(j) + arr(i - 1)(j - 1)
      }
      println(arr(i).mkString("\t"))
    }

  }

}

列表

不可变列表(`List`)

在Scala中，通过List来定义不可变列表，需要注意的是，List本身是一个抽象类，所以并不能直接使用List来构建对象，需要使用它的伴生对象来构建

package com.fesco.list

import scala.::

object ListDemo {

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

    // 方式一
    val list = List[Int](2, 3, 4, 5, 6)
    println(list)
    val list2 = List.apply(2, 3, 4, 5, 6)
    println(list2)

    // 方式二：
    // :: 在list之前来追加数据
    val list3 = 1 :: list
    println(list3)

    // 方式三：
    // Nil是List的子类，表示一个空列表
    val list4 = Nil
    println(list4)

    // 方式四：
    val list5 = 1 :: 2 :: 3 :: 4 :: Nil
    println(list5)
 
  }

}

List被sealed修饰，说明List是一个密封类，那么就意味着List的子类必须和List处在同一个scala文件中，即List无法直接扩展

基本操作

package com.fesco.list

object ListDemo2 {

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

    val list = List[Int](3, 4, 8, 1, 5, 9, 7)

    // 获取指定下标位置上的元素
    // 底层实际上是调用了父特质LinearSeq中的apply函数
    println(list(2))
    // 等价于
    println(list.apply(2))
    // 获取第一个元素
    // println(list(0))
    // 等价于
    println(list.head)
    // 获取最后一个元素
    println(list.last)
    // 追加一个元素 - 产生一个新的列表
    // val r1 = list :+ 6
    val r1 = list.:+(6)
    println(r1)
    // 在头部追加元素
    // 从右向左计算
    val r2 = 1 +: list
    // val r2 = list.+:(1)
    // 当出现:的时候，:对着谁就从谁开始计算
    // 如果两边都有:，那么从右向左计算
    // 错误的写法：list +: 1
    println(r2)
    // 或者
    // val r3 = list.::(1)
    val r3 = 1 :: list
    // list :: 1
    println(r3)
    // 构建了列表
    // 从右到左：先构建空列表List()，然后头部拆入5，在插入4
    val r4 = 1 :: 2 :: 3 :: 4 :: 5 :: List()
    // 等价于
    val r5 = 1 :: 2 :: 3 :: 4 :: 5 :: Nil
    println(r4)
    println(r5)

  }

}

列表的合并

package com.fesco.list

object ListDemo3 {

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

    val list1 = List[Int](1, 2, 3, 4)
    val list2 = List[Int](5, 6, 7, 8)

    // 合并列表
    val r1 = list1 ++ list2
    println(r1)
    val r2 = list1 ++: list2
    println(r2)
    val r3 = list1 :++ list2
    println(r3)
    val r4 = list1.concat(list2)
    println(r4)
    val r5 = list1 ::: list2
    println(r5)

  }

}

可变列表(`ListBuffer`)

Scala中，通过ListBuffer来定义可变列表

package com.fesco.list

import scala.collection.mutable.ListBuffer

object ListBufferDemo {

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

    // 方式一
    // 调用ListBuffer类的主构造器
    val buffer1 = new ListBuffer[Int]()
    buffer1 += 4
    println(buffer1)
    // 方式二
    // 调用了ListBuffer伴生对象中的apply函数
    val buffer2 = ListBuffer[Int](1, 2, 3, 4, 5)
    println(buffer2)

  }

}

基本操作

package com.fesco.list

import scala.collection.mutable.ListBuffer

object ListBufferDemo2 {

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

    val list = ListBuffer[Int](1, 2, 3, 4, 5)

    // 在尾部追加元素
    list += 4
    list append 7
    println(list)
    // 在头部插入元素
    list prepend 0
    // list.+=:(2)
    2 +=: list
    println(list)
    // 在指定下标位置上插入元素
    list.insert(3, 6)
    println(list)
    // 修改指定位置上的元素
    list(2) = 10
    list.update(3, 12)
    println(list)
    // 删除指定下标位置上的元素
    list.remove(0)
    println(list)
    // 删除指定的元素(第一个)
    list -= 3
    println(list)

  }

}

合并列表

package com.fesco.list

import scala.collection.mutable.ListBuffer

object ListBufferDemo3 {

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

    val list1 = ListBuffer[Int](1, 2, 3)
    val list2 = ListBuffer[Int](4, 5, 6)

    // 将list1和list2合并
    // ++合并之后产生一个新的列表，而不是修改原列表
    val r1 = list1 ++ list2
    println(r1)
    // 要求：将list2中的数据合并到list1中
    list1 ++= list2
    println(list1)
    // 获取list1中有而list3中没有的数据 - 差集
    val list3 = ListBuffer[Int](1, 3, 5, 7)
    list1 --= list3
    println(list1)

  }

}

原文地址：https://blog.csdn.net/m0_51388399/article/details/137832255

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：flink on k8s部署
下一篇：记录一下hive启动metestore服务时报错

第9章综合案例————众成远程教育
制作“众成远程教育”网页，本章项目页面布局要求如下:页面要求有最外层的 div-al，第二层嵌套上中下3行区域，分别为div-top.div-main和 div-footer。而 div-main 又
阅读更多2024-11-17
Python3语法基础（全，带示例）
信息技术类，对口高考，Python，教师：施恒锋
阅读更多2024-11-17
【鸿蒙开发】第十四章 Web组件的使用、基本属性与事件
Web组件用于在应用程序中显示Web页面内容，为开发者提供页面加载、页面交互、页面调试等能力。页面加载：Web组件提供基础的前端页面加载的能力，包括：加载网络页面、本地页面、html格式文本数据。页面
阅读更多2024-11-17
python基础知识（五）——文件上传
python基础知识（五）——文件上传
阅读更多2024-11-17
如何在uniapp中获取和修改Web项目的Cookie
在uniapp开发Web项目时，操作Cookie是常见的需求。本文将介绍如何在uniapp中获取和修改Web项目的Cookie，且不设置过期时间。
阅读更多2024-11-17
时钟之Canvas+JS版
上一篇介绍使用CSS+JS方式实现，但元素泰国单一。此篇将以HTML5的canvas标签结合JS来实现。HTML代码JS代码//计时器//钟表半径//时针刻度宽度//分针刻度宽度//时针宽度//分针宽
阅读更多2024-11-17
AI测试的主要研究方向介绍
这个框架将支持对不同主题的基础测试数据集进行文本分词、图像标注、特征筛选等加工处理，为不同AI医疗产品提供定制化的测试数据，解决医学数据模块的通用性与特定测试数据集需求之间的冲突，确保测试数据集既具有
阅读更多2024-11-17
CSS盒子的定位＞（下篇）#固定定位#笔记
固定定位其实是绝对定位的子类别，一个设置了的元素是相对于视窗固定的，就算页面文档发生了滚动，它也会一直待在相同的地方。
阅读更多2024-11-17
doris udf -- 避免使用递归CTE
在部门表里有部门id (dept_id) 和父部门id (parent_id) ，父部门id同时也是部门id。现在要查部门id下所有的子部门id，但是不知道部门层级，部门关系可能也会调整。
阅读更多2024-11-17
前端知识点---this的用法 , this动态绑定(Javascript)
在JavaScript中，this 是一个非常重要但是呢也让人难搞明白的关键字。**它的值不是在编写代码时静态确定的，而是在代码运行时动态绑定的。**这非常重要下面讲一下它 .在全局作用域中（即不在
阅读更多2024-11-17

Scala详解（5）

Scala

集合

概述

数组

不可变数组(Array)

可变数组(ArrayBuffer)

转换

多维数组

列表

不可变列表(List)

可变列表(ListBuffer)

相关文章

不可变数组(`Array`)

可变数组(`ArrayBuffer`)

不可变列表(`List`)

可变列表(`ListBuffer`)