scala里的集合操作练习(2)

最新推荐文章于 2022-12-01 09:59:07 发布

Geek白先生

最新推荐文章于 2022-12-01 09:59:07 发布

阅读量232

点赞数

分类专栏： Scala 文章标签： scala 集合练习

本文链接：https://blog.csdn.net/weixin_43699817/article/details/100559643

版权

Scala 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

集合操作练习第二弹：

(1) def filter(p: (T) => Boolean): Array[T]取得当前数组中符合条件的元素，组成新的数组返回

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

def filterNot(p: (T) => Boolean): Array[T] 该方法则与 filter 作用相反

(2) def find(p: (T) => Boolean): Option[T] 查找第一个符合条件的元素

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

(3) flateen 将二维数组的所有元素联合在一起，形成一个一维数组返回
def flatten[U](implicit asTrav: (T) => collection.Traversable[U], m: ClassTag[U]): Array[U]

val arr1=Array(Array(1,2,3),Array(4,5,6))
val arr2=arr1.flatten
println(arr2.mkString(","))
//1,2,3,4,5,6

(4) reduce、fold、aggregate 对比

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

val b = a.fold(5)(seqno)		//对序列中的每个元素进行二元运算
println(b)
val c = a.par.fold(5)(seqno)	//并行处理
println(c)

val d = a.aggregate(5)(seqno,combine)
println(d)
val e = a.par.aggregate(5)(seqno,combine)
println(e)

val f = a.reduce(seqno)
println(f)
val g = a.par.reduce(seqno)
println(g)

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
}

//结果输出：
seq_exp=5+1
seq_exp=6+2
seq_exp=8+3
seq_exp=11+4
seq_exp=15+5
20
seq_exp=5+3
seq_exp=5+2
seq_exp=5+4
seq_exp=5+5
seq_exp=5+1
seq_exp=6+7
seq_exp=9+10
seq_exp=8+19
seq_exp=13+27
40
seq_exp=5+1
seq_exp=6+2
seq_exp=8+3
seq_exp=11+4
seq_exp=15+5
20
seq_exp=5+3
seq_exp=5+1
seq_exp=5+2
seq_exp=5+4
seq_exp=5+5
com_exp=9+10
com_exp=6+7
com_exp=8+19
com_exp=13+27
40
seq_exp=1+2
seq_exp=3+3
seq_exp=6+4
seq_exp=10+5
15
seq_exp=4+5
seq_exp=1+2
seq_exp=3+9
seq_exp=3+12
15

结果发现:
1） fold中，seqno是把初始值顺序和每个元素相加，把得到的结果与下一个元素进行运算
2）而aggregate中，seqno是把初始值与每个元素相加，但结果不参与下一步运算，而是放到另一个序列中，由第二个方法combine进行处理
3）reduce 跟fold 的效果相同，reduce 不用初始值

(5) foldLeft、foldRight 从左到右计算和从右到左计算，及其简写方法

def foldLeft[B](z: B)(op: (B, T) => B): B
从左到右计算，简写方式：def /:[B](z: B)(op: (B, T) => B): B

def foldRight[B](z: B)(op: (B, T) => B): B
从右到左计算，简写方式：def :\[B](z: B)(op: (T, B) => B): B

val a = Array(1,2,3,4,5)
   val h = a.foldLeft(5)(seqno)  	//从左向右开始计算
   println(h)
   //输出：
    seq_exp=5+1
	seq_exp=6+2
	seq_exp=8+3
	seq_exp=11+4
	seq_exp=15+5
	20
//可简写为：
 	val h = (10 /: a)(_+_)
 	println(h) 						//直接输出结果：25
	
   val i = a.foldRight(5)(seqno)    //从右向左开始计算
   println(i)
   //输出：
    seq_exp=5+5
	seq_exp=4+10
	seq_exp=3+14
	seq_exp=2+17
	seq_exp=1+19
	20
//可简写为：
	val i = (a :\ 10)(_+_)
	println(i) 
 
 def seqno(m:Int,n:Int): Int ={
   val s = "seq_exp=%d+%d"
   println(s.format(m,n))
   return m+n
 }

(6) foreach 遍历数组中的元素
def foreach(f: (A) => Unit): Unit

val a = Array(1, 2, 3,4)
   a.foreach(x => println(x*10))
   //输出：
  	10
	20
 	30
	40

(7) 返回数组中某个值的索引
def indexOf(elem: T): Int
返回elem在序列中的索引，找到第一个就返回

def indexOf(elem: T, from: Int): Int
返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回

val a = Array(1, 3, 2, 3, 5, 4, 10, 4)
    println(a.indexOf(4))		//返回4的索引  结果为 5
    println(a.indexOf(4,5))		//从索引 = 5开始，第一个数即为 4 ，所以返回索引结果为 5
    println(a.indexOf(4,6))		//从索引 = 6开始，第一个数为 10 ，所以返回索引结果为 7

(8)def grouped(size: Int): collection.Iterator[Array[T]]
按指定数量分组，每组有 size 数量个元素，返回一个集合

val b = a.grouped(3).toList
    b.foreach((x) => println("第"+(b.indexOf(x)+1)+"组:"+x.mkString(",")))
    //输出结果:
    第1组:1,3,2
	第2组:3,5,4
	第3组:6,4

(9)def hasDefiniteSize: Boolean 检测序列是否存在有限的长度，对应Stream这样的流数据，返回false
val a = Array(1, 2, 3,4,5)
println(a.hasDefiniteSize) //true

(10)def head: T 返回序列的第一个元素，如果序列为空，将引发错误
val a = Array(1, 2, 3,4,5)
println(a.head) //1

(11)def headOption: Option[T]
返回Option类型对象，就是scala.Some 或者 None，如果序列是空，返回None
val a = Array(1, 2, 3,4,5)
println(a.headOption) //Some(1)

(12)def indexOfSlice[B >: A](that: GenSeq[B]): Int
检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引
val a = Array(1, 3, 2, 3, 4)
val b = Array(3,2)
println(a.indexOfSlice(b)) // 返回出 3 的索引： 1

def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引，指定从 from 索引处开始

val a = Array(1, 3, 2, 3, 2, 3, 4)
val b = Array(2,3)
println(a.indexOfSlice(b,3))    // 返回 a 中第二个 2 的索引  4

(14)indexWhere 和 lastIndexWhere
def indexWhere(p: (T) => Boolean): Int 返回当前序列中第一个满足 p 条件的元素的索引

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

def indexWhere(p: (T) => Boolean, from: Int): Int
返回当前序列中第一个满足 p 条件的元素的索引，可以指定从 from 索引处开始

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

def lastIndexWhere(p: (T) => Boolean): Int 返回当前序列中最后一个满足条件 p 的元素的索引

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

def lastIndexWhere(p: (T) => Boolean, end: Int): Int 可以指定在 end 之前（包括）的元素中查找
println(a.lastIndexWhere( {x:Int => x<2},2)) // return 0

(16)def indices: collection.immutable.Range 返回当前序列索引集合

val a = Array(10, 2, 3, 40, 5)
val b = a.indices
println(b.mkString(","))    // 0,1,2,3,4

(18) def init: Array[T] 返回当前序列中不包含最后一个元素的序列
val a = Array(10, 2, 3, 40, 5)
val b = a.init
println(b.mkString(",")) // 10, 2, 3, 40

(19)def inits: collection.Iterator[Array[T]]
inits对集合中的元素进行 init 操作，该操作的返回值中，第一个值是当前序列的副本，包含当前序列所有的元素，
最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象

val a = Array(4, 7, 3, 9, 5)
val b = a.inits.toList
for(i <- 1 to b.length){
	val s = "第%d个值：%s"
	println(s.format(i,b(i-1).mkString(",")))
}
//输出结果：
第1个值：4,7,3,9,5
第2个值：4,7,3,9
第3个值：4,7,3	
第4个值：4,7
第5个值：4
第6个值：

(20)def intersect(that: collection.Seq[T]): Array[T] 取两个集合的交集
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

(21)def isDefinedAt(idx: Int): Boolean 判断序列中是否存在指定索引
val a = Array(1, 2, 3, 4, 5)
println(a.isDefinedAt(1)) // true
println(a.isDefinedAt(10)) // false

def isTraversableAgain: Boolean判断序列是否可以反复遍历
该方法是GenTraversableOnce中的方法，对于Traversables一般返回true，对于Iterators返回false，除非被复写

def iterator: collection.Iterator[T] 对序列中的每个元素产生一个 iterator
val a = Array(1, 2, 3, 4, 5)
val b = a.iterator //此时就可以通过迭代器访问 b

def last: T 取得序列中最后一个元素
val a = Array(1, 2, 3, 4, 5)
println(a.last) // 结果为：5

def lastOption: Option[T] 返回当前序列中最后一个对象
val a = Array(1, 2, 3, 4, 5)
println(a.lastOption) // 结果返回：Some(5)

def length: Int 返回序列的个数 或者 def size Int
println(a.length) // return 5
priintln(a.size) // return 5

def max: A 返回序列中最大的元素
println(a.max) // return 5

def maxBy[B](f: (A) => B): A 返回序列中第一个符合条件的最大的元素
val a = Array(1, 2, 3, 4, 5)
println(a.maxBy( {x:Int => x > 2})) // return 3

def nonEmpty: Boolean 判断序列不是空
def isEmpty :Boolean 判断序列是否为空

(22) lastIndexOf
def lastIndexOf(elem: T): Int 返回序列中最后一个等于 elem 的元素的索引位置
val a = Array(1, 4, 2, 3, 4, 5)
println(a.lastIndexOf(4)) // return 4

def lastIndexOf(elem: T,end: Int): Int
取得序列中最后一个等于elem的元素的位置，可以指定在end之前（包括）的元素中查找
val a = Array(1, 4, 2, 3, 4, 5)
println(a.lastIndexOf(4,3)) // return 1

(23)def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
判断当前序列中是否包含序列that，并返回最后一次出现该序列的位置处的索引
val a = Array(1, 4, 2, 3, 4, 5, 1, 4)
val b = Array(1, 4)
println(a.lastIndexOfSlice(b)) // return 6

def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int
指定在end之前（包括）的元素中查找
println(a.lastIndexOfSlice(b,4)) // return 0

(24)def padTo(len: Int, elem: A): Array[A]后补齐序列
如果当前序列长度小于len，那么新产生的序列长度是len，多出的几个位值填充elem
如果当前序列大于等于len，则返回当前序列

    val a = Array(1, 2, 3, 4, 5, 6)
    val b = a.padTo(8,9)    //需要一个长度为 7的新序列，空出的填充 9
    val c = a.padTo(4,10)   //需要一个长度为 4的序列，空出的填充 10
    println(b.mkString(","))    // return  1,2,3,4,5,9,9
    println(c.mkString(","))    //原序列长度为6 大于4，所以返回原序列  1,2,3,4,5,6

(25)def par: ParArray[T] 返回一个并行实现，产生的并行序列，不能被修改
val a = Array(1, 2, 3, 4, 5)
val b = a.par // ParArray(1, 2, 3, 4, 5, 6)

(26)def partition(p: (T) => Boolean): (Array[T], Array[T])
按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列

 //下面以序列元素是否是2的倍数来拆分
    val a = Array(1, 2, 3, 4, 5)
    val b = a.partition( {x:Int => x % 2 == 0})
    //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

def span(p: (T) => Boolean): (Array[T], Array[T])
分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，之前的元素放到第一个集合，其它的放到第二个集合

val a = Array(3,2,1,4,5)
val b = a.span( {x:Int => x > 2})
println(b._1.mkString(","))     //  3
println(b._2.mkString(","))     //  2,1,4,5

def splitAt(n: Int): (Array[T], Array[T]) 从指定位置开始，把序列拆分成两个集合

 val a = Array(3,2,1,4,5)
val b = a.splitAt(2)
println(b._1.mkString(",")) //  3,2
println(b._2.mkString(",")) //  1,4,5

(27) def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
批量替换，从原序列的from处开始，后面的replaced数量个元素，将被替换成序列that

val a = Array(9, 2, 7, 4, 5, 10)
val b = Array(3, 4, 6)
val c = a.patch(1,b,4)       //从索引为 1开始，将后面4个元素值替换成b序列
println(c.mkString(","))    // return 9,3,4,6,10

(28)def prefixLength(p: (T) => Boolean): Int
给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p

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

(29)def product: A 返回所有元素乘积的值
val a = Array(1,2,3,4,5)
val b = a.product // b = 120 （12345）

(30) reduceLeft 和 reduceRight

val a = Array(1,2,3,4,5)
val b = a.reduceLeft(seqno)			//从左向右计算
println(b)
val c = a.reduceRight(seqno)		//从右向左计算
println(c)
// 输出结果：
	seq_exp=1+2
	seq_exp=3+3
	seq_exp=6+4
	seq_exp=10+5
	15
	seq_exp=4+5
	seq_exp=3+9
	seq_exp=2+12
	seq_exp=1+14
	15

(31)def reverse: Array[T] 反转序列
val a = Array(1,2,3,4,5)
val b = a.reverse
println(b.mkString(",")) //5,4,3,2,1

(32)def reverseIterator: collection.Iterator[T] 反向生成迭代
def reverseMap[B](f: (A) => B): Array[B] 同map方向相反
val a = Array(1,2,3,4,5)
val b = a.reverseMap( {x:Int => x*10} )
println(b.mkString(",")) // 50,40,30,20,10

(33)def sameElements(that: GenIterable[A]): Boolean 判断两个序列是否顺序和对应位置上的元素都一样
val a = Array(1,2,3,4,5)
val b = Array(1,2,3,4,5)
println(a.sameElements(b)) // true

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

(34)def scan[B >: A, That](z: B)(op: (B, B) => B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That
用法同fold，scan会把每一步的计算结果放到一个新的集合中返回，而fold返回的是单一的值
scanLeft 从左向右计算
scanRight 从右向左计算

val a=Array(1,2,3,4,5)
val b = a.fold(5)(seqno)	//使用fold
println(b)
//输出结果：
seq_exp=5+1
seq_exp=6+2
seq_exp=8+3
seq_exp=11+4
seq_exp=15+5
20

val c= a.scan(5)(seqno)		//使用scan
println(c.toList)
//输出结果：
seq_exp=5+1
seq_exp=6+2
seq_exp=8+3
seq_exp=11+4
seq_exp=15+5
List(5, 6, 8, 11, 15, 20)

(35)def segmentLength(p: (T) => Boolean, from: Int): Int
从序列的from处开始向后查找，所有满足p的连续元素的长度
val a = Array(1,2,3,1,1,1,1,1,4,5)
val b = a.segmentLength( {x:Int => x < 3},3) // return 5

(36)def slice(from: Int, until: Int): Array[T] 取出当前序列中，from 到 until 之间的片段
val a=Array(5,3,6,7,1,9,2)
println(a.slice(2,4).mkString(",")) // 6,7

(37)def sliding(size: Int): collection.Iterator[Array[T]]
从第一个元素开始，每个元素和它后面的size-1个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够size数，则停止

val a = Array(1,2,3,4,5)
val b = a.sliding(3).toList
	for(i<-0 to b.length - 1){
 		val s = "第%d个：%s"
 		println(s.format(i,b(i).mkString(",")))
	}
 //输出结果：
第0个：1,2,3
第1个：2,3,4
第2个：3,4,5

def sliding(size: Int, step: Int): collection.Iterator[Array[T]]
可以设置步进 step，第一个元素组合完后，下一个从上一个元素位置+step后的位置处的元素开始

val a = Array(1,2,3,4,5)
val b = a.sliding(3,2).toList   //第一个从1开始， 第二个从3开始，因为步进是 2
	for(i<-0 to b.length - 1){
  		val s = "第%d个：%s"
 		println(s.format(i,b(i).mkString(",")))
	}
// 输出结果：
 第0个：1,2,3
 第1个：3,4,5

(38)def sortBy[B](f: (T) => B)(implicit ord: math.Ordering[B]): Array[T] 按指定的排序规则排序
val a = Array(3,2,1,4,5)
val b = a.sortBy( {x:Int => x})
println(b.mkString(",")) // 1,2,3,4,5

def sortWith(lt: (T, T) => Boolean): Array[T] 自定义排序方法 lt
val a = Array(3,2,1,4,5)
val b = a.sortWith(.compareTo() > 0) // 大数在前
println(b.mkString(",")) // 5,4,3,2,1

def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T] 使用默认的排序规则对序列排序
val a = Array(3,2,1,4,5)
val b = a.sorted
println(b.mkString(",")) // 1,2,3,4,5

(39)def startsWith[B](that: GenSeq[B], offset: Int): Boolean 从指定偏移处，是否以某个序列开始
val a = Array(0,1,2,3,4,5)
val b = Array(1,2)
println(a.startsWith(b,1)) // true
println(a.startsWith(b,2)) // false

(40)def stringPrefix: String 返回 toString 结果的前缀

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

(41)def subSequence(start: Int, end: Int): CharSequence返回 start 和 end 间的字符序列
val chars = Array(‘a’,‘b’,‘c’,‘d’)
val b = chars.subSequence(1,3)
println(b.toString) // bc

(42)def tail: Array[T] 返回除了当前序列第一个元素的其它元素组成的序列
val a = Array(1,2,3,4,5)
val b = a.tail // 2,3,4,5

def take(n: Int): Array[T]返回当前序列中前 n 个元素组成的序列
val a = Array(1,2,3,4,5)
val b = a.take(3) // 1,2,3

def takeRight(n: Int): Array[T] 返回当前序列中，从右边开始，选择 n 个元素组成的序列
val a = Array(1,2,3,4,3,5,2,3)
val b = a.takeWhile( {x:Int => x < 4}) //1,2,3
println(b.mkString(","))

def takeWhile(p: (T) => Boolean): Array[T]
返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列
val a = Array(1,2,3,4,5)
val b = a.takeWhile( {x:Int => x < 3}) // 1,2

(43)类型转换

def toArray: Array[A]
转换成 Array 类型
def toBuffer[A1 >: A]: Buffer[A1]
转换成 Buffer 类型
def toIndexedSeq: collection.immutable.IndexedSeq[T]
转换成 IndexedSeq 类型
def toIterable: collection.Iterable[T]
转换成可迭代的类型
def toIterator: collection.Iterator[T]
同 iterator 方法
def toList: List[T]
同 List 类型
def toMap[T, U]: Map[T, U]
同 Map 类型，需要被转化序列中包含的元素时 Tuple2 类型数据
val chars = Array((“a”,“b”),(“c”,“d”),(“e”,“f”))
val b = chars.toMap
println(b) //Map(a -> b, c -> d, e -> f)
def toSeq: collection.Seq[T]
同 Seq 类型
def toSet[B >: A]: Set[B]
同 Set 类型
def toStream: collection.immutable.Stream[T]
同 Stream 类型
def toVector: Vector[T]
同 Vector 类型
def transpose[U](implicit asArray: (T) => Array[U]): Array[Array[U]]
矩阵转换，二维数组行列转换
val chars = Array(Array(“a”,“b”),Array(“c”,“d”),Array(“e”,“f”))
val b = chars.transpose
println(b.mkString(","))

(44)def union(that: collection.Seq[T]): Array[T] 联合两个序列，效果同操作符 ++
val a = Array(1,2,3,4,5)
val b = Array(6,7)
val c = a.union(b)
println(c.mkString(",")) // 1,2,3,4,5,6,7

(45)def unzip3[T1, T2, T3](implicit asTriple: (T) => (T1, T2, T3), ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3])
将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列

val chars = Array(("a","b","x"),("c","d","y"),("e","f","z"))
val b = chars.unzip3
println(b._1.mkString(","))     //a,c,e
println(b._2.mkString(","))     //b,d,f
println(b._3.mkString(","))     //x,y,z

(46) def update(i: Int, x: T): Unit 将序列中 i 索引处的元素更新为 x
val a = Array(1,2,3,4,5)
a.update(1,9)
println(a.mkString(",")) //1,9,3,4,5

(47)def view(from: Int, until: Int): IndexedSeqView[T, Array[T]] 返回 from 到 until 间的序列，不包括 until 处的元素

val a=Array(4,5,3,7,8,2,0,9)
val b=a.view(3,6)
println(b.mkString(","))   // 7,8,2

(48)def withFilter(p: (T) => Boolean): FilterMonadic[T, Array[T]] 根据条件 p 过滤元素
val a = Array(1,2,3,4,5)
val b = a.withFilter( {x:Int => x>3}).map(x=>x)
println(b.mkString(",")) //4,5

(49)def zip[B](that: GenIterable[B]): Array[(A, B)] 将两个序列对应位置上的元素组成一个pair序列

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

def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
同zip，但是允许两个序列长度不一样，不足的自动填充，如果当前序列短，空出的填充为thisElem，如果that短，填充为thatElem

val a = Array(1,2,3,4,5,6,7)
val b = Array(5,4,3,2,1)
val c = a.zipAll(b,9,8)         //(1,5),(2,4),(3,3),(4,2),(5,1),(6,8),(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)

(50) def zipWithIndex: Array[(A, Int)]** 序列中的每个元素和它的索引组成一个序列**

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

Geek白先生

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
scala里的集合操作练习(2)

集合操作练习第二弹：(1) def filter(p: (T) => Boolean): Array[T]取得当前数组中符合条件的元素，组成新的数组返回val a = Array(3, 2, 3,4) val b = a.filter( {x:Int => x> 2} ) println(b.mkString(",")) //3,3,4def fil...
复制链接

扫一扫