Scala基础知识

数组

不可变数组

第一种方式定义数组

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

（1）new 是关键字

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

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

案例实操

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

    //（1）数组定义
    val arr01 = new Array[Int](4)
    println(arr01.length) // 4
    //（2）数组赋值
    //（2.1）修改某个元素的值
    arr01(3) = 10
    //（2.2）采用方法的形式给数组赋值
    arr01.update(0, 1)
    //（3）遍历数组
    //（3.1）查看数组
    println(arr01.mkString(","))
    //（3.2） 普 通 遍 历
    for (i <- arr01) {
      println(i)
    }
      //（3.3）简化遍历
      def printx(elem: Int): Unit = {
        println(elem)
      }
      arr01.foreach(printx)
      // arr01.foreach((x)=>{println(x)})
      // arr01.foreach(println(_))
      arr01.foreach(println)
      //（4）增加元素（由于创建的是不可变数组，增加元素，其实是产生新的数组）
      println(arr01)
      val ints: Array[Int] = arr01 :+ 5
      println(ints)
  }
}

第二种方式定义数组val arr1 = Array

1. (1, 2)在定义数组时，直接赋初始值
2. 使用apply 方法创建数组对象

案例实操

object TestArray1 {
  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

案例实操

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) // 5

  }
}

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

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

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

转换函数：不可变数组可通过to array转换为可变数组，反之亦然。
转换过程：转换过程中原始数组不会发生变化，而是生成一个新的数组。

object TestArrayBuffer1 {
  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)
  }
}

多维数组

1. 多维数组定义val arr = Array.ofDim[Double](3,4)

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

案例实操

object DimArray {
  def main(args: Array[String]): Unit = {
    //（1）创建了一个二维数组, 有三个元素，每个元素是，含有 4 个元素一维数组()
    val arr = Array.ofDim[Int](3, 4)
    arr(1)(2) = 88
    //（2）遍历二维数组
    for (i <- arr) { //i 就是一维数组
      for (j <- i) {
        print(j + " ")
       }
      println()
    }
  }
}

创建方法：使用array of关键字创建多维数组，如二维数组double[3][4]。
遍历方法：使用嵌套的for循环遍历多维数组，通过行索引和列索引访问特定元素。
列表（List）
不可变列表：默认情况下，列表是不可变的，可以包含重复元素。

1. 说明
   1. List 默认为不可变集合
   2. 创建一个 List（数据有顺序，可重复）
   3. 遍历 List
   4. List 增加数据
   5. 集合间合并：将一个整体拆成一个一个的个体，称为扁平化
   6. 空集合 Nil

案例实操

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)
    //（6）取指定数据
    println(list(0))
    //（3）遍历 List
    //list.foreach(println)
    //list1.foreach(println)
    //list3.foreach(println)
    //list4.foreach(println)
    list5.foreach(println)
  }
}

可变列表：通过list buffer创建，可以进行添加、修改、删除操作。

1. 说明
   1. 创建一个可变集合 ListBuffer
   2. 向集合中添加数据

添加数据：可以通过+=、append、insert等方式添加数据。
遍历与输出：使用for each循环遍历并输出列表元素。
集合（Set）

默认情况下， Scala 使用的是不可变集合， 如果你想使用可变集合， 需要引用scala.collection.mutable.Set 包

不可变集合：数据无序且不可重复，使用set关键字创建。

1. 说明
   1. 创建不可变集合 Map
   2. 循环打印
   3. 访问数据
   4. 如果 key 不存在，返回

可变集合：通过mutable set创建，支持添加、删除操作。

1. 说明
   1. 创建可变集合
   2. 打印集合
   3. 向集合增加数据
   4. 删除数据
   5. 修改数据

遍历与输出：使用for each循环遍历并输出集合元素。

映射（Map）
不可变映射：使用map关键字创建，键值对形式存储数据。
可变映射：通过mutable map创建，支持添加、删除、修改操作。
访问数据：通过键获取值，如果键不存在则返回默认值（如0）。
遍历与输出：使用for each循环遍历并输出映射中的键值对。
数据类型声明：在创建列表、集合、映射时，需要明确数据类型，如int、double等。
索引从零开始：无论是列表、数组还是映射，索引都是从零开始的。
可变Map的操作
可变Map的基本操作包括删除数据（通过指定键）、修改数据（指定键对应值）等。

元组

是将多个无关的数据封装为一个整体，称为元组。

元组可容纳各种类型的数据，最大只能有22个元素。
声明方式为元素间用逗号分隔，例如 TALE(40, "bob", true) 。
访问元组元素可通过点符号（如 .1 访问第一个元素）或索引（索引从零开始）。
可用迭代器（for循环）和 for each 循环遍历元组元素，还提到Map中的键值对本质也是元组形式。

案例

​
object TestTuple {

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

        //（1）声明元组的方式：(元素 1，元素 2，元素 3)
        val tuple: (Int, String, Boolean) = (40,"bobo",true)

        //（2）访问元组
        //（2.1）通过元素的顺序进行访问，调用方式：_顺序号println(tuple._1)
        println(tuple._2) println(tuple._3)

        //（2.2）通过索引访问数据println(tuple.productElement(0))
    
        //（2.3）通过迭代器访问数据
        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))

        map.foreach(tuple=>{println(tuple._1 + "=" + tuple._2)})
    }
 }

​

集合

基本属性和常见操作：

1. 包括集合长度（.length 或 .size）
2. 循环遍历（for each 和 for 循环）
3. 生成字符串（.mkString ）
4. 判断是否包含某个值。
5. 反转
6. 取前（后）n 个元素
7. 去掉前（后）n 个元素
8. 并集
9. 交集
10. 差集
11. 拉链（数量需相等）
12. 滑窗（较少用到）

集合计算简单函数：

1. 对集合求和
2. 求乘积
3. 求最大值
4. 最小值
5. 排序（按大小排序 .sorted 、按绝对值排序 .sortBy(identity,Ordering.Int.abs)
6. 升序排序 .sortBy(identity,Ordering.Int.asc)
7. 降序排序 .sortBy(identity,Ordering.Int.desc) ）

案例实操

object TestList1 {
  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))
  }
}