自学内容网 自学内容网

Scala详解(5)

Scala

集合

概述

  1. 集合本质上就是一个用于存储1个到多个数据的容器。在Scala中,集合可以分为三大类:Seq(序列),Set(集合)和Map(映射)。基于这三大类,衍生出来众多的子类

    1. 序列:元素有序可重复

    2. 集合:元素无序不可重复

    3. 映射:键值对结构数据

  2. 在Scala中,所有的集合都混入了Iterable特质,意味着所有的集合都可以被迭代遍历

  3. Scala中的集合分为可变集合(scala.collection.mutable)和不可变集合(scala.collection.immutable)

    1. 所谓的不可变集合,指的是集合被创建好之后,长度不可变,且其中的元素也不能改变。如果对不可变集合中的元素进行增删操作,那么不会改变原集合,而是会产生一个新的集合

    2. 所谓的可变集合,指的是集合创建好之后,依然可以对元素进行增删操作,并且不会产生新集合,而是修改原集合

数组

不可变数组(Array)
  1. 不可变数组定义好之后,长度不能发生变化,元素也不能增删;如果增删元素,那么会产生一个新的数组

  2. 定义方式

    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(","))
    ​
      }
    ​
    }
  3. 应用一

    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)
    ​
    ​
      }
    ​
    }
  4. 应用二

    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(", "))
    ​
      }
    ​
    }
  5. 应用三

    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(", "))
    ​
      }
    ​
    }
  6. 练习:猴子报数。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)
  1. 可变数组,类似于Java中的ArrayList,长度可以发生变化,并且可以对数组中的元素来进行增删

  2. 定义格式

    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)
    ​
      }
    ​
    }
  3. 基本操作

    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)
​
  }
​
}
多维数组
  1. 定义格式

    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)
    ​
      }
    ​
    }
  2. 如果每一个一维数组等大,那么推荐使用第三种方式;如果包含的一维数组不等大,使用方式一;如果已知元素,那么使用方式二

  3. ofDim支持多维数组:一维~五维数组。Scala中不推荐超过5维的数组

  4. 练习:输入一个数字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)
  1. 在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)
     
      }
    ​
    }
  2. List被sealed修饰,说明List是一个密封类,那么就意味着List的子类必须和List处在同一个scala文件中,即List无法直接扩展

  3. 基本操作

    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)
    ​
      }
    ​
    }
  4. 列表的合并

    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)
  1. 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)
    ​
      }
    ​
    }
  2. 基本操作

    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)
    ​
      }
    ​
    }
  3. 合并列表

    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)!