scala数据结构——数组

首先贴一下Java中集合和数组的概念区别：

（1）数组的大小固定，并且元素必须是同一类型；

（2）集合中可以存储不同数据类型的元素

（3）Java里的数组是[]，集合是{}，scala中数组和集合都是()

数组和集合的区别

目录

一、定长数组Array

二、变长数组ArrayBuffer

三、遍历数组

四、原数组基础上运算出新数组

五、数组的常用算法

六、数组转换（scala数组 <-> java数组）

七、数组常用方法

---

一、定长数组Array

//定长数组
object ArrayDemo1 {
    def main(args: Array[String]): Unit = {
        //创建一个长度为10的整形数组
        val arr1 = new Array[Int](10)//元素初始化为0
        var arr2 = new Array[String](10) //元素初始化为null

        //创建长度为2的String类型数组
        val arr3 = Array("a", "b")

        //访问数组中的元素，用()
        println(arr1(0))
        println(arr2(1))
        println(arr3(1))
    }
}

打印结果：

0
null
b

二、变长数组ArrayBuffer

数组长度能根据需求变化，用ArrayBuffer，类似Java中的ArrayList

//变长数组
object ArrayDemo2 {
    def main(args: Array[String]): Unit = {
        //1. 创建数组方式一
        val arr1 = new ArrayBuffer[Int]()
        //创建数组方式二
        //        val arr2 = ArrayBuffer[Int]

        //2. 使用+=在尾端添加元素
        arr1 += 1
        //在尾端同时加多个元素
        arr1 += (2, 3, 4, 5)
        println(arr1)

        //3. 使用++=追加集合
        arr1 ++= Array(10, 20, 30)
        println(arr1)

        //4. 移除开头和最后2个元素trim
        arr1.trimStart(2)
        arr1.trimEnd(2)
        println(arr1)

        //5. 在指定下标为2的位置插入元素和集合insert
        arr1.insert(2, 60)
        println(arr1)
        arr1.insert(2, 100, 200, 300)
        println(arr1)

        //5. 移除元素remove
        //移除下标为1的元素
        arr1.remove(1)
        println(arr1)
        //从下标为1的位置开始，移除3个元素
        arr1.remove(1, 3)
        println(arr1)

        //6. 变长数组转化成定长数组
        val arr = arr1.toArray
        println(arr.mkString(", "))
    }
}

打印结果

ArrayBuffer(1, 2, 3, 4, 5, 10, 20, 30)
ArrayBuffer(3, 4, 5, 10)
ArrayBuffer(3, 4, 60, 5, 10)
ArrayBuffer(3, 4, 100, 200, 300, 60, 5, 10)
ArrayBuffer(3, 100, 200, 300, 60, 5, 10)
ArrayBuffer(3, 60, 5, 10)
3, 60, 5, 10

三、遍历数组

//遍历数组
object ArrayDemo3 {
    def main(args: Array[String]): Unit = {
        //1. for循环遍历数组
        val arr1 = Array(10, 20, 30, 40)
        for (i <- 0 until arr1.length) {
            println(i + ":" + arr1(i))
        }
        println("----------")

        //2. for循环遍历数组缓冲
        val arr2 = arr1.toBuffer
        for (i <- 0 until arr2.length) {
            println(i + ":" + arr2(i))
        }
        println("----------")

        //3. 遍历的时候改变步长
        for (i <- 0 until(arr2.length, 2)) {
            println(i + ":" + arr2(i))
        }
        println("----------")

        //4. 从后向前遍历
        for (i <- (0 until(arr2.length, 2)).reverse) {
            println(i + ":" + arr2(i))
        }
        println("----------")

        //5. 直接遍历
        for (ele <- arr2) {
            println(ele)
        }
    }
}

打印结果

0:10
1:20
2:30
3:40
----------
0:10
1:20
2:30
3:40
----------
0:10
2:30
----------
2:30
0:10
----------
10
20
30
40

四、原数组基础上运算出新数组

yield后是表达式；if是添加守卫语句

将if守卫和yield运算后的结果，生成一个新数组，就叫数组转换，不会改变原数组或缓冲

object ArrayDemo4 {
    def main(args: Array[String]): Unit = {
        val arr = Array(1,2,3,4,5,6).toBuffer

        //遍历arr中每一个元素，并按yield后的表达式进行计算，将运算结果以新数组arr2表示
        var arr2 = for(ele <- arr) yield ele * ele

        //增加守卫语句if，打印偶数部分
        var arr3 = for(ele <- arr if ele % 2 == 0) yield ele * ele
        println(arr2)
        println(arr3)
    }
}

打印结果

ArrayBuffer(1, 4, 9, 16, 25, 36)
ArrayBuffer(4, 16, 36)

五、数组的常用算法

数组元素之间求和、求最大值、最小值，数组转为String，数组排序

其中sortWith可以自定义函数进行排序，sortBy可以按维度进行排序

//数组的常用算法
object ArrayDemo5 {
    def main(args: Array[String]): Unit = {
        var arr = Array(10, 21, 32, 4, 15, 46, 17)
        //1. 数组元素之和、最大值、最小值
        println(arr.sum)
        println(arr.max)
        println(arr.min)
        println("------------------")

        //2. 把数组转成字符串，元素之间以,隔开
        println(arr.mkString)
        println(arr.mkString(", "))
        println("------------------")

        //3. 默认升序排列，sorted
        val arr1 = arr.sorted
        println(arr1.mkString(", "))

        //4. 降序排列，sortWith
        val arr2 = arr.sortWith(_ > _)
        println(arr2.mkString(", "))
    }
}

打印结果

145
46
4
------------------
1021324154617
10, 21, 32, 4, 15, 46, 17
------------------
4, 10, 15, 17, 21, 32, 46
46, 32, 21, 17, 15, 10, 4

六、数组转换（scala数组 <-> java数组）

（1）转换需要引入两个包：

scala数组转java数组的包是import scala.collection.JavaConversions.bufferAsJavaList

java数组转scala的包是import scala.collection.JavaConversions.asScalaBuffer

（2）scala数组和java数组的区别：

scala数组可调用的方法有：insert、remove、fold、sorted、sortWith、sortBy、max、min、sum、mkString、toBuffer等

java数组可调用的方法有：add、remove、set、size、index of、toArray、sort、get、isEmpty等

（3）类型的声明：

scala数组 -> java数组，需要声明类型为java.util.List[Int]

java数组 -> scala数组，需要声明类型为mutable.Buffer[Int]

//这个包把scala数组隐式转成java数组
import scala.collection.JavaConversions.bufferAsJavaList
import scala.collection.mutable
//这个包把java数组隐式转成scala数组
import scala.collection.JavaConversions.asScalaBuffer
import scala.collection.mutable.ArrayBuffer


object ArrayDemo7 {
    def main(args: Array[String]): Unit = {
        //1. scala数组转java数组
        val scalaArr = ArrayBuffer(10, 20, 30)
        //需要声明为java.util.List类型，隐式转换由bufferAsJavaList来完成
        val javaArr: java.util.List[Int] = scalaArr
        println(javaArr)

        //2. java数组转scala数组
        val javaList = new java.util.ArrayList[Int]()
        javaList.add(1)
        javaList.add(20)
        //需要声明为mutable.Buffer类型，隐式转换由asScalaBuffer来完成
        val scalaBuffer: mutable.Buffer[Int] = javaList
        println(scalaBuffer)
    }
}

打印结果

[10, 20, 30]
Buffer(1, 20)

从结果上也可以看出，java数组是[]，scala数组是()

七、数组常用方法

1. ++ 连接两个数组
2. ++: 连接两个数组
3. :+ 一个数组连接一个元素
4. +: 一个数组连接一个元素
5. /: 左折叠
6. :\ 右折叠
7. head 第一个元素(重要)
8. tail 除第一个元素为其他元素组成的数组(重要)
9. last 最后一个元素
10. max 找到最大值
11. min 找到最小值

object ArrayDemo8 {
    def main(args: Array[String]): Unit = {
        val arr1 = Array(10, 20, 30, 40, 50)
        val arr2 = Array(1, 2, 3, 4)
        println((arr1 ++ arr2).mkString(", "))
        println((arr2 ++: arr1).mkString(", "))
        println((arr1 :+ 7).mkString(", "))
        println((8 +: arr1).mkString(", "))
        println(arr1.head)
        println(arr1.tail.mkString(", "))
        println(arr1.last)
        println(arr1.max)
        println(arr1.min)
        println(arr1.sum)
    }
}

打印结果

10, 20, 30, 40, 50, 1, 2, 3, 4
1, 2, 3, 4, 10, 20, 30, 40, 50
10, 20, 30, 40, 50, 7
8, 10, 20, 30, 40, 50
10
20, 30, 40, 50
50
50
10
150