今天，我们将研究Scala slice函数。

Scala slice

以下API类中提供了Scala slice函数：

• Scala数组API
• 字符串API
• Scala Collection API

我们将挑选每种API，并在下一部分中通过适当的示例进行深入讨论。

Scala slice函数的用法

在Scala API中，"切片"功能用于选择元素的间隔。
它采用两个" Int"类型的参数，并返回原始Collection(或者String或者Array)的子集或者全部或者不包含元素。

真实切片场景：-我们也可以在正常的真实生活中使用此切片功能，如下所示。

这里的Bread.slice(0,10)表示从0到9切面包片，所以总共要切成10个面包片。

slice函数语法：在Scala标准库(API)中，此slice函数定义如下：

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]

slice函数参数：下表描述了" slice"函数参数的用法：

slice函数提取从"第一个索引"(包括)到"直到索引"(不包括)的元素。
这里的元素数字代表数字数组，字符代表字符串，对象代表集合。

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)

创建的Int of Array具有5个值，因此它的索引起始值为0，索引终止值为4。
它的长度= 5

现在让我们使用切片功能。

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

它从第一个元素的索引0开始，并检索所有元素，直到2表示索引= 1，这就是我们在这里得到第0个元素和第一个元素的原因。

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

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

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

如果我们像上面一样给start和end赋予相同的值，为什么会得到空数组？

开始索引= 3结束索引= 3-1 – 2

不可能从3到2个索引的数组中检索一组元素。

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

如果我们给-ve值，它只是从可用索引开始，如上所示。

scala> marksArray.slice(0,5)

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

如果我们在上面提供的第二个参数值之外提供第二个参数值(marksArray的可用最大索引值只有4个，因为它的长度= 5)，它只会忽略该值并仅返回最新的可用索引。

注意：-与Java不同，它不会引发任何ArrayIndexOutOfBoundsException。

Scala Collection切片

在Scala的Standard API中，大多数类都定义了此slice函数，该函数支持基于索引的元素访问。
例如，List类定义此功能，如下所示：

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

列表切片功能示例：

与Array示例相同，任何Collection 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对象上使用slice函数时，Scala编译器会在内部将此String对象转换为StringOps类对象，以使用此slice函数。
(不仅切片功能更多。
有关更多信息，请参见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

众所周知，字符串索引从零开始。
这里from-index = 6表示直到索引= 9(这是排他性的，因此我们只需要考虑到索引= 8)。

字符串的子字符串功能与切片功能相同，如下所示：

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

其中str.slice(6,9)和str.substring(6,9)都返回相同的值。

切片Vs子串

String类的slice和substring函数之间的区别

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

注意：-在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，如上所示。

字符串的字符访问返回Char，其中子字符串和切片函数返回String，如下所示。

scala> str(0)
res4: Char = H

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

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