在Scala中获得子阵列的正确方法是什么？

我正试图在scala中获得子阵列，但我对正确的方法有点困惑。我最想要的是类似于如何在python中实现的内容：

x = [3, 2, 1]
x[0:2]

但我相当肯定你不能这样做

最明显的方法是使用Java数组util库

import java.util.Arrays
val start = Array(1, 2, 3)
Arrays.copyOfRange(start, 0, 2)

但在Scala中使用Java库总是让我觉得有点脏。我发现的最“规模化”的方法是

def main(args: List[String]) {
    val start = Array(1, 2, 3)
    arrayCopy(start, 0, 2)
}
def arrayCopy[A](arr: Array[A], start: Int, end: Int)(implicit manifest: Manifest[A]): Array[A] = {
    val ret = new Array(end - start)
    Array.copy(arr, start, ret, 0, end - start)
    ret
}

---

但是有更好的方法吗？

您可以调用slice方法：

scala> Array("foo", "hoo", "goo", "ioo", "joo").slice(1, 4)
res6: Array[java.lang.String] = Array(hoo, goo, ioo)

---

它的工作原理类似于python。

假设您有一个包含从

a

到

f

scala> val array = ('a' to 'f').toArray // Array('a','b','c','d','e','f')

然后，您可以通过不同的方式从中提取子数组：

使用

drop（n:Int）

array.drop（2）//数组（'c'，'d'，'e'，'f'）

使用

Take（n:Int）

array.take（4）//数组（'a'，'b'，'c'，'d'）

使用

切片（from:Int，till:Int）

选择任意元素间隔。请注意，

直到

被排除在外

array.slice（2,4）//数组（'c'，'d'）

切片方法完全等同于：

array.take（4）.drop（2）//数组（'c'，'d'）

使用dropRight（n:Int）排除最后n个元素：

array.dropRight（4）//数组（'a'，'b'）

使用takeRight（n:Int）选择最后n个元素：

array.takeRight（4）//数组（'c'，'d'，'e'，'f'）

---

参考：

从2D Scala数组（原始数组）提取特定列的示例：

导入scala.collection.mutable.ArrayBuffer
val sub_array=ArrayBuffer[array[String]]（）
val columns\u子集：Seq[String]=Seq（“ColumnA”、“ColumnB”、“ColumnC”）
val columns\u original=原始数组（0）
对于（列_现在哦，当然，ArrayOps，我是哑巴。是的，你是对的。我指的是绑定约定。包含下限，排除上限。没有尾随
：
也没有。@nnythm链接是head。看起来我无法编辑过时的注释，但活动链接是：@nnythm您可以删除旧注释；）
import scala.collection.mutable.ArrayBuffer

val sub_array = ArrayBuffer[Array[String]]()
val columns_subset: Seq[String] = Seq("ColumnA", "ColumnB", "ColumnC")
val columns_original = original_array(0)

for (column_now <- columns_subset) {
      sub_array += original_array.map{_(columns_original.indexOf(column_now))}
    }
sub_array