定长数组

基本演示

int类型的数组默认都是0

  1. // 创建长度为10的int数组 等价于java:  new Int[10]
  2.     val arr = new Array[Int](10)
  3.     println(arr.mkString(", "))

输出

0, 0, 0, 0, 0, 0, 0, 0, 0, 0

创建数组的时候初始化一些值

    val arr = Array[Int](1, 2, 3)
    println(arr.mkString(", "))

输出

1, 2, 3

scala没有自己定义数组, 底层就是java的数组

    //数组的长度实例化后就是固定的,长度不可变,但是元素可以变.
    val arr: Array[Int] = Array[Int](1, 2, 3, 4)
    //获取数组0号索引的元素
    println(arr(0))  // 结果 1 
    // 给数组0号索引赋值
    arr(0) = 100
    println(arr(0))  // 结果 100
    //给数组里面的所有的元素拼成字符串,用逗号拼接
    println( arr.mkString(", "))  //结果: 100, 2, 3, 4

添加元素

给数组添加元素,返回的是一个新的数组(地址值发生变化了).

:+ 一般用于给不可变的集合添加单个元素在末尾 (+)
+: 一般用于给不可变的结集合加单个元素到头部 (+)

    //数组的长度实例化后就是固定的,长度不可变,但是元素可以变.
    val arr: Array[Int] = Array[Int](1, 2, 3, 4)
    //添加到尾部
    val arr1: Array[Int] = arr :+ 100
    println(arr1.mkString(",")) //结果 1,2,3,4,100
    //添加到头部
    val arr12 = 100 +: arr
    println(arr12.mkString(",")) //结果 100,1,2,3,4
    val arr13 = arr.+:(100)
    println(arr13.mkString(",")) //结果 100,1,2,3,4

合并两个数组

    val arr: Array[Int] = Array[Int](1, 2, 3, 4)
    val arr2: Array[Int] = Array[Int](5, 6, 7, 8)
    val arr3: Array[Int] = arr ++ arr2 // 合并两个数组
    println(arr3.mkString(",")) // 输出 1,2,3,4,5,6,7,8

可变数组

ArrayBuffer可变数组底层还是不可变的数组,只不过是在不可变的数组里面增加了一些API,你在增加元素的时候底层是重新实例化一个新的数组,

创建方式

可变数组就不用指定长度了

1.ArrayBuffer(1,2,3)// 初始化可变数组的时候赋值
2.ArrayBuffer.apply(1, 2, 3, 4) //初始化可变数组的时候赋值
2. new ArrayBuffer[Int]() //初始化一个空的可变数组

打印数组

    val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 1)
    println(buffer1)

Scala底层已经给toString覆写的特别好了,所以不需要再写

输出

ArrayBuffer(1, 2, 3, 4, 1)

添加元素

生成新的可变数组并且添加元素

    val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)

    //这种方式添加都会产品新的可变数组对象
    var b2 = buffer1 :+ 10 //在后面加
    var b3 = 5 +: buffer1 //在前面加
    println(b2)

输出

ArrayBuffer(1, 2, 3, 10)
ArrayBuffer(5, 1, 2, 3)

在原来的数组里面添加元素

    val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)
    //在原来的集合的尾部添加元素 +=
    buffer1 += 100
    //在原来的集合的头部添加元素  +=:
    200 +=: buffer1
    println(buffer1)

输出

ArrayBuffer(200, 1, 2, 3, 100)

合并两个可变数组

合并两个可变数组并且生成新的数组

    val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)
    val buffer2: ArrayBuffer[Int] = ArrayBuffer(4, 5, 6)
    var result = buffer1 ++ buffer2
    println(result)

会生成一个新的集合

结果:

ArrayBuffer(1, 2, 3, 4, 5, 6)

把第二个数组的值合并到第一个数组里面

    val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)
    val buffer2: ArrayBuffer[Int] = ArrayBuffer(4, 5, 6)
    buffer1 ++= buffer2
    println(buffer1)

此时数据都在第一个可变数组里面了

输出

ArrayBuffer(1, 2, 3, 4, 5, 6)

把第一个数组的值合并到第二个里面

注意, 上面是给元素合并到第一个数组里面,这个是给元素合并到第二个数组里面

    val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)
    val buffer2: ArrayBuffer[Int] = ArrayBuffer(4, 5, 6)
    buffer1 ++=: buffer2
    println(buffer2)

输出

ArrayBuffer(1, 2, 3, 4, 5, 6)

删除

删除匹配的元素

下面是删除数组里面的1 这个元素,如果有两个1的话,只是删除从左往右的第一个匹配的元素.

这种方式一般用于set集合,因为set集合里面的数据都是不重复的.

    val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3,1)
    buffer1 -= 1 //删除  -=
    println(buffer1)

输出

ArrayBuffer(2, 3, 1)

移除两个可变数组共同的元素(求差集)

    val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)
    val buffer2: ArrayBuffer[Int] = ArrayBuffer(1, 5, 6)
    buffer1 --= buffer2  //移除操作
    println(buffer1)

输出

ArrayBuffer(2, 3)

移除可变数组里面的匹配的元素

只是移除从左往右第一个匹配的元素.

    val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 1)
    buffer1 -= (1, 2)
    println(buffer1)

输出

ArrayBuffer(3, 1)

去重复数据

思路,转成Set集合再转回来

    val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 1)
    var result = buffer1.toSet.toArray.toBuffer
    println(result)

输出

ArrayBuffer(1, 2, 3)

定长数组和可变数组互相转换

    // 定长数组转成可变数组
    val arr1 = Array(30, 50, 70, 60, 10, 20)
    val buffer: mutable.Buffer[Int] = arr1.toBuffer
    println(buffer)
    // 可变数组转成定长数组
    val b: ArrayBuffer[Int] = ArrayBuffer(10, 20)
    println(b.toArray.mkString(","))

输出

ArrayBuffer(30, 50, 70, 60, 10, 20)
10,20

多维数组

多维数组和Java的二维数组是一样的,用的比较少

  //ofDim 纬度的意思
    //二维数组
    val arr: Array[Array[Int]] = Array.ofDim[Int](2, 3)
    // 三维数组
    val arr2: Array[Array[Array[Int]]] = Array.ofDim[Int](2, 3, 4)
    println(arr(0)(1)) // 访问零号元素数组里面的1号元素的值
    // 遍历二维数组
    for (a1 <- arr) {
      for (elem <- a1) {
        println(elem)
      }
    }

输出

0
0
0
0
0
0
0