Scala-数组（Array）、列表（List）

open_test01

已于 2023-03-01 17:48:10 修改

阅读量739

点赞数

分类专栏： Scala 文章标签： scala 开发语言后端

于 2023-02-28 11:33:01 首次发布

本文链接：https://blog.csdn.net/dafsq/article/details/129249684

版权

Scala 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

数组

不可变数组

val arr1 = new Array[Int](10)

new 是关键字
[Int]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定 Any
(10)，表示数组的大小，确定后就不可以变化

判断元素是否在数组中

arr.contains(i)

不可变数组定义和访问

object test {
  def main(args: Array[String]): Unit = {
   //创建不可变数组
    val arr1 : Array[Int] = new Array[Int](10)
    //另一种创建方式
    val arry2 = Array(1,2,3,4,5,6,7,8,9)
    //访问数组中的元素
    println(arry2(1))
    //赋值
    arr1(0) = 10
    arr1(1) = 11
  }
}

不可变数组遍历

object test {
  def main(args: Array[String]): Unit = {
   //创建不可变数组
    val arry = Array(1,2,3,4,5,6,7,8,9,10)

    //数组遍历1普通循环
    for (i <- 0 until arry.length){
      println(arry(i))
    }

    //数组遍历2 使用indices
    for (i <- arry.indices) {
      println(arry(i))
    }

    //数组遍历3 直接遍历所有元素（增强for循环）
    for (i <- arry){
      println(i)
    }

    //数组遍历4 迭代器
    val iter = arry.iterator
    while (iter.hasNext){
      println(iter.next())
    }

    //数组遍历5 foreach方法
    arry.foreach( (i : Int) => println(i))
                                            //致简原则 arry.foreach(println)

    //所有数据转换成String拼接到一起
    println(arry.mkString("_")) //括号内为连接符
  }
}

不可变数组添加元素

object test {
  def main(args: Array[String]): Unit = {
   //创建不可变数组
    val arry = Array(1,2,3,4,5,6,7,8,9,10)

    //向后添加元素
    val newArry1 =arry.:+(11) //使用 ：加号放冒号后代表向后添加 ":+()"方法进行添加 并克隆新的添加对象后的数组
    println(newArry1.mkString(" "))

    //向前添加元素
    val newArry2 = arry.+:(0) //使用 ：加号放冒号前代表向前添加 "+:()"方法进行添加 并克隆新的添加对象后的数组
    println(newArry2.mkString(" "))

    //简化添加方法
    val newArry3 = newArry1 :+ 15 //加号放冒号后代表向后添加
    val newArry4 = 20 +: newArry1 //添加数在前代表向前添加 
    
    //连续叠加
    val newArry5 = 10 +: 20 +: newArry1 :+ 50 :+ 60
    println(newArry5.mkString(" "))

  }
}

可变数组

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

[Any]存放任意数据类型
(3, 2, 5)初始化好的三个元素
ArrayBuffer 需要引入 scala.collection.mutable.ArrayBuffer

 //创建可变数组
    val arry1 : ArrayBuffer[Int] = new ArrayBuffer[Int]()

    val arry2 = ArrayBuffer(21,22,23,24,25,26,27,28,29,30)

    //输出
    println(arry2.mkString(" "))
    println(arry2)

    //访问元素 对数组操作需要注意不要对数组越界
    println(arry2(0))

可变数组添加元素

 //创建可变数组
   val arr = ArrayBuffer(1,2,3,4,5,6,7,8,9,10)
   val arr2 = new ArrayBuffer[Int]

    //添加元素
      //  末尾添加
   arr += 19 //可变数组中使用+=来给末尾添加元素
   println(arr)
      //向前添加
    22 +=: arr
    println(arr)

    //使用append方法添加
    arr.append(20)//向后添加
    arr.prepend(1)//向前添加
    arr.insert(1,10) //任意索引位置添加
    arr.insertAll(1,arr2)//任意索引位置追加数组
    arr.appendAll(arr2) //向前追加数组
    arr.prependAll(arr2)//向后追加数组
    println(arr)

可变数组删除元素

//创建可变数组
   val arr = ArrayBuffer(1,2,3,4,5,6,7,8,9,10)

    //删除元素
   arr.remove(1,2) //删除索引元素remove(索引,删除个数)

   arr -= 13 //"-="代表删除数组中的某一个元素
    println(arr)

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

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

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

 //转换为不可变数组
    val newArry = arr.toArray
    println(newArry.mkString(" "))
    println(newArry)

二维数组

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

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

   //创建二维数组
    val arry = Array.ofDim[Int](2,3) //创建2行3列的二维数组
    
    //访问元素
    arry(1)(0) = 19 //第2行第1个元素位置赋值19
    
    //遍历打印
    for (i <- 0 until arry.length; j <- 0 until arry(i).length){ //双重for循环遍历二维数组
      println(arry(i)(j))
    }
    //使用indices作为限制进行循环打印
    for (i <- arry.indices; j <- arry(i).indices){ //双重for循环遍历二维数组
      println(arry(i)(j) +"\t")
      
      if (j == arry(i).length -1){ //如果到了第一行数组最后一位元素 则换行（美观）
        println()
      }
    } 
    //使用foreach遍历
    arry.foreach(i => i.foreach(println))

列表

不可变 List

List 默认为不可变集合
创建一个 List（数据有顺序，可重复）
遍历 List （4）List 增加数据
集合间合并：将一个整体拆成一个一个的个体，称为扁平化
取指定数据
空集合 Nil

//创建不可变列表
    val lis = List(1,2,3,4,5,6,7,8,9,10) //不使用new来创建
    println(lis)

    //访问元素
    println(lis(0))

    //遍历
    lis.foreach(println)

    //添加元素
    val lis2 = lis.+:(10)//向前添加
    val lis3 = lis.:+(10)//向后添加

    val lis4 = lis.::(50)//添加到列表前面
    println(lis4)
    
    val lis5 = Nil.::(1)//定义空列表向前添加一个元素

合并列表

//创建不可变列表
    val lis1 = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    val lis2 = List(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1)

    //创建合并列表
    val lis3 = lis1 ::: lis2
    println(lis3)
    val list4 = lis1 ++ lis2

可变列表

ListBuffer

 //创建可变列表
    val lis1 = new ListBuffer[Int]()
    val lis2 = ListBuffer(1,2,3,4,5,6,7,8,9)
    
    //添加元素
    lis2.append(10)
    lis2.prepend(0)
    lis2.insert(1,10)
    
    //连接列表
    val lis3 = lis2 ++ lis1
    
    //修改元素
    lis2(3) = 30 // lis2(索引位置) = 值
    lis2.update(0,20) //lis2.update(索引位置,值)
    
    //删除元素
    lis2.remove(2)//索引
    lis2 -= 25 //具体值