Scala之Array方法集

参考博客：https://blog.csdn.net/zyp13781913772/article/details/81428862

Scala：Array(集合、序列)

数组是一种可变的、可索引的数据集合。在Scala中用Array[T]的形式来表示Java中的数组形式 T[]。

val arr=Array(1, 2, 3, )   //声明一个数组对象
val first=arr(0) // 读取第一个元素
arr(2)=100 // 替换第三个元素为100
方法一：arr.map(x=>x*2) // 所有元素乘2
方法二：arr.map(_ * 2) // 所有元素乘2

Scala提供了大量的集合操作：

• 1、++
  合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。(不去重)

val a=Array(1,2,3)
val b=Array(4,5,6)
val c= a ++ b

• 2、++:
  合并集合，并返回一个新的数组，右边操纵数的类型决定着返回结果的类型

val a = List(1,2)
val b = scala.collection.mutable.LinkedList(3,4)
val c = a ++: b
注：c的类型是：scala.collection.mutable.LinkedList

• 3、+:
  在数组前面添加一个元素，并返回新的对象

val a = List(1,2)
val c = 0 +: a // c中的内容是 （0,1,2）

• 4、:+
  在数组末尾添加一个元素，并返回新对象

val b = List(3,4)
val c = b :+ 0 // c中的内容是 （3,4,0）

• 5、/:
  对数组中所有的元素进行相同的操作，foldLeft的简写

val a=List(1,2,3,4)
val c=(10 /: a)(_+_)   //10+1+2+3+4  计算方向 ——>
val d=(10 /: a)(_*_)   //10*1*2*3*4  计算方向 ——>

• 6、 :\
  对数组中所有的元素进行相同的操作，foldRight的简写

val a=List(1,2,3,4)
val c=(a :\ 10)(_+_)   //1+2+3+4+10  计算方向 <——
val d=(a :\ 10)(_*_)   //1*2*3*4*10  计算方向 <——

• 7、addString
• • addString(b:StringBuilder):StringBuilder
    将a数组中的元素逐个添加到b中

val a=List(1,2,3,4)
val b=new StringBuilder()
val c= a.addString(b)      //c中的内容是：1234

• • addString(b:StringBuilder,sep:String):StringBuilder
    将a数组中的元素逐个添加到b中,并且每个元素用sep分隔符分开

val a=List(1,2,3,4)
val b=new StringBuilder()
val c= a.addString(b,",")      //c中的内容是：1,2,3,4

• • addString(b:StringBuilder,start:String,sep:String,end:String):StringBuilder
    将a数组中的元素逐个添加到b中, 同上，在首尾各加一个字符串，并指定sep分隔符

val a=List(1,2,3,4)
val b=new StringBuilder()
val c= a.addString(b,"{",",","}")    //c中的内容是：{1,2,3,4}

• 8、aggregate
  聚合计算，aggregate是柯里化方法，参数是两个方法，为了方便理解，我们把aggregate的两个参数，分别封装成两个方法，并把计算过程打印出来。

• 9、apply(i:int)
  取出指定索引处的元素

val a=List(1,2,3,4)
val first=a.apply(0)   //读取第一个元素
等同于：val first=arr(0)  //读取第一个元素

• 10、canEqual
  判断两个对象是否可以进行比较

• 11、charAt(index: Int)
  获取index索引处的字符，这个方法会执行一个隐式的转换，将Array[T]转换为 ArrayCharSequence，只有当T为char类型时，这个转换才会发生。

val chars = Array('a','b','c')
val c=chars.charAt(0)   //c的结果为 a

• 12、clone()
  创建一个副本

val chars = Array('a','b','c')
val newchars = chars.clone()

• 13、collect
  通过执行一个并行计算（偏函数），得到一个新的数组对象

val chars = Array('a','b','c')
//通过下面的偏函数，把chars数组的小写a、b转换为大写的A、B
val fun:PartialFunction[Char, Char]={
   
    case 'a' => 'A'
    case 'b' => 'B'
    case x => x
}
chars.collect(fun)     // 输出结果：Array(A, B, c)

• 14、collectFirst
  在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算

var arr = Array(1,"a","b")
//定义一个偏函数，要求当被执行对象为Int类型时，进行乘100的操作，
//对于上面定义的对象arr来说，只有第一个元素符合要求
val fun:PartialFunction[Any,Int]={
   
    case x:Int => x*100
}
//计算
val value = arr.collectFirst(fun)

//另一种写法
val value = arr.collectFirst({
   case x:Int => x*100})

• 15、combinations(n: Int)
  排列组合，这个排列组合会选出所有包含字符不一样的组合，对于 “abc”、“cba”，只选择一个，参数n表示序列长度，就是几个字符为一组

val arr = Array("a","b","c")
val newarr = arr.combinations(2)
newarr.foreach((item) => println(item.mkString(",")))
/**
a,b
a,c
b,c
*/

• 16、contains
  序列中是否包含指定对象，包含则输出true,不包含则输出false

val arr = Array("a","b","c","d","e","f")
arr.contains("a")  // true
arr.contains("s")  // false

• 17、containsSlice
  判断当前序列中是否包含另一个序列，如果另一个序列中的元素连续且相同于当前序列，则返回true，反之则返回false

val a = List(1,2,3,4)
val b = List(1,2)
a.containsSlice(b)  //true

val c = List(2,1)
a.containsSlice(c)  //false

val d = List(1,4)
a.containsSlice(d)  //false

• 18、copyToArray
  此方法还有两个类似的方法：
  copyToArray(xs: Array[A], start: Int): Unit
  copyToArray(xs: Array[A], start: Int, len: Int): Unit

val a = Array('a','b','c')
val b:Array[Char] = new Array(5)   //定义一个长度为5的char类型数组b
a.copyToArray(b)   //复制数组a中元素至数组b
b  //查看b中元素  Array[Char] = Array(a, b, c, ?, ?)

val b:Array[Char] = new Array(5)
a.copyToArray(b,2)   //从数组b索引为2的位置开始，复制数组a中元素至数组b
b   //查看b中元素  Array[Char] = Array(?, ?, a, b, c)

val b:Array[Char] = new Array(5)
a.copyToArray(b,2,2)   //从数组b索引为2的位置开始，复制数组a中元素至数组b，复制的元素个数为2
b   //查看b中元素  Array[Char] = Array(?, ?, a, b, ?)

• 19、copyToBuffer
  将数组中的内容拷贝到Buffer中

//前提：导入可变集合
import scala.collection.mutable._

val a = Array('a','b','c')
val b:ArrayBuffer[Char] = ArrayBuffer()   //定义Buffer类型数组b
a.copyToBuffer(b)   //复制数组a中元素至数组b
b   //查看数组b： ArrayBuffer(a, b, c)
b.toString   //输出数组b： String = ArrayBuffer(a, b, c)

b.append('d')   //为数组b添加元素'd'
b   //查看数组b：ArrayBuffer(a, b, c, d)
b.append('e')   //为数组b添加元素'e'
b   //查看数组b：ArrayBuffer(a, b, c, d, e)

//将数组b按自定义样式输出
b.mkString("{","^","}")   // 输出结果：{a^b^c^d^e}

• 20、correspond
  判断两个序列长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true

val a = Array(1,2,3)
val b = Array(3,4,5)
//检查a和b长度是否相等，并且a中元素是否小于b中对应位置的元素
a.corresponds(b)(_<_)    //true

val b = Array(1,4,5)
a.corresponds(b)(_<_)   // false

val b = Array(4,5,6,7)
a.corresponds(b)(_<_)   // false

val b = Array(4,5)
a.corresponds(b)(_<_)   // false

• 21、count
  统计符合条件的元素个数

val a = Array(1,2,3)
//统计大于2的元素个数
a.count(x => x>2)   //1
//统计大于0的元素个数
a.count(x => x>0)   //3
//统计大于1的元素个数
a.count(x => x>1)   //2

• 22、diff
  计算当前数组与另一个数组的不同。将当前数组中没有在另一个数组中出现的元素返回

val a = Array(1,2,3,4)
val b = Array(4,5,6)
//计算数组a中没有在数组b中出现的元素
a.diff(b)   //结果：Array(1, 2, 3)
//计算数组b中没有在数组a中出现的元素
b.diff(a)   //结果：Array(5, 6)

• 23、distinct
  去除当前集合中重复的元素，只保留一个

val a = Array(1,1,2,2,3,3,5,5,6,7,7)
//去除数组a中重复的元素
val c = a.distinct   //结果：Array(1, 2, 3, 5, 6, 7)

• 24、drop(n: Int)
  将当前序列中前 n 个元素去除后，作为一个新序列返回

val a = Array(1,2,3,4)
//去除当前序列的前2个元素
a.drop(2)   //结果：Array(3, 4)

• 25、dropRi