Scala 用法之 Array,List 大全

1.++

def ++[B](that: GenTraversableOnce[B]): Array[B]

合并集合,返回一个新的数组,数组包含左右两个集合的内容

示例

val a =Array(1,2)
val b =Array(3,4)
val c =a ++ b
println(c.mkString(",")) //1,2,3,4

2.++:

def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That

也是合并两个集合,但是最终返回的集合类型取决于冒号后面的

示例:

val a =Array(1,2)
val b =List(3,4)
a++:b  //List[Int] = List(1,2,3,4)

3.+:

def +:(elem: A): Array[A]

在数组前面添加一个元素,并返回新的数组对象

val a =Array(1,2)
val b = 0+:a
println(b.mkString(",")) //0,1,2

4./:

def /:[B](z: B)(op: (B, T) ⇒ B): B

对数组中所有的元素从左向右进行遍历,进行相同的迭代操作,foldleft的简写

val a =Array(1,2,3,4)
val b =(10/:a)(_+_) //(((10+1)+2)+3)+4=20
val c =(10/:)(_*_) //10*1*2*3*4=120

5.:\

def :[B](z: B)(op: (T, B) ⇒ B): B

对数组中所有的元素从右向左进行遍历,进行相同的迭代操作,foldright的简写

val a =Array(1,2,3,4)
val b=(a:\10)(_-_) //1-(2-(3-(4-10)))=8 

6.addString(b)

def addString(b: StringBuilder): StringBuilder

将数组中的元素逐个添加到StringBuilder中

val a =Array(1,2,3,4)
val b =new StringBuilder()
a.addString(b)
println(b) //1234

7.addString(b,sep)

def addString(b: StringBuilder, sep: String): StringBuilder

将数组中的元素逐个添加到 StringBuilder 中，每个元素用 sep 分隔符分开

val a =Array(1,2,3,4)
val b =new StringBuilder()
a.addString(b)
println(b,",") //1,2,3,4

8.aggregate

def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B

聚合计算，aggregate 是柯里化方法，有分区和不分区两种算法

val a =Array(1,2,3,4)
val b =a.aggregate(5)(_+_,_+_) //不分区 5+1+2+3+4=15
val c =a.par.aggregate(5)(_+_,_+_) //分区 (1+5)+(2+5)+(3+5)+(4+5)=30

 

9.apply

def apply(i: Int): T

获取指定索引处的元素

val a =Array(1,2,3,4)
val b =a.apply(1) //即可简写为a(1)
println(b) //2

10.canEqual

def canEqual(that: Any): Boolean

判断两个对象是否可以进行比较

这个方法里所有的对象都可比较,返回的均为true 没啥意义

11.charAt

def charAt(index: Int): Char

获取 index 索引处的字符，这个方法会执行一个隐式的转换，将 Array[T] 转换为 ArrayCharSequence，只有当 T 为 Char 类型时，这个转换才会发生

val chars = Array('a','b','c')
println(chars.charAt(0)) //a

12.clone

def clone(): Array[T]

创建一个副本

 val a = Array(1, 2, 3, 4)
 val b = a.clone()
 println(b.mkString(",")) // 1,2,3,4

13.collect

def collect[B](pf: PartialFunction[A, B]): Array[B]

通过执行一个偏函数计算，得到一个新的数组对象

val fun: PartialFunction[Char, Char] = {
      case 'a' => 'A'
      case x => x
    }
    val a = Array('a', 'b', 'c')
    val b = a.collect(fun)
    println(b.mkString(",")) // A,b,c

14.collectFrist

def collectFirst[B](pf: PartialFunction[T, B]): Option[B]

在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算(且返回元素的类型)

val fun: PartialFunction[Any, Int] = {
      case x: Int => x * 100
    }
    val a = Array(1, 'a', "b")
    val b = arr.collectFirst(fun)
    println(b) // Some(100)

15.combinations

def combinations(n: Int): collection.Iterator[Array[T]]

排列组合,该方法只会选出包含字符不一样的组合,不考虑顺序,参数n表示序列的长度

val a = Array(1,2,3)
val b = a.combinations(2)
b.foreach(x=>println(x.mkString(","))) //结果如下
1,2
1,3
2,3

16.contains

def contains[A1 >: A](elem: A1): Boolean

判断序列中是否包含指定对象

val a = Array(1, 2, 3, 4)
println(a.contains(1)) // true

17.containsSlice

def containsSlice[B](that: GenSeq[B]): Boolean

判断当前序列中是否包含另一个序列

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

18.copyToArray(xs)

def copyToArray(xs: Array[A]): Unit

将当前数组元素复制到另一个数组中

val a = Array(1,2,3,4)
val b = Array(5,6,7,8,9,10)
a.copyToArray(b)
println(b) //1,2,3,4,9,10

19.copyToArray(xs,start)

def copyToArray(xs: Array[A], start: Int): Unit

将当前数组元素复制到另一个数组中，从 索引位置开始复制

val a = Array(1,2,3,4)
val b = Array(5,6,7,8,9,10)
a.copyToArray(b,1)
println(b) //5,1,2,3,4,10

20.corresponds

def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean

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

val a = Array(1, 2, 3, 4)
val b = Array(5, 6, 7, 8)
println(a.corresponds(b)(_ < _)) // true

21.count

def count(p: (T) ⇒ Boolean): Int

统计符合条件的元素个数

val a = Array(1, 2, 3, 4)
println(a.count(x => x > 2)) // 2

22.diff

def diff(that: collection.Seq[T]): Array[T]

求两个数组之间的差集(前面数组在后面数组中没有的元素组成的集合)

val a = Array(1, 2, 3, 4)
val b = Array(3, 4, 5, 6)
val c = a.diff(b)
println(c.mkString(",")) // 1,2

23.distinct

def distinct: Array[T]

去除当前数组中重复的元素,只保留一个元素

val a = Array(1, 2, 2, 3, 4, 4)
val b = a.distinct
println(b.mkString(",")) // 1,2,3,4

24.drop

def drop(n: Int): Array[T]

将当前数组中前 n 个元素去除，返回一个新数组

val a = Array(1, 2, 3, 4)
val b = a.drop(2)
println(b.mkString(",")) // 3,4

25.dropRight

def dropRight(n: Int): Array[T]

将当前数组后n个元素去除,返回一个新数组

val a = Array(1, 2, 3, 4)
val b = a.dropRight(2)
println(b.mkString(",")) // 1,2