不可变数组
创建
- 通过new创建: new Array[元素类型](数组的长度)
val arr=new Array[Int](5)
2.通过apply方法: Array[元素类型](初始元素,...)
val arr= Array[Int](1,2,3,4,5)
查看不可变数组支持哪些api
打开终端，输入scala
scala> val arr= Array[Int](1,2,3,4,5)
arr: Array[Int] = Array(1, 2, 3, 4, 5)
scala> arr.
++ filterNot maxBy span
++: find min splitAt
+: flatMap minBy startsWith
/: flatten mkString stringPrefix
:+ fold nonEmpty sum
:\ foldLeft orElse tail
addString foldRight padTo tails
aggregate forall par take
andThen foreach partition takeRight
apply genericBuilder patch takeWhile
applyOrElse groupBy permutations to
array grouped prefixLength toArray
canEqual hasDefiniteSize product toBuffer
clone head reduce toIndexedSeq
collect headOption reduceLeft toIterable
collectFirst indexOf reduceLeftOption toIterator
combinations indexOfSlice reduceOption toList
companion indexWhere reduceRight toMap
compose indices reduceRightOption toSeq
contains init repr toSet
containsSlice inits reverse toStream
copyToArray intersect reverseIterator toTraversable
copyToBuffer isDefinedAt reverseMap toVector
corresponds isEmpty runWith transform
count isTraversableAgain sameElements transpose
deep iterator scan union
diff last scanLeft unzip
distinct lastIndexOf scanRight unzip3
drop lastIndexOfSlice segmentLength update
dropRight lastIndexWhere seq updated
dropWhile lastOption size view
elemManifest length slice withFilter
elemTag lengthCompare sliding zip
endsWith lift sortBy zipAll
exists map sortWith zipWithIndex
filter max sorted
首选需要运行
scala> val arr= Array[Int](1,2,3,4,5)
通过 arr. 再加一个 tab 键
scala> arr.
操作
主要讲解操作符，其他的函数太多了，也没那么多时间和精力一个个敲。
++
++:
+:
/:
:+
:\
- 添加数据【是生成一个新的集合,原集合没有改变】
++
合并两个数组，返回一个新的数组
val arr1= Array[Int](1,2,3)
val arr2= Array[Int](4,5,6)
// 合并
val arr= arr1 ++ arr2
println(arr.toList)
List(1, 2, 3, 4, 5, 6)
除了上面的写法，arr1 ++ arr2 也可以写成 arr1.++(arr2)，只是上面的方式更简洁。
val arr= arr1.++(arr2)
++:
合并两个数组，返回一个新的数组
val arr1= Array[Int](1,2,3)
val arr2= Array[Int](4,5,6)
// 合并
val arr= arr1 ++: arr2
println(arr.toList)
List(1, 2, 3, 4, 5, 6)
感觉和 ++ 没啥区别？如果是 .++:() 就不一样了
表示：:在后，会将数组添加到原数组前面（我觉得挺扯蛋的，至于为啥，只有为马丁了，记住这一点就行了）。
// 合并
val arr= arr1.++:(arr2)
println(arr.toList)
List(4, 5, 6, 1, 2, 3)
+:
两个加表示添加一组元素(数组)，那么一个+，就是添加一个元素。
:的前后顺序也会影响数组顺序。
:在前,表示将元素添加到末尾。
:在后,表示将元素添加到头部。
将元素添加到数组头部，并返回一个新的数组
val arr= Array[Int](1,2,3)
val newArr=arr.+:(4)
println(newArr.toList)
List(4, 1, 2, 3)
这个就不支持简写了
arr +: 4 // 这种写法会报错
:+
将元素添加到数组末尾
val arr= Array[Int](1,2,3)
val newArr=arr.:+(4)
println(newArr.toList)
List(1, 2, 3, 4)
最搞笑的是，:+ 又支持简写
val newArr=arr :+ 4
println(newArr.toList)
List(1, 2, 3, 4)
我的idea版本是 20.1.2 ；运行 arr +: 4 会报错
- 删除数据
不执行删除数据 - 获取数据
通过索引获取
val arr= Array[Int](10,22,23,444)
println(arr(1)) // 22
- 修改数据
通过索引修改
arr(1)=44
List(10, 44, 23, 444)
- 遍历数组
val arr= Array[Int](10,22,23,444)
for (e <- arr){
println(s"e=${e}")
}
e=10
e=22
e=23
e=444
若想通过索引获取数据，可以通过 scala的Range获取。
for (i<- 0 until arr.length){
println(s"e=${arr(i)}")
}
e=10
e=22
e=23
e=444
- 不可变数组转可变数组(
toBuffer)
val arr= Array[Int](10,22,23,444)
val buffer: mutable.Buffer[Int] = arr.toBuffer
- 获取元素个数
length
val arr= Array[Int](10,22,23,444)
println(arr.length) // 4
size
println(arr.size) // 4
可变数组
可变数组无法像不可变数组那样直接使用，需要进行先导包
import scala.collection.mutable.ArrayBuffer
可变数组创建:
- 通过new： new ArrayBuffer[元素类型]()
val arr=new ArrayBuffer[Int](5)
- 通过apply方法: ArrayBuffer[元素类型](初始元素,...)
val arr=ArrayBuffer[Int](5,12,32,445,66)
操作：
查看 ArrayBuffer 支持哪些 api
首先需要进行导包
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer
然后再运行
scala> val arr=ArrayBuffer[Int](5,12,32,445,66)
arr: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(5, 12, 32, 445, 66)
scala> arr.
++ endsWith mapResult sortBy
++: equals max sortWith
++= exists maxBy sorted
++=: filter min span
+: filterNot minBy splitAt
+= find mkString startsWith
+=: flatMap nonEmpty stringPrefix
- flatten orElse sum
-- fold padTo tail
--= foldLeft par tails
-= foldRight partition take
/: forall patch takeRight
:+ foreach permutations takeWhile
:\ genericBuilder prefixLength to
<< groupBy prepend toArray
WithFilter grouped prependAll toBuffer
addString hasDefiniteSize product toIndexedSeq
aggregate hashCode reduce toIterable
andThen head reduceLeft toIterator
append headOption reduceLeftOption toList
appendAll indexOf reduceOption toMap
apply indexOfSlice reduceRight toSeq
applyOrElse indexWhere reduceRightOption toSet
canEqual indices reduceToSize toStream
clear init remove toString
clone inits repr toTraversable
collect insert result toVector
collectFirst insertAll reverse transform
combinations intersect reverseIterator transpose
companion isDefinedAt reverseMap trimEnd
compose isEmpty runWith trimStart
contains isTraversableAgain sameElements union
containsSlice iterator scan unzip
copyToArray last scanLeft unzip3
copyToBuffer lastIndexOf scanRight update
corresponds lastIndexOfSlice segmentLength updated
count lastIndexWhere seq view
diff lastOption size withFilter
distinct length sizeHint zip
drop lengthCompare sizeHintBounded zipAll
dropRight lift slice zipWithIndex
dropWhile map sliding
操作符：
++
++:
++=
++=:
+:
:+
+=
+=:
/:
:\
<<
++ 表示添加一组元素(数组)，并返回一个新的数组
:在前，元素添加到最后，:在后，元素添加到最前（根据后面元素/数组而言）
= 表示将一组元素(数组)，添加到指定的数组中，而不是返回一个新的数组
+表示添加单个元素
- 添加数据
++
合并两个数组，并返回一个新的数组
val arr1=ArrayBuffer[Int](1,2,3,4,5)
val arr2=ArrayBuffer[Int](6,7,8,9,10)
val newArr: ArrayBuffer[Int] = arr1 ++ arr2
println(newArr.toList)
List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
试试 .++()
val newArr: ArrayBuffer[Int] = arr1.++(arr2)
没啥区别
println(newArr.toList)
List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
++:
将arr2 数组数据添加到新数组首部；.++:()才有效
val newArr: ArrayBuffer[Int] = arr1.++:(arr2)
println(newArr.toList)
List(6, 7, 8, 9, 10, 1, 2, 3, 4, 5)
++: 是不起作用的；虽然支持简写，但是结果去不一样，这点一定要注意。
val newArr: ArrayBuffer[Int] = arr1 ++: arr2
println(newArr.toList)
List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
++=
将arr2数组添加到arr1数组的尾部（不返回新的数组）
val arr1=ArrayBuffer[Int](1,2,3,4,5)
val arr2=ArrayBuffer[Int](6,7,8,9,10)
arr1 ++= arr2
println(arr1)
ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
++=:
将arr2数组添加到arr1数组的首部（不返回新的数组）
val arr1=ArrayBuffer[Int](1,2,3,4,5)
val arr2=ArrayBuffer[Int](6,7,8,9,10)
arr1.++=:(arr2)
println(arr1)
ArrayBuffer(6, 7, 8, 9, 10, 1, 2, 3, 4, 5)
+:
添加一个元素到数组头部，并返回一个新的元素
val arr1=ArrayBuffer[Int](1,2,3,4,5)
val newArr=arr1.+:(10)
println(newArr)
ArrayBuffer(10, 1, 2, 3, 4, 5)
:+
添加一个元素到数组尾部，并返回一个新的元素
val arr1=ArrayBuffer[Int](1,2,3,4,5)
val newArr=arr1.:+(10)
println(newArr)
ArrayBuffer(1, 2, 3, 4, 5, 10)
+=
添加元素到指定数组的尾部（不返回新的数组）
val arr1=ArrayBuffer[Int](1,2,3,4,5)
arr1.+=(10)
println(arr1)
ArrayBuffer(1, 2, 3, 4, 5, 10)
+=:
添加元素到指定数组的头部（不返回新的数组）
val arr1=ArrayBuffer[Int](1,2,3,4,5)
arr1.+=:(10)
println(arr1)
ArrayBuffer(10, 1, 2, 3, 4, 5)
- 删除数组
操作符
-
--
--=
-=
单个 - 表示删除单个元素。
有 = 表示在原数组中删除，没有=表示删除元素并返回一个新的数组。
两个个 - 表示删除一组元素。
元素数据
val arr=ArrayBuffer[Int](1,2,3,4,5,7,8,9,10)
-
删除单个元素并返回新的数组，原来的数组不受影响。
val newArr=arr.-(3)
println(s"arr=${arr.toList}")
println(s"newArr=${newArr.toList}")
arr=List(1, 2, 3, 4, 5, 7, 8, 9, 10)
newArr=List(1, 2, 4, 5, 7, 8, 9, 10)
--
删除一组元素并返回新的数组，原来的数组不受影响。
val newArr=arr.--(ArrayBuffer[Int](2,5,8))
println(s"arr=${arr.toList}")
println(s"newArr=${newArr.toList}")
arr=List(1, 2, 3, 4, 5, 7, 8, 9, 10)
newArr=List(1, 3, 4, 7, 9, 10)
--=
在原始数组中删除一组元素（不返回新的数组）
val newArr=arr.--=(ArrayBuffer[Int](2,5,8))
println(s"arr=${arr.toList}")
println(s"newArr=${newArr.toList}")
println(s"arr=newArr:${arr.eq(newArr)}")
arr=List(1, 3, 4, 7, 9, 10)
newArr=List(1, 3, 4, 7, 9, 10)
arr=newArr:true
-=
在原始数组中删除单个元素（不返回新的数组）
val newArr=arr.-=(5)
println(s"arr=${arr.toList}")
println(s"newArr=${newArr.toList}")
println(s"arr=newArr:${arr.eq(newArr)}")
arr=List(1, 2, 3, 4, 7, 8, 9, 10)
newArr=List(1, 2, 3, 4, 7, 8, 9, 10)
arr=newArr:true
remove
通过索引删除元素(remove(索引))，并返回删除元素的值
val arr=ArrayBuffer[Int](1,2,3,4,5,7,8,9,10)
val value: Int = arr.remove(1)
println(arr.toList)
println(value)
List(1, 3, 4, 5, 7, 8, 9, 10)
2
从指定索引删，并指定删几个(remove(索引,个数))。
从下标5开始，往后删2个。
val arr=ArrayBuffer[Int](1,2,3,4,5,7,8,9,10)
val value= arr.remove(5,2)
println(arr.toList)
6，7，8 被删除了。
List(1, 2, 3, 4, 5, 9, 10)
- 修改元素
通过索引修改。
val arr=ArrayBuffer[Int](1,2,3,4,5,7,8,9,10)
arr(5)=100
println(arr)
ArrayBuffer(1, 2, 3, 4, 5, 100, 8, 9, 10)
通过update(索引,值)函数修改
val arr=ArrayBuffer[Int](1,2,3,4,5,7,8,9,10)
arr.update(5,100)
println(arr)
ArrayBuffer(1, 2, 3, 4, 5, 100, 8, 9, 10)
通过updated(索引,值)函数修改，并返回一个新的数组
val arr=ArrayBuffer[Int](1,2,3,4,5,7,8,9,10)
val newArr=arr.updated(5,100)
println(s"arr=${arr}")
println(s"newArr=${newArr}")
arr=ArrayBuffer(1, 2, 3, 4, 5, 7, 8, 9, 10)
newArr=ArrayBuffer(1, 2, 3, 4, 5, 100, 8, 9, 10)
- 遍历数组
val arr=ArrayBuffer[Int](1,2,3,4,5,7,8,9,10)
for (e <- arr){
println(s"e=$e")
}
e=1
e=2
e=3
e=4
e=5
e=7
e=8
e=9
e=10
通过索引遍历，利用Range
val arr=ArrayBuffer[Int](1,2,3,4,5,7,8,9,10)
for (i <- 0 until arr.length){
println(s"e=${arr(i)}")
}
e=1
e=2
e=3
e=4
e=5
e=7
e=8
e=9
e=10
- 获取元素长度
length 函数
val arr=ArrayBuffer[Int](1,2,3,4,5,7,8,9,10)
println(s"length=${arr.length}") // 9
size 函数
val arr=ArrayBuffer[Int](1,2,3,4,5,7,8,9,10)
println(s"size=${arr.size}") // 9
-
toArray可变数组转不可变数组
val arr=ArrayBuffer[Int](1,2,3,4,5,7,8,9,10)
val array: Array[Int] = arr.toArray
多维数组 Array.ofDim()
Array.ofDim 有五个重载方法，一个的参数的表示一维数组，两个参数就表示二维数组，以此类推，5个参数就是表示五维数组。通过 Array.ofDim 可以看出是Array 下的方法，也就是说多维数组是一个不可变数组（没有可变的多维数组）。
不可变数组除了上面两种创建方法，还多了一种方式
val array: Array[Int] = Array.ofDim(length)
案例：
val array: Array[Int] = Array.ofDim(5)
array(0)=1
array(1)=2
array(2)=3
array(3)=4
array(4)=5
for(e <- array){
println(s"e=$e")
}
e=1
e=2
e=3
e=4
e=5
创建一个二维数组
2：表示数组长度，3：表示元素个数
val array: Array[Array[Int]] = Array.ofDim(2,3)
array(0)=Array[Int](1,2,3)
array(1)=Array[Int](4,5,6)
for(e <- array){
println(s"e=${e.toList}")
}
e=List(1, 2, 3)
e=List(4, 5, 6)
创建其他维度数组也是如此（3，4，5）
Array.ofDim 不不支持超过5个维度的多维数组；
- 实际工作中，不会需要这么复杂的多维数组
- 若真的有这样的业务场景，可以手动实现，大可不必使用
Array.ofDim。
网友评论