美文网首页
scala(十四) 数组

scala(十四) 数组

作者: 万事万物 | 来源:发表于2021-07-01 08:33 被阅读0次

不可变数组

创建

  1. 通过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

可变数组创建:

  1. 通过new: new ArrayBuffer[元素类型]()
val arr=new ArrayBuffer[Int](5)
  1. 通过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个维度的多维数组;

  1. 实际工作中,不会需要这么复杂的多维数组
  2. 若真的有这样的业务场景,可以手动实现,大可不必使用 Array.ofDim

相关文章

网友评论

      本文标题:scala(十四) 数组

      本文链接:https://www.haomeiwen.com/subject/phrgyltx.html