首先贴一下Java中集合和数组的概念区别：
（1）数组的大小固定，并且元素必须是同一类型；
（2）集合中可以存储不同数据类型的元素
（3）Java里的数组是[]，集合是{}，scala中数组和集合都是()
目录
一、定长数组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数组是()
七、数组常用方法
++连接两个数组++:连接两个数组:+一个数组连接一个元素+:一个数组连接一个元素/:左折叠:\右折叠head第一个元素(重要)tail除第一个元素为其他元素组成的数组(重要)last最后一个元素max找到最大值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