Scala切片函数

今天我们将研究Scala的切片函数。

Scala切片

Scala切片函数可在以下API类中使用：

• Scala Array API
• String API
• Scala Collection API

我们将选择每个API并在下一节中使用适当的示例进行深入讨论。

Scala切片函数用法

在 Scala API 中，“slice”函数用于选择元素的区间。它接受两个“Int”类型的参数，并返回原始集合（或字符串或数组）的子集、整体或无元素。真实世界的切片场景：我们也可以在日常生活中使用这个切片函数，如下所示。这里的Bread.slice(0,10)表示从第0到第9取面包片，总共10片面包片。（仅为模仿Scala的切片函数，这里我使用零，但请将其视为1。）切片函数语法：在Scala标准库（API）中，此切片函数定义如下：

  def slice(from-index: Int, until-index: Int): ScalaAPIClass[A]

这里的“ScalaAPIClass”表示任何Scala集合类（支持基于索引的访问，如Seq、List等）、String、Array类。示例：以下函数在Scala API的Seq类中定义。

  def slice(from-index: Int, until-index: Int): Seq[A]

切片函数参数：“切片”函数参数的使用说明在下表中描述：

切片函数从‘first-index’（包含）到‘until-index’（不包含）提取元素。这里的元素编号适用于数字数组、字符串的字符、集合的对象。

Scala数组切片

在Scala API中，Array类定义了如下的切片函数：

def slice(from: Int, until: Int): Array[T]

在这里，“from”是数组的起始索引（包含），而“until”是数组的结束索引（不包含）。数组切片函数示例：

scala> val marksArray = Array(56,79,60,99,71)
marksArray: Array[Int] = Array(56, 79, 60, 99, 71)

创建了具有5个值的整数数组，因此其索引起始值为0，索引结束值为4。它的长度为5，现在让我们来玩玩切片函数。

scala> marksArray.slice(0,2)
res0: Array[Int] = Array(56, 79)

它从索引0开始，即第一个元素，并检索所有元素，直到2，意味着索引=1，这就是为什么我们在这里得到了第0个元素和第1个元素。

scala> marksArray.slice(3,4)
res1: Array[Int] = Array(99)

我们可以访问任何索引范围。

scala> marksArray.slice(3,3)
res2: Array[Int] = Array()

如果我们为开始和结束指定相同的值，就像上面一样，我们将获得空数组，为什么？起始索引= 3，结束索引= 3-1 = 2，从3到2的索引中检索一组元素是不可能的，对吧。

scala> marksArray.slice(-1,3)
res3: Array[Int] = Array(56, 79, 60)

如果我们给出负值，它就从可用索引开始，如上所示。

scala> marksArray.slice(0,5)

res4: Array[Int] = Array(56, 79, 60, 99, 71)

如果我们给出超出其可用索引的第二个参数值（在marksArray中可用的最大索引值仅为4，因为它的长度= 5），它将忽略该值，并仅返回可用索引。注意：-与Java不同，它不会抛出任何ArrayIndexOutOfBoundsException。

Scala集合切片

在Scala的标准API中，大多数类都定义了此切片函数，支持基于索引的元素访问。例如，List类将此函数定义如下：

def slice(from: Int, until: Int): List[A]

列表切片功能示例：与数组示例相同，我们将获得任何集合 API 的相同结果。

scala> val list = List(56, 79, 60, 99, 71)
list: List[Int] = List(56, 79, 60, 99, 71)

scala> list.slice(0,2)
res5: List[Int] = List(56, 79)

scala> list.slice(3,4)
res6: List[Int] = List(99)

scala> list.slice(3,3)
res7: List[Int] = List()

scala> list.slice(-1,3)
res8: List[Int] = List(56, 79, 60)

scala> list.slice(0,5)
res9: List[Int] = List(56, 79, 60, 99, 71)

如果我们访问一个空列表，我们将只获得空列表，如下所示

scala> val list2 = List()
list2: List[Nothing] = List()

scala> list2.slice(0,1)

res10: List[Nothing] = List()

Scala 字符串切片

在 Scala API 中，“StringOps” 类被定义在 scala.collection.immutable 包中。它将切片函数定义如下：

def slice(from: Int, until: Int): String

注意：-在 Scala 中，我们使用 Java 的 String 类。但是这个类没有切片函数。当我们在 Java 的 String 对象上使用切片函数时，Scala 编译器会将这个 String 对象内部转换成 StringOps 类对象来使用这个切片函数。（不仅是切片函数，还有许多其他函数。请查看 Scala API 获取更多信息。）这意味着“StringOps”是 String 类的一个隐式类。字符串切片函数示例：

scala> val str = "Hello I'm doing good. How are you?"
str: String = Hello I'm doing good. How are you?

scala> str.slice(6,9)

res8: String = I'm

正如我们所知，字符串索引从零开始。这里的从索引 = 6 意味着到索引 = 9（它是排他的，所以我们只需要考虑到索引 = 8）字符串的子字符串函数与它的切片函数工作方式相同，如下所示：

scala> str.substring(6,9)
res12: String = I'm

这里 str.slice(6,9) 和 str.substring(6,9) 都返回相同的值。切片 Vs 子字符串String 类的切片函数与子字符串函数之间的区别

• 在功能和语法上几乎没有区别
• 性能几乎相似且可以忽略。

注意： 在Scala中，我们可以像访问数组元素一样访问字符串字符，如下所示：

scala> str(0)
res0: Char = H

这里返回的是一个字符，而不是一个字符串

scala> str(-1)
java.lang.StringIndexOutOfBoundsException: String index out of range: -1
  at java.lang.String.charAt(String.java:658)
  at scala.collection.immutable.StringOps$.apply$extension(StringOps.scala:38)
  ... 33 elided

scala> str.length
res2: Int = 34

scala> str(34)
java.lang.StringIndexOutOfBoundsException: String index out of range: 34
  at java.lang.String.charAt(String.java:658)
  at scala.collection.immutable.StringOps$.apply$extension(StringOps.scala:38)

  ... 33 elided

注意：如果我们尝试在范围之外访问字符串字符，就会得到StringIndexOutOfBoundsException，如上所示。字符串的字符访问返回字符，而子串和切片函数返回字符串，如下所示。

scala> str(0)
res4: Char = H

scala> str.substring(0,1)
res5: String = H

scala> str.slice(0,1)
res6: String = H

关于“Scala的切片函数”用法，就是这些。在我的下一篇文章中，我们将讨论更多Scala的概念。参考：Scala API文档