scala之数组操作

最新推荐文章于 2022-05-20 16:01:23 发布
最新推荐文章于 2022-05-20 16:01:23 发布
阅读量715 收藏
点赞数 1
分类专栏： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Roserug/article/details/77623180
版权

定长数组

  定长数组的定义-可使用Scala中的Array(在scala包中)。可用如下两种方式定义数组，

 

scala> val arrs = new Array[String](10)
arrs: Array[String] = Array(null, null, null, null, null, null, null, null, null, null)

注：定义一个固定长度为10的String数组，初始值为null，如果为Int类型，则为0，其他数据类型可自行测试一下。

 

 

scala> val nums = Array(2, 3)
nums: Array[Int] = Array(2, 3)

注：定义长度为2的Int数组，类型和长度可以被推断出来，不用显示定义。

 

  在Scala中访问数组，使用()及下标即可，下标从0开始，如，

 

scala> val arrs = new Array[String](2)
arrs: Array[String] = Array(null, null)

scala> arrs(0)="test"

scala> arrs(1)="lm"

scala> print(arrs(1))
lm

注：在JVM中，Scala的Array以Java数组的方式实现。示例中的数组在JVM中的类型为java.lang.String[]。总之，Int、Double或其它与Java中基本类型对应的数组都是基本类型数组。

 

 

变长数组

  在Scala中，若使用变长的数组，可用ArrayBuffer(在scala.collection.mutable包路径下)定义。可用如下方式定义变长数组，

 

scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val array = new ArrayBuffer[Int]()
array: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

注：定义一个可变长度的Int数组。你也可以这样去定义-结尾不使用括号：val array = new ArrayBuffer[Int]，亦可以这样定义：val array = ArrayBuffer[Int]()。

 

变长数组的基本使用

 

  1.在数组尾端添加元素-使用+=

scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val array = new ArrayBuffer[Int]()
array: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> array += 1
res0: array.type = ArrayBuffer(1)

scala> array += (2, 3, 4, 5)
res1: array.type = ArrayBuffer(1, 2, 3, 4, 5)
注：第一种为添加一个元素，第二种为添加多个元素，多个元素用括号包围并用逗号分隔。
  2.在数组尾端追加任何集合-使用++= 
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val array = new ArrayBuffer[Int]()
array: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> array += (1, 2, 3)
res2: array.type = ArrayBuffer(1, 2, 3)

scala> val array1 = new ArrayBuffer[Int]()
array1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> array1 += (4, 5, 6)
res3: array1.type = ArrayBuffer(4, 5, 6)

scala> array ++= array1
res4: array.type = ArrayBuffer(1, 2, 3, 4, 5, 6)

scala> array ++= Array(7, 8, 9)
res5: array.type = ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9)
  3.在数组尾端移除元素-使用trimEnd 
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val array = new ArrayBuffer[Int]()
array: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> array += (1, 2, 3)
res6: array.type = ArrayBuffer(1, 2, 3)

scala> array.trimEnd(1)

scala> array.toString
res8: String = ArrayBuffer(1, 2)
注：在数组缓冲的尾端添加或者移除元素是高效的。
  4.在数据指定位置添加或移除元素-使用insert/remove 
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val array = new ArrayBuffer[Int]()
array: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> array += (1, 2, 3)
res0: array.type = ArrayBuffer(1, 2, 3)

scala> array.insert(1, 6)

scala> array.toString
res2: String = ArrayBuffer(1, 6, 2, 3)

scala> array.insert(1, 9, 8, 7)

scala> array.toString
res4: String = ArrayBuffer(1, 9, 8, 7, 6, 2, 3)

scala> array.remove(1)
res5: Int = 9

scala> array.toString
res6: String = ArrayBuffer(1, 8, 7, 6, 2, 3)

scala> array.remove(1, 3)

scala> array.toString
res8: String = ArrayBuffer(1, 2, 3)
注：在数组非结尾位置插入或移除元素并不是高效的，因为每添加/移除一个或多个元素时，所有在插入/移除位置之后的元素都必须被平移。
  5.变长数组(数组缓冲)到定长数组的转换-使用toArray 
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val array = new ArrayBuffer[Int]
array: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> array +=(1, 2, 3)
res0: array.type = ArrayBuffer(1, 2, 3)

scala> array.toArray
res1: Array[Int] = Array(1, 2, 3)
注：如果要从定长数组转换为变长数组(数组缓冲)-使用toBuffer方法。

遍历数组和数组缓冲

  在Scala中，你可以使用以下语法遍历数组和数组缓冲，如 
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val array = ArrayBuffer[Int]()
array: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> array +=(1, 2, 3)
res2: array.type = ArrayBuffer(1, 2, 3)

scala> for(arr <- 0 until array.length) print(array(arr) + ",")
1,2,3,
注：until是RichInt类的方法，返回所有小于但不包括上线的数字，上述for循环的结构如下：for(i <- 区间)，变量i会遍历区间所包含的所有值。如果想要每两个元素一跳，你可使用0 until (array.length, 2)；如果你想从数组的尾端开始遍历，你可使用(0 until a.length).reverse；如果在循环体中不需要使用数据下标，你也可以直接访问数组元素，如 elem <- array。

数组转换

  在Scala中，你可以使用for推导式即用for(...) yield实现，如 
scala> val array = Array(1,2,3)
array: Array[Int] = Array(1, 2, 3)

scala> val res = for(elem <- array) yield 3 * elem
res: Array[Int] = Array(3, 6, 9)

scala> val result = for(elem <- array if elem >1) yield 3 * elem
result: Array[Int] = Array(6, 9)
注：for(...) yield循环创建了一个类型与原始集合相同的新类型。你也可以在for中使用守卫等功能，请留意结果是一个新的集合-原始的集合没有受到影响。

常用算法

  1.求和-sum 
scala> val array = Array(1,2,3)
array: Array[Int] = Array(1, 2, 3)

scala> array.sum
res0: Int = 6
注：求和方法同样适用于ArrayBuffer。若要使用sum方法，数据类型要为如下几种类型，即整形、浮点数、BigInteger、BigDecimal。
  2.最大值/最小值-max/min 
scala> val array = Array(1,2,3)
array: Array[Int] = Array(1, 2, 3)

scala> array.max
res1: Int = 3

scala> array.min
res2: Int = 1
注：方法适用于ArrayBuffer。
  3.排序-sorted/sortWith 
scala> val array = Array(1,7,2,9)
array: Array[Int] = Array(1, 7, 2, 9)

scala> array.sorted
res3: Array[Int] = Array(1, 2, 7, 9)

scala> array.sortWith(_>_)
res4: Array[Int] = Array(9, 7, 2, 1)
注：使用sorted及sortWith方法排序，不影响原始数组。sortWith参数接受一个函数。 
scala> val array = Array(1,6,2,9)
array: Array[Int] = Array(1, 6, 2, 9)

scala> scala.util.Sorting.quickSort(array)

scala> array.mkString(", ")
res10: String = 1, 2, 6, 9
注：你可以直接对一个数组排序，但是不能对数据缓冲-可变数组排序，直接排序会改变原始数组。若要使用直接排序，则需要带有Ordered特质。mkString方法-把数组以参数为分隔符组装为字符串。

多维数组

  在Scala中，多维数组也是通过数组的数组来实现的。如， 
scala> val array = Array.ofDim[Int](2,2)
array: Array[Array[Int]] = Array(Array(0, 0), Array(0, 0))

scala> array(0)(0) = 1

scala> array(0)(0)
res1: Int = 1
注：访问元素使用两对圆括号。
  创建不规则的数组，每一行长度不一，如 
scala> val array = new Array[Array[Int]](10)
array: Array[Array[Int]] = Array(null, null, null, null, null, null, null, null, null, null)

scala> for(i <- 0 until array.length) array(i) = new Array[Int](i+1)
注：Array[Array[Int]]的默认值为null。

与Java的互操作

  由于Scala数组是用Java数组实现的，你可以在Java和Scala之间来回传递。如果你调用接受或返回java.util.List的Java方法，则当然可以在Scala代码中使用Java的ArrayList-但那样做没有什么意思。你完全可以引入scala.collection.JavaConversions里的隐式转换方法。这样，你就可以在代码中使用Scala缓冲，在调用Java方法时，这些对象会被自动包装成Java列表。如，java.lang.ProcessBuilder类有一个以List<String>为参数的构造器，请看一下示例， 
scala> import scala.collection.JavaConversions.bufferAsJavaList
import scala.collection.JavaConversions.bufferAsJavaList

scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val command = ArrayBuffer("a", "b", "c")
command: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(a, b, c)

scala> import java.lang.ProcessBuilder
import java.lang.ProcessBuilder

scala> val pb = new ProcessBuilder(command)
pb: ProcessBuilder = java.lang.ProcessBuilder@b16e202
注：Scala缓冲被包装成了一个实现了java.util.List接口的Java类的对象-command会隐式转换为List。(注意引入的包)
 
 
 
 
Roserug
关注
专栏目录
【大数据Scala系列】Scala 数组相关操作
weixin_54707168的博客
03-31 392
【大数据Scala系列】Scala 数组相关操作
Scala - 数组相关操作
qq_29342297的博客
06-25 284
数组相关操作 定长数组 不变数组。使用Scala中的Array. val nums = new Array[Int](10) //初始化为0 val a = new Array[String](10) //初始化为null val s = Array("Hello","World") //长度为2的Array[String] - 类型是推断出来的。说明：当已提供初始值时，就不需要new了 s(0) = "Goodbye" // 使用()而不是[]来访问元素 Jvm中，Scala的Array以Java数组方
Scala数组操作
热门推荐
蔡先生的专栏
07-22 3万+
Scala数组操作： 1.定长数组 长度不变的数组的声明： //长度为10的整数数组，所有元素初始化为0 val numArr = new Array[Int](10) //长度为10的字符串数组，所有元素初始化为null val numArr = new Array[String](10) //长度为2的数组，数据类型自动推断出来，已经提供初始值就不需要new关键字 val
Scala学习----数组相关操作(转载)
weixin_30522183的博客
08-27 479
数组相关操作 原地址：http://www.cnblogs.com/sunddenly/p/4411564.html 摘要: 本篇主要学习如何在Scala中操作数组。Java和C++程序员通常会选用数组或近似的结构（比如数组列表或向量）来收集一组元素。在Scala中，我们的选择更多，不过现在我们先假定不关心其他选择，而只是想马上开始用数组。本篇的要点包...
Scala学习笔记之 --- Array、ArrayBuffer以及遍历数组（1）
fengyuruhui123的博客
12-08 2055
Array在Scala中，Array代表的含义与Java中类似，也是长度不可改变的数组。此外，由于Scala与Java都是运行在JVM中，双方可以互相调用，因此Scala数组的底层实际上是Java数组。例如字符串数组在底层就是Java的String[]，整数数组在底层就是Java的Int[]。// 数组初始化后，长度就固定下来了，而且元素全部根据其类型初始化 val a = new Array[In
Scala编程数组、Map操作（四）
闵浮龙的博客
05-05 3907
Array 在Scala中，Array代表的含义与Java中类似，也是长度不可改变的数组。此外，由于Scala与Java都是运行在JVM中，双方可以互相调用，因此Scala数组的底层实际上是Java数组。例如字符串数组在底层就是Java的String[]，整数数组在底层就是Java的Int[]。 数组初始化后，长度就固定下来了，而且元素全部根据其类型初始化 val a = new A...
Scala 【 5 数组常见操作和 Map 】
01-20
**数组操作** 1. **创建数组**： ```scala val a = Array(1, 2, 3, 4, 5) ``` 2. **数组求和**： ```scala val sum = a.sum ``` 这将计算数组所有元素的和。 3. **获取最大值**： ```scala val max = a....
Scala之数组用法
sk_43485671的博客
07-16 228
1、map（映射） var arr1=ArrayBuffer(2,3,4,56,9,87,12) var a1=arr1.map(_ * 3) 2、flatten（扁平化操作） var arr1=ArrayBuffer("hello c","hello o","hello p","hello p") var q1=arr1.map(_.split(" ")).flatten 3、f...
快学scala之数组操作
彩虹的约定
07-14 287
object Array_opt { def main(args: Array[String]) { // init an array val array = new Array[String](3) val arr = Array(1, 2, 3, 4) // traversal element // method 1 for (i 0
scala中的数组
m0_63117386的博客
04-04 1789
不可变数组 数组的基本操作 , scala中的数组和java中的不太一样 ,这里的数组类似于一个数组对象 .有自己的方法!! 数组的定义 def main(args: Array[String]): Unit = { // 定义一个通用数组 没有执行数据类型 , 可以存储任意类型 val arr1 = Array("JIM", 12, 12.22, true) // 指定泛型 约束数组中的数据类型 只能写泛型的子类 val arr2 = Array[Any]("JIM", 12,
Scala 数组
m0_55834564的博客
05-20 1461
目录 Scala数组 一、声明数组 二、处理数组 三、多维数组 四、合并数组 五、创建区间数组 Scala数组 一、声明数组 1.Scala 数组声明的语法格式: var z:Array[String] = new Array[String](3) 或 var z = new Array[String](3) object ArrayTest { def main(args: Array[String]): Unit = { //数组定义方式 va
scala集合之数组的使用
congge_study的博客
06-20 238
前言 数组可以说是任何后端框架的基础，scala也不例外，在scala中，对于数组的操作，主要分为定长数组和可变数组，下面就这liang'z
5.Scala数组操作实战详解
KongMingJue的博客
04-09 519
一、数组的基本操作 1.定长数组 val a = new Array[String](4) val b = new Array[Int](5) val c= Array("nihaoa","shia") c(0) = "hello" for(elem 输出： hello shia 以上是定长数组定义的两种方法 2.缓冲数组 工程右键-->new sc
Scala知识点5---数组基本操作
别人笑我太疯癫，我笑他人看不穿。
01-07 118
下边这个例子是给大家演示一下普通数组和可变数组的操作方式 package com.wy object ArrayDemo { def main(args: Array[String]): Unit = { //不可变数组 var array = Array("java","html","css") //查 println(array(1)) for(str <- array){ println(str) } //改
Scala中的数组介绍与使用
zhaoguowei的博客
11-06 1015
1 定长数组 定义一个长度不变的数组，可以使用Scala中的Array //定义一个Int类型的数组，元素的初始值为0 scala> var nums = new Array[Int](10) nums: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0) //定义一个String类型的数组，元素的初始值为null scala> var ...
Scala数组
weixin_30852451的博客
11-17 74
1、数组的定义和取值 object helloworld { def main(args: Array[String]) { //java: int[] arr = new int[10]; // int[] arr = new int[]{1,2,3,4} // int...
Scala 系列（四）—— 数组 Array
weixin_30362083的博客
08-28 277
一、定长数组 在 Scala 中，如果你需要一个长度不变的数组，可以使用 Array。但需要注意以下两点： 在 Scala 中使用 (index) 而不是 [index] 来访问数组中的元素，因为访问元素，对于 Scala 来说是方法调用，(index) 相当于执行了 .apply(index) 方法。 Scala 中的数组与 Java 中的是等价的，Array[Int]() 在虚拟机...
scala获取数组元素
最新发布
06-08
要获取Scala数组中的元素，可以使用括号操作符和元素的索引。例如，对于一个名为"arr"的数组，要获取第一个元素的值，可以使用以下语法： ``` val firstElement = arr(0) ``` 其中，"0"是第一个元素的索引值。同样，要获取第二个元素的值，可以使用以下语法： ``` val secondElement = arr(1) ``` 以此类推。注意，Scala数组的索引从0开始。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值