Scala之Array方法集

最新推荐文章于 2022-02-09 20:01:57 发布

绿萝蔓蔓绕枝生

最新推荐文章于 2022-02-09 20:01:57 发布

阅读量1.4k

点赞数 1

分类专栏： Scala 文章标签： scala

本文链接：https://blog.csdn.net/qq_42578036/article/details/109288547

版权

Scala 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

++

两个集合相加，不去重

    val a = Array(1,2)
    val b = Array(3,4)
    val c = a ++ b
    //c中的内容是：(1,2,3,4)

++:

两个集合相加，不去重，结果的集合类型等于冒号后面集合的集合类型

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

+:

在数组前面添加一个元素，注意数组在冒号那一边

    val a = Array(1,2)
	val c = a +: 0
	//c中的内容是：(0,1,2)

:+

在数组后面添加一个元素，注意数组在冒号那一边

    val a = Array(1,2)
	val c = a :+ 0
	//c中的内容是：(1,2,0)

/:

对数组、集合中所有元素进行相同的操作，foldLeft的简写
初始值依次从左往右加上数组中的元素

    val a = List(1,2,3,4)
    val c = (10 /: a)(_+_)
	//c的值为：15
	//与下面等价
	val c=(10/:a)((x,y)=>{println(x,y);x+y})

:\

对数组、集合中所有元素进行相同的操作，foldRight的简写
初始值依次从右往左加上数组中的元素，结果与/:相同

    val a = List(1,2,3,4)
    val c = (a :\ 10)(_+_)
	//c的值为：15
	//与下面等价
	val c=(a:\10)((x,y)=>{println(x,y);x+y})

addString

将数组中的元素逐个添加到StringBuilder中
后面括号中依次是：将添加到的数组、边界符号（可选）、分隔符（可选）、边界符号（可选）

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

aggregate

柯理化方法，参数是两个匿名函数

	def seqop(x:Int,y:Int):Int={
		println("seqop",x,y)
		x+y
	}
	def combop(x:Int,y:Int):Int={
		println("combop",x,y)
		x+y
	}
	a.aggregate(5)(seqop,combop)
	val c = a.par.aggregate(5)(_+_,_+_)
  	val c = a.par.aggregate(5)((x,y)=>x+y,(x,y)=>x+y)
  	//c的值为：30
  	/**
    seq_exp=5+3
    seq_exp=5+2
    seq_exp=5+4
    seq_exp=5+1
    com_exp=6+7
    com_exp=8+9
    com_exp=13+17
    c:30
 	 */

apply

取出指定索引处的元素

    val a=Array("hellow","LL","nihao")
    println(a.apply(1))
    //输出结果为：LL

canEqual

判断两个对象是否可以进行比较
返回结果为boolean值 true 或 false

    val a=Array("hellow","LL","nihao")
    val b=Array(1,2,3,4)
    println(a.canEqual(b))
    //输出结果为：true

charAt

获取坐标点的字符
注意是字符数组，返回某个下标的字符

    val chars = Array('a','b','c')
    println(chars.charAt(1))
    //输出结果为：b

clone

克隆并创建一个新副本

    val chars = Array('a','b',"cd")
    val newchars = chars.clone()
    println(newchars.mkString(","))

collect

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

    val a=Array('a','c','B','G','H','L','m')
    val fun:PartialFunction[Char,Char] = {
      case 'a' => 'A'
      case 'b' => 'B'
      case 'c' => 'C'
      //case x不可省略,表示小写字符不变
      //case x => 'M'//表示从该语句向下所有字符操作修改为M
      case x => x
    }
    println(a.collect(fun).mkString(","))
    val c = a.collect({case 'b' => 'B';case x=>x})
    println(c.mkString(","))

collectFirst

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

val arr=Array(1,'a',"b")
val fun:PartialFunction[Any,Int]={
	case x:Int=x*100
}
val value = arr.collectFirst({case x => x*100})	//匿名偏函数
val value = arr.collectFirst(fun)

combinations

combinations(n）
排列组合，这个排列组合会选出所有包含字符不一样的组合
参数n表示序列长度，即n字符为一组，输出所有可能的组合

    val arr1 = Array("a","b","c")
    val arr2 = arr1.combinations(2)
    arr2.foreach(x => println(x.mkString(",")))
    /**
    a,b
    a,c
    b,c
    */

contains

序列中是否包含指定对象
返回值类型为 Boolean 值 true 或 false

    val arr = Array("a","b","c")
    println(arr.contains("b"))

containsSlice

判断当前序列中是否包含另一个序列
另一个序列在序列中连续比较、顺序不可乱

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

copyToArray

将集合 a 复制到一个空集合 b 中
a 集合元素不够时，在末尾补 0
从新数组的第几位开始，拷贝原数组的位数，其余位置补 0

	val b : Array[Char] = new Array(5)
	a.copyToArray(b)			//复制集合,集合不足数，在末尾补空格
	a.copyToArray(b,1)			//从目标地址开始
	a.copyToArray(b,1,2)		//从新数组的第几位开始,拷贝原数组的位数

copyToBuffer

先导入import scala.collection.mutable._包
将数组的内容拷贝到Buffer(缓存)中

	val b:ArrayBuffer[Char] = ArrayBuffer()
	a.copyToBuffer(b)
	println(b.mkString(","))

corresponds

判断两个序列长度，对应位置元素是否规定条件符合某个条件
下面代码检查 a 和 b 长度是否相等，并且 a 中元素是否小于 b 中对应位置的元素

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

count

统计符合条件的元素个数
下面统计大于2的元素个数

	val a = Array(1,2,3)
	println(a.count({x:Int => x > 2}))

diff

返回将当前数组中没有在另一个数组中出现的元素

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

distinct

去除当前集合中重复的元素，只保留一个(去重)

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

drop

删除当前序列前 n 个元素，返回一个新的数组

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

dropRight

删除当前序列后面 n 个元素，返回一个新的数组

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

dropWhile

删除当前数组中符合条件的元素，返回一个新的数组
从第一个不满足条件的元素开始输出后面所有元素

	val a = Array(3,2,3,4)
	val c = a.dropWhile( {x:Int => x > 2} )
	println(c.mkString(","))

endsWith

判断是否以某个序列结尾

	val a = Array(3,2,3,4)
	val b = Array(3,4)
	println(a.endsWith(b))

exists

判断当前数组是否包含符合条件的元素

	val a = Array(3,2,3,4)
	println(a.exists( _==3 ))   //true
	println(a.exists( {x:Int => x==3} ))   //true
	println(a.exists( {x:Int => x==30} ))  //false

filter

参数为一个函数
取得当前数组中符合条件的元素，组成新的数组返回

	val a = Array(1,3,2,3,4)
	val b = a.filter( {x:Int => x > 2} )
	println(b.mkString(","))

filterNot

与 filter 作用相反，取得当前数组中不符合条件的元素

	val a = Array(1,3,2,3,4)
	val b = a.filterNot( {x:Int => x> 2} )
	println(b.mkString(","))

find

查找第一个符合条件的元素
没有符合条件的元素则返回 None

	val a = Array(1,12,3,4)
	val b = a.find( {x:Int => x>2} )
	println(b)  // Some(12)

flatMap

可用于分隔字符
可输出某个值到集合中每个元素的集合，可加步长；类似于 for 循环的条件改变

	val a = Array(1,2,3,4)
	val b = a.flatMap(_.split(","))	//用空格分隔字符串
	val b = a.flatMap(1 to _ by 1)	//类似于for循环的条件改变

flatten

将二维数组的所有元素联合在一起，返回一个一维数组

	val dArr = Array(Array(1,2,4),Array(4,5,6))
	val c = dArr.flatten
	println(c.mkString(","))
	//输出结果为：1,2,4,4,5,6

fold

对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同
fold中，seqno 是把初始值顺序和每个元素相加，把得到的结果与下一个元素进行运算
aggregate中，seqno 是把初始值与每个元素相加，但结果不参与下一步运算，而是放到另一个序列中，由第二个方法 combine 进行处理

  def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
  def combine(m:Int,n:Int): Int ={
    val s = "com_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
  val a = Array(1, 2, 3,4)
  val b = a.fold(5)(seqno)
  val c = a.par.aggregate(5)(seqno,combine)

a.par.aggregate(700)((x,y)=>{println(x,y);if(x>y) x else y},(x,y)=>{println(x,y);if(x>y) x else y})

foldLeft

初始值依次从左往右加上数组中的元素，等价于/:

  def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
    val a = Array(1, 2, 3,4)
    val b = a.foldLeft(5)(seqno)
    // (5 /: a)(_+_)

foldRight

初始值依次从右往左加上数组中的元素，等价于:\

  def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
    val a = Array(1, 2, 3,4)
    val b = a.foldRight(5)(seqno)
    //(a :\ 5)(_+_)

forall

检测序列中的元素是否都满足条件，有一个不满足条件则结果为 false

	val a = Array(1,2,3,4)
	val b = a.forall( _>0 )
	val b = a.forall( {x:Int => x>0})   //true
	val c = a.forall( {x:Int => x>2})   //false

foreach

遍历序列中的元素，进行 f 操作
检测序列中的元素是否满足条件 p

	//遍历序列中的元素，进行 f 操作
	val a = Array(1,2,3,4)
	a.foreach(println)
	println(a.mkString(","))
	a.foreach(x => println(x*10))

	//检测序列中的元素是否满足条件p
	val a = Array(1,2,3,4)
	val b = a.foreach( {x:Int => println(x>0)} )   //true
	val c = a.foreach( {x:Int => x>2})   //false

groupBy

按条件分组，返回值是Map类型，每个 key 对应一个序列
把小于3的数字放到一组，大于3的放到一组，返回Map[String，Array[Int]]

    val a = Array(1, 2, 3,4)
    val b = a.groupBy( x => x match {
      case x if (x < 3) => "small"
      case _ => "big"
    })

grouped

按指定数量分组,每组有 n 个元素，返回一个集合

	val a = Array(1,2,3,4,5)
	val b = a.grouped(3).toList
	b.foreach(x => println("第"+(b.indexOf(x)+1)+"组:"+x.mkString(",")))
	/**
	第1组:1,2,3
	第2组:4,5
	*/

hasDefiniteSize

检测序列是否存在有限的长度，对应 Stream 这样的流数据，返回 false
特例：如果迭代器为空，则返回 true，否则返回 false

	val a = Array(1,2,3,4,5)
	println(a.hasDefiniteSize)  //true
	println(a.toStream.hasDefiniteSize)  //false

head

返回序列的第一个元素

	val a = Array(10,2,3,4,5)
	println(a.head)

headOption

返回Option类型对象,就是scala.Some(第一个元素)
空集返回 None

	val a = Array(1,2,3,4,5)
	println(a.headOption)   //Some(1)

indexOf

返回指定值在序列中的索引，找到第一个就返回；若不存在则返回 -1
返回指定值在序列中的索引，从指定索引处开始查找，找到第一个就返回

	val a = Array(1,3,2,3,4)
	println(a.indexOf(3))   // return 1
	val a = Array(1,3,2,3,4)
	println(a.indexOf(3,2)) // return 3

indexOfSlice

检测当前序列中是否包含另一个序列，并返回第一个匹配出现的元素的索引；不存在则返回 -1

	val a = Array(1,3,2,3,4)
	val b = Array(2,3)
	println(a.indexOfSlice(b))  // return 2

indexWhere

返回当前序列中第一个满足条件的元素的索引，并可从指定索引处开始查找

    val a = Array(1,2,3,4)
    println(a.indexWhere( {x:Int => x>3}))  // return 3
    val a = Array(1,2,3,4,5,6)
    println(a.indexWhere( {x:Int => x>3},4))    // return 4

indices

返回当前序列索引集合

    val a = Array(10,2,3,40,5)
    a.indices

init

返回当前序列中不包含最后一个元素的序列

    val a = Array(10,2,3,40,5)
    val b = a.init
    println(b.mkString(","))
    //输出结果为：10,2,3,40

inits

对一个序列多次执行init操作，直到输出为空时结束，将每次执行init操作产生的所有元素组成一个新序列输出

    val a = Array(1,2,3,4,5)
	a.inits.toList
	//输出结果为：List(Array(1, 2, 3, 4, 5), Array(1, 2, 3, 4), Array(1, 2, 3), Array(1, 2), Array(1), Array()

intersect

取两个集合的交集组成新数组返回

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

isDefinedAt

判断序列中指定索引处是否有内容

    val a = Array(1,2,3,4,5)
    println(a.isDefinedAt(1))   // true
    println(a.isDefinedAt(10))  // false

isEmpty

判断当前序列是否为空

    val a = Array(1,5,6)
    a.isEmpty	//false

isTraversableAgain

判断序列是否可以反复遍历；一般返回 true，对于 Iterators 返回 false

	val a = Array(null)
	a.isTraversableAgain

iterator

对序列中的每个元素产生一个 iterator

	val a = Array(1,2,3,4,5)
	a.iterator.toList

last

取得序列中最后一个元素

    val a = Array(1, 2, 3, 4, 5)
    a.last

lastIndexOf

取得序列中最后一个指定元素的位置下标，并且可以在指定坐标之前的元素中查找

    val a = Array(1, 4, 2, 3, 4, 5)
    a.lastIndexOf(4)   // return  4
    a.lastIndexOf(4,3) // return  1

lastIndexOfSlice

判断当前序列中是否包含另一个序列，并返回最后一次出现该序列的位置处的索引；并且可以在指定坐标之前的元素中查找

    val a = Array(1,4,2,3,4,5,1,4)
    val b = Array(1,4)
    a.lastIndexOfSlice(b)  //return 6
    a.lastIndexOfSlice(b,4)	//return 0

lastIndexWhere

返回当前序列中最后一个满足条件的元素的索引；并且可以在指定坐标之前的元素中查找

    val a = Array(1,4,2,3,4,5,1,4)
    a.lastIndexWhere( {x:Int => x<2} )  // return 6
    a.lastIndexWhere( {x:Int => x<2},2 )    // return 0

lastOption

返回当前序列中最后一个对象

    val a = Array(1,2,3,4,5)
    a.lastOption  // return  Some(5)

length

返回当前序列中元素个数

    val a = Array(1,2,3,4,5)
    a.length   // return  5

lengthCompare

返回集合长度与参数的差值

    val a = Array(1,2,3,4,5)
    a.lengthCompare(10)	//return -5

map

遍历数组中每个元素；对序列中的元素进行参数（函数）中的操作

    val a = Array(1,2,3,4,5)
    val b = a.map( {x:Int => x*10} )
    println(b.mkString(","))    // 10,20,30,40,50

max

返回序列中最大的元素

    val a = Array(1,2,3,4,5)
    a.max  // return  5

maxBy

返回序列中第一个符合条件的元素；若序列中没有符合条件的元素则返回第一个元素

    val a = Array(1,2,3,4,5)
    a.maxBy( {x:Int => x > 2}) // return  3

min

返回序列中最小的元素

    val a = Array(1,2,3,4,5)
    println(a.min)  // return  1

minBy

返回序列中第一个不符合条件的元素；若全部符合条件，则返回第一个元素

    val a = Array(1,2,3,4,5)
    println(a.minBy( {x:Int => x > 2})) // return  1

mkString

将所有元素组合成一个字符串，可以没有参数，也可以有1到3个参数，3个参数依次代表：开始边界符、分隔符、结束边界符

    val a = Array(1,2,3,4,5)
    a.mkString // return  12345
    a.mkString(",") //return 1,2,3,4,5
    a.mkString("{",",","}"))    // return  {1,2,3,4,5}

nonEmpty

判断序列不为空

    val a = Array(1,2,3,4,5)
    a.nonEmpty

padTo

后补齐序列，如果当前序列长度小于第一个参数，那么新产生的序列长度为第一个参数
多出的几个位值填充第二个参数，如果当前序列大于等于第一个参数，则返回当前序列

    val a = Array(1,2,3,4,5)
    val b = a.padTo(7,9)    //需要一个长度为7的新序列,空出的填充9
    println(b.mkString(","))    // return  1,2,3,4,5,9,9

par

返回一个并行实现，产生的并行序列，不能被修改
相当于多线程操作，往往与其他方法一起使用

    val a = Array(1, 2, 3, 4, 5)
    a.par

partition

按条件将序列拆分成两个新的序列,满足条件的放到第一个序列中，其余的放到第二个序列
下面以序列元素是否是2的倍数来拆分

    val a = Array(1,2,3,4,5)
    val b:(Array[Int],Array[Int]) = a.partition( {x:Int => x % 2 == 0})
    println(b._1.mkString(","))     // return  2,4
    println(b._2.mkString(","))     // return  1,3,5

patch

patch(from,b,num) 需传递3个参数
批量替换，从原序列的 from 处开始，后面的 num 个元素，将被替换成序列 b

    val a = Array(1,2,3,4,5)
    val b = Array(3,4,6)
    val c = a.patch(1,b,2)
    println(c.mkString(","))    // return 1,3,4,6,4,5
    /**从 a 的第二个元素开始
	取两个元素
	即 2和3 ,这两个元素被替换为b的内容
	*/

permutations

排序，列出所有可能的序列

    val a = Array(1,2,3)
    val b = a.permutations.toList   // b 中将有6个结果

prefixLength

返回第一个不满足条件元素的前面元素个数

    val a = Array(1,2,3,4,1,2,3,4)
    val b = a.prefixLength( {x:Int => x<3}) // b = 2

product

返回所有元素乘积的值，只对 Int 型数组管用

    val a = Array(1,2,3,4,5)
    a.product       // b = 120  （1*2*3*4*5）

reduce

作用与 fold 相同，不需要初始值

  val fun:PartialFunction[Any,Int] = {
    case 'a' => 'A'
    case x:Int => x*100
  }
  val a = Array(1,2,3,4,5)
  val b = a.reduce(seqno)
  //return 15

reduceOption

计算 Option，参考 reduce

reduceLeft

从左向右计算

reduceLeftOption

计算 Option，参考 reduceLeft

reduceRight

从右向左计算

reduceRightOption

计算 Option，参考 reduceRight

reverse

反转序列，即将序列倒序

    val a = Array(1,2,3,4,5)
    a.reverse	//5,4,3,2,1

reverseIterator

反向生成迭代

	val a = Array(1,2,3,4,5)
    a.reverseIterator
    //toList后的结果为：5,4,3,2,1

reverseMap

传入一个函数，做map操作后再做reverse倒序操作

	val a = Array(1,2,3,4,5)
	a.reverseMap(x=>x*10)
	//50, 40, 30, 20, 10

sameElements

判断两个序列是否顺序和对应位置上的元素都一样

    val a = Array(1,2,3,4,5)
    val b = Array(1,2,3,4,5)
    a.sameElements(b)  // true
    val c = Array(1,2,3,5,4)
    a.sameElements(c)  // false

scan

用法同 fold，scan 会把每一步的计算结果放到一个新的集合中返回

    val a = Array(1,2,3,4,5)
    val b = a.scan(5)(seqno)
    println(b.mkString(","))    // 5,6,8,11,15,20

scanLeft

用法同上，从左向右计算

scanRight

从右向左计算

segmentLength

从指定位置开始查找满足条件的连续元素的长度；若指定位置处不满足条件则返回 0

    val a = Array(1,2,3,4,5)
    val b = a.segmentLength( {x:Int => x < 3},3) 	//return 3

seq

产生一个引用当前序列的sequential视图

size

序列元素个数，同length

    val a = Array(1,2,3,4,5)
	a.size	//return 5

slice

取出当前序列中某段序列，传入两个参数为元素下标，左闭右开截取

    val a = Array(1,2,3,4,5,6,7,8,9)
	a.slice(3,6)//return (4,5,6)

sliding

从集合第一个元素开始，按指定个数元素为一组划分，然后向右移动相应步长（默认步长为1）后取指定个数元素第二组，像这样依次移动到最后一个元素时结束，返回所有组的集合

    val a = Array(1,2,3,4,5,6,7,8,9)
	a.sliding(2).toList
	//输出结果为：List[Array[Int]] = List(Array(1, 2), Array(2, 3), Array(3, 4), Array(4, 5))
	a.sliding(2,2).toList
	//输出结果为：List[Array[Int]] = List(Array(1, 2), Array(3, 4), Array(5))

sortBy

排序，默认升序排序

    val a = Array(1,2,4,3,2,5,5,6,7,8,9)
	a.sortBy(x=>x)//升序
	a.sortBy(x=>{-x})//降序

sortWith

自定义排序方法

    val a = Array(1,2,4,3,2,5,5,6,7,8,9)
    a.sortWith(_.compareTo(_)>0)

sorted

升序排序

    val a = Array(3,2,1,4,5)
    a.sorted
    //return 1,2,3,4,5

span

分隔序列为两个集合，以第一个不满足条件的元素分隔，前面的元素放到第一个集合中，其他元素放到第二个集合中

    val a = Array(3,2,1,4,5)
    a.span( {x:Int => x > 1})
    //res466: (Array[Int], Array[Int]) = (Array(3, 2),Array(1, 4, 5))

splitAt

从指定下标位置开始，把序列拆分成两个集合；下标之前的元素放到第一个集合，其他元素放到第二个集合

    val a = Array(3,2,1,4,5)
    a.splitAt(3)
    //res469: (Array[Int], Array[Int]) = (Array(3, 2, 1),Array(4, 5))

startsWith

判断集合是否以某个序列开始，并且可从集合的指定下标处开始判断

    val a = Array(0,1,2,3,4,5)
    val b = Array(1,2)
    a.startWith(b)	//false
    a.startWith(b,1)	//true

stringPrefix

返回 toString 结果的前缀

    val a = Array(0,1,2,3,4,5)
    println(a.toString())       //[I@3daa57fb
    val b = a.stringPrefix
    println(b)      //[I

subSequence

返回序列中下标为两个参数之间的序列，左闭右开原则
该方法仅对字符数组有用，其他类型数组没有该方法

    val chars = Array('a','b','c','d')
    chars.subSequence(1,3)	//return  bc

sum

对序列中所有元素求和，注意需为Int型数组

    val a = Array(1,2,3,4,5)
    a.sum       //  15

tail

与init相反，去掉第一个元素，返回剩下的元素

    val a = Array(1,2,3,4,5)
    val b = a.tail      //  2,3,4,5

tails

与inits相反，依次去掉第一个元素

    val a = Array(1,2,3,4,5)
    val b = a.tails.toList
    //res493: List[Array[Int]] = List(Array(1, 2, 3, 4, 5), Array(2, 3, 4, 5), Array(3, 4, 5), Array(4, 5), Array(5), Array())

take

返回当前序列中前 n 个元素组成的序列（n为参数）

    val a = Array(1,2,3,4,5)
    a.take(3)       //  1,2,3

takeRight

返回当前序列中后 n 个元素组成的序列（n为参数）

    val a = Array(1,2,3,4,5)
    a.takeRight(3)       //  3,4,5

takeWith

返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列；第一个元素不满足条件时返回空

    val a = Array(1,2,3,4,5)
    a.takeWhile( {x:Int => x < 3})      //  1,2

to…

转换到相应的类型：
toArray
toBuffer
toIndexedSeq
toIterable
toIterator
toList
toMap（元组仅有）
toSeq
toSet
toStream
toTraversable
toVector

以上方法都是讲数组转换到相对应的类型

transform

遍历集合，对集合中所有元素进行操作

	val a=Array(1,2,3,4,5)
	a.transfrom({x=>x})	//(1,2,3,4,5)
	a.transfrom({x=>{-x}})	//(-1,-2,-3,-4,-5)
	a.transfrom({x=>{x*10}})	//(10,20,30,40,50)

transpose

矩阵转换，二维数组行转列操作，行数大于1

    val chars = Array(Array("a","b"),Array("c","d"),Array("e","f"))
    chars.transpose	//(a,c,e)(b,d,f)

union

用法与++相同

    val a = Array(1,2,3,4,5)
    val b = Array(6,7)
    a.union(b)	// 1,2,3,4,5,6,7

unzip

元组的行转列操作，注意每行只能有两个元素，行数大于1

	val a=Array((1,2),(3,4))
	a.unzip	//((1,3),(2,4))

unzip3

元组的行转列操作，注意每行必须是三个元素，行数大于1

	val a=Array((1,2,3),(4,5,6))
	a.unzip	//((1,4),(2,5),(3,6))

update

修改原数组中指定下标处的元素为第二个参数值

	val a=Array(1,2,3,4,5,6)
	a.update(3,9)	//原数组改变为：(1,2,3,9,5,6)

updated

修改数组中指定下标处的元素为第二组参数值并生成新数组返回，原数组不变

	val a=Array(1,2,3,4,5,6)
	a.updated(3,9)	//原数组不变，返回新数组为：(1,2,3,9,5,6)

view

返回序列中指定两个下标之间的序列，遵循左闭右开原则

    val a = Array(1,2,3,4,5)
    a.view(1,3)	//2,3

withFilter

根据条件过滤元素

    val a = Array(1,2,3,4,5)
    a.withFilter( {x:Int => x>3} ).map(x=>x)	//4,5

zip

将两个序列对应位置上的元素组成一个pair序列

    val a = Array(1,2,3,4,5)
    val b = Array(5,4,3,2,1)
    a.zip(b)	//(1,5),(2,4),(3,3),(4,2),(5,1)

zipAll

与zip相同，区别是zipAll会补齐较短的数组，而zip会舍弃较长数组多出来的部分元素

    val a = Array(4,5,6,7)
    val b = Array(3,2,1)
    a.zipAll(b,9,8)	//(4,3)(5,2),(6,1),(7,8)
    
    val a = Array(1,2,3,4)
    val b = Array(5,4,3,2,1)
    val c = a.zipAll(b,9,8)  //(1,5),(2,4),(3,3),(4,2),(9,1)

zipWithIndex

序列中的每个元素和它的索引组成一个序列

    val a = Array(10,20,30,40)
    a.zipWithIndex
    //(10,0),(20,1),(30,2),(40,3)

绿萝蔓蔓绕枝生

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录