文章目录
- 一、元素操作
- 二、元素取头尾
- 三、数组中的计算
- 四、字符串相关操作
- 五、方法操作
- 六、指定条件判断
- 七、下标索引操作
- 1、apply
- 2、charAt
- 3、indexOf(elem)、indexOf(elem, from)
- 4、indexOfSlice(that)、indexOfSlice(that, from)
- 5、indexWhere(p)、indexWhere(p, from)
- 6、lastIndexOf(elem: T)、lastIndexOf(elem: T, end: Int)
- 7、lastIndexOfSlice(that)、lastIndexOfSlice(that, end)
- 8、lastIndexWhere(p)、lastIndexWhere(p, end)
- 9、indices
- 10、slice
- 11、subSequence
- 12、view
- 八、数组拆分排序
- 九、数组长度
- 十、两数组操作
- 十一、数组克隆和复制
- 十二、数组反转
- 十三、数组的行列操作
- 十四、类型转换
一、元素操作
1、+：(添加元素)
● 定义：def +:(elem: A): Array[A]
● 描述：在数组前面添加一个元素，并返回新的数组对象，冒号的方向指向数组
var a1 = Array.range(1,5)
a1.foreach(x=>print(s"$x "))
println()
(12 +: a1).foreach(x=>print(s"$x "))
2、 :+ (添加元素)
● 定义：def :+(elem: A): Array[A]
● 描述：在数组后面添加一个元素，并返回新的数组对象，冒号的方向指向数组
var a2 = Array.range(1,5)
a2.foreach(x=>print(s"$x "))
println()
(a2:+ 10).foreach(x=>print(s"$x "))
3、combinations
● 定义：def combinations(n: Int): collection.Iterator[Array[T]]
● 描述：选出n个元素进行排列组合，不考虑顺序，并去重
var a3 = Array.range(1,5)
a3.foreach(x=>print(s"$x "))
println()
a3.combination(3).foreach(x=>print(x=>x.mkString("-")))
4、distinct
● 定义：def distinct: Array[T]
● 描述：去除当前集合中重复的元素
var a4 = Array(1,2,3,1)
a4.foreach(x=>print(s"$x "))
println()
a4.distinct.foreach(x=>print(s"$x "))
5、drop
● def drop(n: Int): Array[T]
● 描述：删掉前n个元素，返回一个新数组
// 跟下标索引无关
var a5 = Array(1,2,3,4)
a5.foreach(x=>print(s"$x "))
println()
a5.drop(2).foreach(x=>print(s"$x "))
6、dropRight
● 定义：def dropRight(n: Int): Array[T]
● 描述：删掉后n个元素，返回一个新数组
var a6 = Array(1,2,3,4,5,6)
a6.foreach(x=>print(s"$x "))
println()
a6.dropRight(3).foreach(x=>print(s"$x "))
7、dropWhile
●
● 描述：从第一个符合的元素开始删除满足条件的元素，若第一个元素就不符合条件则不做任何删除操作
var a7 = Array.range(1,5)
a7.foreach(x=>print(s"$x "))
println()
a7.dropWhile(x=>x%2==0).foreach(x=>print(s"$x "))
println()
a7.dropWhile(x=>x<3 && x>=1).foreach(x=>print(s"$x "))
8、max
● def max: A
● 描述：返回序列中最大的元素
var a8 = Array.range(1,5)
a8.foreach(x=>print(s"$x "))
println()
println(a8.max)
9、min
● 定义：def min: A
● 描述：返回序列中最小的元素
var a9 = Array.range(1,5)
a9.foreach(x=>print(s"$x "))
println()
println(a9.min)
10、maxBy
● 定义：def maxBy[B](f: (A) ⇒ B): A
● 描述：返回序列中符合条件的第一个元素
var a10 = Array(1,5,8,10)
a10.foreach(x=>print(s"$x "))
println()
println(a10.maxBy(_ > 2))
11、minBy
● 定义：def minBy[B](f: (A) ⇒ B): A
● 描述：返回序列中不符合条件的第一个元素
a10.foreach(x=>print(s"$x "))
println()
println(a10.minBy(_ < 5))
12、padTo （序列填充）
● 定义：def padTo(len: Int, elem: A): Array[A]
● 描述：填充序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列
a10.foreach(x=>print(s"$x "))
println()
a10.padTo(10,"-").foreach(x=>print(s"$x "))
println()
a10.padTo(3,"-").foreach(x=>print(s"$x "))
13、patch
println("----patch(批量替换、删除操作)------")
a10.foreach(x=>print(s"$x "))
println()
a10.patch(0,Array(12,13,14),2).foreach(x=>print(s"$x ")) // 替换
println()
a10.patch(2,Array(12,13,14),0).foreach(x=>print(s"$x ")) // 添加
println()
a10.patch(2,"",2).foreach(x=>print(s"$x ")) // 删除
// 或者可以这么写删除操作
// 写个空数组，最后把需要替换的写成空数组
println()
var i:Array[Int] = Array() 空集合会报错，必须用这种形式
a10.patch(2,i,2).foreach(x=>print(s"$x "))
println()
a10.patch(1,i,2).foreach(x=>print(s"$x "))
14、permutations
● 定义：def permutations: collection.Iterator[Array[T]]
● 描述：permutations 表示排列，这个排列组合会选出所有排列顺序不同的字符组合，permutations 与 combinations 不同的是，相同的组合考虑排列，对于 “abc”、“cba”，视为不同的组合
println("------permutations:组合，考虑排序-------")
a10.foreach(x=>print(s"$x "))
println()
a10.permutations.foreach(x=>println(x.mkString("{","-","}")))
println()
15、prefixLength
● 定义：def prefixLength(p: (T) ⇒ Boolean): Int
● 描述：由第一个索引开始，返回序列中满足条件p的元素数量，直到有不满足的则结束
println("--------prefixLength:检索符合条件的元素个数，遇到不符合的结束--------")
a10.foreach(x=>print(s"$x "))
println()
println(a10.prefixLength(_ > 0))
println(a10.prefixLength(_ > 2))
println(a10.prefixLength(_<2))
16、transform
● 定义：def transform(f: Int => Int): scala.collection.mutable.WrappedArray[Int]
● 描述：将序列中的元素转换成指定的元素（同类型），原数组会被改变
println("---------transform：转换成指定类型，原数组会改变------------")
a10.transform(Math.pow(_,2).toInt).foreach(x=>print(s"$x "))
println()
a10.sorted.transform(Math.pow(_,3).toInt).foreach(x=>print(s"$x "))
// 查看原数组是否变化了
println()
a10.foreach(x=>print(s"$x ")) // 原数组已经变化了
17、update
● 定义：def update(i: Int, x: T): Unit
● 描述：将序列中 i 索引处的元素更新为 x，改变原数组，返回更改后的新数组
println("-----update:更新指定索引处数组元素(替换)，原数组变化--------")
var a11 = Array(1,5,8,10)
a11.foreach(x=>print(s"$x "))
println()
// 返回的是一个数组
a11.update(2,3)
a11.foreach(x=>print(s"$x "))
18、updated
● 定义：def updated(index: Int, elem: A): Array[A]
● 描述：将序列中 i 索引处的元素更新为 x，不改变原数组
println("---------updated:更新数组元素，原数组不改变------")
a11.foreach(x=>print(s"$x "))
println()
a11.updated(2,9).foreach(x=>print(s"$x "))
println()
//查看原数组是否变化了
a11.foreach(x=>print(s"$x "))
二、元素取头尾
1、head
● 定义：def head: T
● 描述：返回序列的第一个元素，如果序列为空，将引发错误
println("------------head:取第一个元素-----------")
a11.foreach(x=>print(s"$x "))
println()
println(a11.head)
2、headOption
● 定义：def headOption: Option[T]
● 描述：返回序列的第一个元素的 Option 类型对象，如果序列为空，则返回 None
println("-------headOption:返回第一个元素的Option对象-----------")
a11.foreach(x=>print(s"$x "))
println()
println(a11.headOption)
var b:Array[Int] = Array() // 空数组
println(b.headOption)
3、last
● 定义：def last: T
● 描述：返回序列的最后一个元素，如果序列为空，将引发错误
println("----------last-----------")
a11.foreach(x=>print(s"$x "))
println()
println(a11.last)
4、lastOption
● 定义：def lastOption: Option[T]
● 描述：返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None
println("---------lastOption：返回序列对象的最后一个元素的Option类型对象----------")
a11.foreach(x=>print(s"$x "))
println()
var b1:Array[Int] = Array()
println(b1.lastOption)
println(a11.lastOption)
5、tail
● 定义：def tail: Array[T]
● 描述：返回当前序列中不包含第一个元素的序列，除了头都是尾
println("--------------tail：取尾----------------")
a11.foreach(x=>print(s"$x "))
println()
a11.tail.foreach(x=>print(s"$x "))
6、tails
● 定义：def tails: collection.Iterator[Array[T]]
● 描述：和inits类似，只不过每一步都是取尾部进行 tail 操作
println("----------tails:不断取尾----------------")
a11.foreach(x=>print(s"$x "))
println()
a11.tails.foreach(x=>{x.foreach(y=>print(s"$y "));println()})
7、init
● 定义：def init: Array[T]返回当前序列中不包含最后一个元素的序列
● 描述：返回当前序列中不包含最后一个元素的序列
println("----init:返回当前序列不包含最后一个元素的序列(不包尾)----")
a11.foreach(x=>print(s"$x "))
println()
a11.init.foreach(x=>print(s"$x "))
7.1、inits
● 定义：def inits: collection.Iterator[Array[T]]
● 描述：对集合中的元素进行 init 迭代操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，每一步都进行 init 操作，上一步的结果作为下一步的操作对象；返回一个二维数组
println("---------inits:每次的数组都是上一次的副本，最后一个值为空---------")
a11.foreach(x=>print(s"$x "))
println()
a11.inits.foreach(x=>{{x.foreach(y=>print(s"$y "));println()}})
8、take
● 定义：def take(n: Int): Array[T]
● 描述：返回当前序列中，前 n 个元素组成的序列
println("--------take:返回前n个数组成的序列--------")
a11.foreach(x=>print(s"$x "))
println()
a11.take(2).foreach(x=>print(s"$x "))
9、takeRight
● 定义：def takeRight(n: Int): Array[T]
● 描述：返回当前序列中，从右边开始，后 n 个元素组成的序列
println("------takeRight:从右边开始，后n个员孙组成的序列--------")
a11.foreach(x=>print(s"$x "))
println()
a11.takeRight(3).foreach(x=>print(s"$x "))
10、takeWhile
● 定义：def takeWhile(p: (T) ⇒ Boolean): Array[T]
● 描述：返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列，如果第一个值不满足，则返回空，不管后面的元素了
println("----takeWhile:满足条件的元素组成一个序列，第一个不满足返回空------")
a11.foreach(x=>print(s"$x "))
println()
a11.takeWhile(_>2).foreach(x=>print(s"$x "))
println()
a11.takeWhile(_<8).foreach(x=>print(s"$x "))
三、数组中的计算
1、/: :\
● 定义：def /:[B](z: B)(op: (B, T) ⇒ B): B ， def :[B](z: B)(op: (T, B) ⇒ B): B
● 描述：对数组中所有的元素从左向右、从右向左遍历，进行相同的迭代操作，分别为foldLeft 和foldRight 的简写
(有初始值0)
println("------------/:-迭代-----------")
a11.foreach(x=>print(s"$x "))
println()
val add = (x:Int,y:Int) => {
var z = x + y
println(s"$x + $y = $z")
z
}
println(a11./:(0)(add))
println(a11.:\(0)(add))
2、fold
● 定义：def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1ClassTag[U]): Array[U]
● 描述：对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同
（有初值0）
println("------------fold:迭代-> /:-----------")
a11.foreach(x=>print(s"$x "))
println()
val add1 = (x:Int,y:Int) =>{
var z = x + y
println(s"$x + $y = $z")
z
}
println(a11.fold(0)(add1))
3、flodRight
● 定义：foldRight[B](z: B)(op: (B, T) ⇒ B): B
● 描述：从右到左计算
println("---------foldRight:从右到左计算-----------")
a11.foreach(x=>print(s"$x "))
println()
val add2 = (x:Int,y:Int) =>{
var z = x + y
println(s"$x + $y = $z")
z
}
println(a11.foldRight(0)(add2))
4、foldLeft
● 定义：def foldLeft[B](z: B)(op: (B, T) ⇒ B): BClassTag[U]): Array[U]
● 描述：从左到右计算
println("------foldLeft:从左向右计算--------")
a11.foreach(x=>print(s"$x "))
println()
val add3 = (x:Int,y:Int)=>{
var z = x + y
println(s"$x + $y = $z")
z
}
println("fold")
println(a11.fold(0)(add3))
println()
println("foldLeft")
println(a11.foldLeft(0)(add))
println()
println("foldRigt")
println(a11.foldRight(0)(add))
5、product
● 定义：def product: A
● 描述：返回所有元素乘积的值
println("------product:返回所有你元素乘积值----")
a11.foreach(x=>print(s"$x "))
println()
println(a11.product)
6、reduce
● 定义：def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
● 描述：对序列中的每个元素进行二元运算，不需要初始值，其他的和fold一样
println("-----reduce:迭代计算，没有初始值，其余和fold一样------")
a11.foreach(x=>print(s"$x "))
println()
println(a11.reduce((x,y) => {
var z = x + y
println(s"$x + $y = $z")
z
}))
7、reduceLeft
● 定义：def reduceLeft[B >: A](op: (B, T) ⇒ B): B
● 描述：同 foldLeft，从左向右计算，不需要初始值
println("---reduceLeft:从左向右计算-----")
a11.foreach(x=>print(s"$x "))
println()
println(a11.reduceLeft((x,y)=>{
var z = x + y
println(s"$x + $y = $z")
z
}))
8、reduceRight
● 定义：def reduceRight[B >: A](op: (B, T) ⇒ B): B
● 描述：同 foldRight，从右向左计算，不需要初始值
println("---reduceRight:从右向左计算-----")
a11.foreach(x=>print(s"$x "))
println()
println(a11.reduceRight((x,y)=>{
var z = x + y
println(s"$x + $y = $z")
z
}))
9、reduceOption
● 定义：def reduceOptionA1>:A: scala.Option[A1]
● 描述：同 reduceLeftOption，计算Option，返回 Option
println("---reduceOption:返回Option-----")
a11.foreach(x=>print(s"$x "))
println()
println(a11.reduceOption((x,y)=>{
var z = x + y
println(s"$x + $y = $z")
z
}))
10、reduceLeftOption
● 定义：def reduceLeftOption[B >: A](op: (B, T) ⇒ B): Option[B]
● 描述：同 reduceLeft，返回 Option
println("---reduceLeftOption:返回Option-----")
a11.foreach(x=>print(s"$x "))
println()
println(a11.reduceLeftOption((x,y)=>{
var z = x + y
println(s"$x + $y = $z")
z
}))
11、reduceRightOption
● 定义：def reduceRightOption[B >: A](op: (T, B) ⇒ B): Option[B]
● 描述：同 reduceRight，返回 Option
println("---reduceRightOption:返回Option-----")
a11.foreach(x=>print(s"$x "))
println()
println(a11.reduceRightOption((x,y)=>{
var z = x + y
println(s"$x + $y = $z")
z
}))
12、scan
● 定义：def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That
● 描述：同 fold，scan 会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是最后的结果
println("-----scan:返回每一步的结果值，放到一个新集合，同fold----")
a11.foreach(x=>print(s"$x "))
println()
a11.scan(0)(_+_).foreach(x=>print(s"$x "))
13、scanLeft
● 定义：def scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
● 描述：同 scan，从左向右计算，每一步的计算结果放到一个新的集合中返回
println("-----scanLeft:从左向右计算----")
a11.foreach(x=>print(s"$x "))
println()
a11.scanLeft(0)(_+_).foreach(x=>print(s"$x "))
14、scanRight
● 定义：def scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
● 描述：同 foldRight，从右向左计算，每一步的计算结果放到（从右向左放）一个新的集合中返回
println("-----scanRight:从右向左计算,从右往左放----")
a11.foreach(x=>print(s"$x "))
println()
a11.scanRight(0)(_+_).foreach(x=>print(s"$x "))
15、sum
● 定义：def sum: A
● 描述：序列求和，元素需为 Numeric[T] 类型
println("-------sum---------")
var c = Array.range(1,5)
c.foreach(c=>print(s"$c "))
println()
println(c.sum)
四、字符串相关操作
1、addString
● 定义：def addString(b: StringBuilder): StringBuilder | def addString(b: StringBuilder, sep: String): StringBuilder | def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
● 描述：将数组中的元素逐个添加到 StringBuilder 中 | 每个元素用 sep 分隔符分开 | 在首尾各加一个字符串，并指定sep分隔符
println("----addString:将数组元素添加到StringBuilder中------")
var a12 = Array(1,1,2)
a12.foreach(x=>print(s"$x "))
println()
var a13 = Array.range(1,5)
a13.foreach(x=>print(s"$x "))
println()
var builder = new StringBuilder
a12.addString(builder,"-")
println(builder)
a13.addString(builder,"[","-","]") // 添加到同一个Builder,之前已经添加了a12
println(builder)
var builder2 = new StringBuilder
println(a12.addString(builder2,"*"):StringBuilder)
2、mkString
● 定义：def mkString(start: String, sep: String, end: String): String
● 描述：将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾
println("-------mkString:拼接字符串------")
var a14 = Array(1,1,3)
a14.foreach(x=>print(s"$x "))
println()
var b2 = Array.range(1,5)
b2.foreach(x=>print(s"$x "))
println(a14.mkString("[", "-", "]"))
import scala.collection.mutable.ArrayBuffer // 导包
var lst = new ArrayBuffer[Int]
for (elem <- 1 to 5) {
lst.append(Random.nextInt(100))
}
println(lst.mkString("-"))
3、stringPrefix
● 定义：def stringPrefix: String
● 描述：返回 toString 结果的前缀
println("----stringPrefix:返回toString的前缀-----")
a14.foreach(x=>print(s"$x "))
println()
println(a14)
println(a14.stringPrefix)
五、方法操作
1、aggregate
● 定义：def aggregate[B](z : => B)(seqop : scala.Function2[B, A, B], combop : scala.Function2[B, B, B]) : B = { /* compiled code */ }
● 描述：aggregate是柯里化方法（将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数）， aggregate 方法是一个聚合函数，接受多个输入，并按照一定的规则运算以后输出一个结果值
println("----aggregate------")
var add4 = (x:Int,y:Int) =>{
var z = x + y
println(s"$x + $y = $z")
z
}
var lst2 = new ArrayBuffer[Int]
for (elem <- 1 to 5) {
lst2.append(Random.nextInt(100))
}
println(lst.par.aggregate(0)(add4, add4))
2、andThen
● 定义：override def andThen[C](k : scala.Function1[B, C]) : scala.PartialFunction[A, C] = { /* compiled code */ }
● 描述：表示方法的连续调用，相当于嵌套函数 a(b(x)(需要满足第一个函数的返回值类型为第二个函数的输入值类型)，与 compose 相反
println("----andThen:方法的连续调用-----")
var a15 = Array.range(1,5)
a15.foreach(x=>print(s"$x "))
println()
println(a15.andThen(x=>{
if (x % 3 == 0){
"match"
}
})(1))
println(a15.andThen(x=>{
if (x % 3 == 0) Some(x)
else None
})(2))
3、compose
● 定义：def compose[A](g : scala.Function1[A, T1]) : scala.Function1[A, R] = { /* compiled code */ }
● 描述：表示方法的连续调用，与 andThen 相反
4、applyOrElse
5、collect
● 定义：def collect[B](pf: PartialFunction[A, B]): Array[B]
● 描述：通过执行一个并行计算（偏函数），得到一个新的数组对象
println("----collect:通过并行计算得到一个新数组--------")
var a16 = Array.range(1,5)
a16.foreach(x=>print(s"$x "))
println()
a16.collect({case i if i % 2==0 => i}).foreach(x=>print(s"$x "))
6、collectFirst
● 定义：def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
● 描述：查找第一个符合偏函数定义的元素，并执行偏函数计算，返回值是元组
println("-----查找第一个符合偏函数定义的元数，返回一个元组------")
var a17 = Array.range(1,5)
a17.foreach(x=>print(s"$x "))
println()
println(a17.collectFirst({case i if i % 2 == 0 => i}))
7、foreach
● 定义：def foreach(f: (A) ⇒ Unit): Unit
● 描述：遍历序列中的元素，进行f的操作
println("-----foreach--------")
a17.foreach(x=>print(s"$x "))
println()
a16.foreach(x=>print(s"$x,"))
8、iterator
● 定义：def iterator: collection.Iterator[T]
● 描述：生成当前序列的迭代器
println("------iterator:生成当前序列的迭代器------")
var a18 = Array.range(1,5)
a18.foreach(x=>print(s"$x "))
println()
val it = a18.iterator
while (it.hasNext){
print(it.next()*3 + "\t")
}
9、map
● 定义：def map[B](f: (A) ⇒ B): Array[B]
● 描述：对序列中的元素进行 f 操作，返回生成的新序列，对一个维度的数据进行操作
println("------iterator:生成当前序列的迭代器------")
var a18 = Array.range(1,5)
a18.foreach(x=>print(s"$x "))
println()
val it = a18.iterator
while (it.hasNext){
print(it.next()*3 + "\t")
}
10、runWith
● 定义：def runWith[U](action : scala.Function1[B, U]) : scala.Function1[A, scala.Boolean] = { /* compiled code */ }
● 描述： 执行偏函数，当参数不在定义域内时，返回false，否则返回true，并执行action
六、指定条件判断
1、contains
● 定义：def contains[A1 >: A](elem: A1): Boolean
● 描述：判断序列中是否包含指定对象
println("--------contains--------")
a19.foreach(x=>print(s"$x "))
println()
println(a19.contains(5))
println(a19.contains(1))
2、containsSlice
● 定义：def containsSlice[B](that: GenSeq[B]): Boolean
● 描述：判断当前序列中是否包含另一个序列(数量和顺序相等)，是否包含子序列
println("--------containsSlice:是否包含子序列(顺序也要相同)---------")
a19.foreach(x=>print(s"$x "))
println()
println(a19.containsSlice(Array(1,2)))
println(a19.containsSlice(Array(1,3)))
3、count
● 定义：def count(p: (T) ⇒ Boolean): Int
● 描述：统计符合条件的元素个数
println("------count:统计符合条件的元素个数--------")
a19.foreach(x=>print(s"$x "))
println()
println(a19.count(_>3))
println(a19.count(_!=0))
println(a19.count(x=>(x> 3 && x < 9)))
4、endsWith
● 定义：def endsWith[B](that: GenSeq[B]): Boolean
● 描述：判断当前序列是否以某个序列结尾
println("----endsWith---------")
var a21 = Array.range(1, 5)
a21.foreach(x => print(x + "\t"))
println()
var a22 = Array.range(1,3)
a22.foreach(x => print(x + "\t"))
println()
var a23 = Array.range(4,5)
a23.foreach(x => print(x + "\t"))
println()
println(a21.endsWith(a22))
println(a21.endsWith(a23))
5、startsWith
● 定义：def startsWith[B](that: GenSeq[B], offset: Int): Boolean
● 描述：判断序列从指定偏移处是否以某个序列开始，第二个参数是主序列的偏移量，也就是从第n位开始的位置是否以子序列结束
println("------startWith----------")
println(a21.endsWith(a22))
println(a21.endsWith(a23))
6、exists
● 定义：def exists(p: (T) ⇒ Boolean): Boolean
● 描述：判断当前数组是否包含符合条件的元素
println("-----exists:判断某数组中是否包含符合条件的元素-------")
var a25 = Array(1,2,3,4,5)
a25.foreach(x=>println(s"$x "))
println()
println(a25.exists(_ > 5))
println(a25.exists(_ > 3))
7、filter、filterNot
● 定义：def filter(p: (T) ⇒ Boolean): Array[T]、def filterNot(p: (T) ⇒ Boolean): Array[T]
● 描述：取得当前数组中符合、不符合条件的元素，组成新的数组返回
var a25 = Array(1,2,3,4,5)
a25.foreach(x=>print(s"$x "))
println()
println(a25.exists(_ > 5))
println(a25.exists(_ > 3))
println()
println("-----filter:取出当前数组符合条件的值组成新数组------")
var a26 = Array.range(1,5)
a26.foreach(x=>print(s"$x "))
println()
a26.filter(_%2==0).foreach(x=>print(s"$x "))
println()
a26.filter(x=>x % 2 ==0).foreach(x=>print(s"$x "))
println()
a26.filterNot(x=>x%2!=0).foreach(x=>print(s"$x "))
8、withFilter
● 定义：def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
● 描述：根据条件 p 过滤元素,不生成新的集合
println("-------withFilter:过滤元素，改变原数组-------")
a26.foreach(x=>print(s"$x "))
println()
a26.withFilter(_>2).foreach(x=>print(s"$x "))
9、find
● 定义：def find(p: (T) ⇒ Boolean): Option[T]
● 描述：查找第一个符合条件的元素，返回 Option
println("--------find:查找第一个符合条件的值------")
var a27 = Array.range(1,5)
a27.foreach(x=>print(s"$x "))
println()
println(a27.find(_>2))
println(a27.find(_<4))
10、forall
● 定义：def forall(p: (T) ⇒ Boolean): Boolean
● 描述：检测序列中的元素是否都满足条件 p，如果序列为空，则返回 true
println("--------forall:检测所有元素是否都符合条件------")
println(a27.forall(_>4))
println(a27.forall(_<6))
11、hasDefiniteSize
● 定义：def hasDefiniteSize: Boolean
● 描述：检测序列是否存在有限的长度，对应 Stream 这样的流数据则返回 false，流没有确定的大小
println("----hasDefiniteSize:检测序列是否存在有限长度------")
a27.foreach(x=>print(s"$x "))
println()
println(a27.hasDefiniteSize)
println(a27.toStream)
println(a27.toStream.hasDefiniteSize)
12、isDefinedAt
● 定义：def isDefinedAt(idx: Int): Boolean
● 描述：判断序列中是否存在指定索引
println("-----isDefinedAt:判断是否存在指定索引------")
a27.foreach(x=>print(s"$x "))
println()
println(a27.isDefinedAt(2))
println(a27.isDefinedAt(4))
println(a27.isDefinedAt(7))
13、isEmpty
● 定义：def isEmpty: Boolean
● 描述：判断序列是否为空
println("-----isEmpty--------")
a27.foreach(x=>print(s"$x "))
println()
println(a27.isEmpty)
14、nonEmpty
● 定义：def nonEmpty: Boolean
● 描述：判断序列是否不为空
println("-----nonEmpty:判断序列是否不为空------")
a27.foreach(x=>print(s"$x "))
println()
println(a27.nonEmpty)
15、isTraversableAgain
● 定义：def isTraversableAgain: Boolean
● 描述：判断序列是否可以反复遍历，该方法是 GenTraversableOnce 中的方法，对于 Traversables 一般返回 true，对于 Iterators 返回 false，除非被复写 或者说判断是否为迭代器（只能遍历一次）
println("----isTraversableAgain:是否能反复遍历----")
a27.foreach(x=>print(s"$x "))
println()
println(a27.isTraversableAgain)
println(a27.toIterator.isTraversableAgain)
七、下标索引操作
1、apply
● 定义：def apply(i: Int): T
● 描述：获取指定索引处的元素
println("-----apply:获取指定索引处元素----")
a27.foreach(x=>print(s"$x "))
println()
println(a27.apply(1))
println(a27.apply(3))
println(a27.apply(0))
2、charAt
● 定义：def charAt(index: Int): Char
● 描述：获取 index 索引处的字符，这个方法会执行一个隐式的转换，将 Array[T] 转换为 ArrayCharSequence，只有当 T 为 Char 类型时，这个转换才会发生
println("------charAt:或者指定索引处字符------")
var a28 = Array('a','b','c','d')
a28.foreach(x=>print(s"$x "))
println()
println(a28.charAt(2))
println(a28.charAt(3))
3、indexOf(elem)、indexOf(elem, from)
● 定义：def indexOf(elem: T): Int、def indexOf(elem: T, from: Int): Int
● 描述：返回元素 elem 在序列中第一次出现的索引，【指定从索引 from 开始查找】
println("----indexOf:返回元素第一次在序列中出现的索引")
a27.foreach(x=>print(s"$x "))
println()
println(a27.indexOf(2))
println(a27.indexOf(5))
println(a27.indexOf(1,2)) // 第二个参数指定从哪个索引查起
// 找不到的返回-1
4、indexOfSlice(that)、indexOfSlice(that, from)
● 定义：def indexOfSlice[B >: A](that: GenSeq[B]): Int、def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
● 描述：检测当前序列中是否包含序列 that，并返回第一次出现该序列的索引，找不到返回-1；并且指定索引可以超出元素索引的范围，【指定从索引 from 开始查找，并返回第一次出现该序列】
println("-----indexOfSlice:检测是否包含序列----")
a27.foreach(x=>print(s"$x "))
println()
println(a27.indexOfSlice(Array(1,2)))
println(a27.indexOfSlice(Array(6,7)))
println(a27.indexOfSlice(Array(8,6)))
println(a27.indexOfSlice(Array(8,6),2))
5、indexWhere§、indexWhere(p, from)
● 定义：def indexWhere(p: (T) ⇒ Boolea
nt、def indexWhere(p: (T) ⇒ Boolean, from: Int): Int
● 描述：返回当前序列中第一个满足条件 p 的元素的索引【，指定从索引 from 开始查找】
println("-----indexwhere:返回当前序列第一个满足条件的元素索引------")
a27.foreach(x=>print(s"$x "))
println()
println(a27.indexWhere(_==6))
println(a27.indexWhere(_==2))
println(a27.indexWhere(_>2))
println(a27.indexWhere(_>1,2))
6、lastIndexOf(elem: T)、lastIndexOf(elem: T, end: Int)
● 定义：def lastIndexOf(elem: T): Int、def lastIndexOf(elem: T, end: Int): Int
● 描述：返回元素 elem 在序列中最后一次出现的索引【，指定在索引 end 之前（包括）的元素中查找】
println("-----lastIndexOf:返回元素在序列中最后那一次出现的索引----")
a27.foreach(x=>print(s"$x "))
println()
println(a27.lastIndexOf(2))
println(a27.lastIndexOf(6))
println(a27.lastIndexOf(3,2))
println(a27.lastIndexOf(2,0))
7、lastIndexOfSlice(that)、lastIndexOfSlice(that, end)
● 定义：def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
● 描述：检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引【，指定在索引 end 之前（包括）的元素中查找】
println("-----lastIndexOfSlice:返回最后一次包含指定序列的索引----")
a27.foreach(x=>print(s"$x "))
println()
println(a27.lastIndexOfSlice(Array(1,2)))
println(a27.lastIndexOfSlice(Array(6,7)))
println(a27.lastIndexOfSlice(Array(3,4),1))
8、lastIndexWhere§、lastIndexWhere(p, end)
● 定义：def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
● 描述：返回当前序列中最后一个满足条件 p 的元素的索引，指定在索引 end 之前（包括）的元素中查找
println("-----lastIndexWhere:最后一个满足条件得我元素索引----")
a27.foreach(x=>print(s"$x "))
println()
println(a27.lastIndexWhere(_==3))
println(a27.lastIndexWhere(_==8))
println(a27.lastIndexWhere(_>2,0))
9、indices
● 定义：def indices: collection.immutable.Range
● 描述：返回当前序列索引集合
println("----indices:返回当前序列索引集合-----")
a27.foreach(x=>print(s"$x "))
println()
println(a27.indices)
a27.indices.foreach(x=>print(s"$x "))
10、slice
● 定义：def slice(from: Int, until: Int): Array[T]
● 描述：返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素
println("-----slice:返回from到until之间的元素，[from,until)-----")
a27.foreach(x=>print(s"$x "))
println()
a27.slice(1,3).foreach(x=>print(s"$x "))
11、subSequence
● 定义：def subSequence(start: Int, end: Int): CharSequence
● 描述：返回 start 和 end 间的字符序列，不包含 end 处的元素，(返回 start 和 end 间的字符序列 只针对char类型(前包后不包))
println("----subSequence:from to end 类似slice，针对字符-----")
var a29 = Array('a','b','c','d')
a29.foreach(x=>print(s"$x "))
println()
println(a29.subSequence(1,3))
12、view
● 定义：def view(from: Int, until: Int): IndexedSeqView[T, Array[T]]
● 描述：返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素。对于数组的操作有点像slice，前包后不包
println("-----view:类似slice [)----")
a27.foreach(x=>print(s"$x "))
println()
a27.view(1,3).foreach(x=>print(s"$x "))
println()
println(a27.view(1,3))
八、数组拆分排序
1、group by
● 定义：def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]
● 描述：按条件分组，条件由 f 匹配，返回值是 Map 类型，每个 key 对应一个数组
println("-----groupBy-----")
val add5 = (x:Int,y:Int) =>{
val z = x + y
println(s"$x + $y = $z")
z
}
var array = Array(1,2,3,5,7)
println(array.groupBy(x=> x match {
case i if i % 2 == 0 => "even"
case i => "odd"
}).map(x=>(x._1,x._2.par.fold(0)(add5))))
2、grouped
● 定义：def grouped(size: Int): collection.Iterator[Array[T]]
● 描述：按指定数量分组，每组有 size 个元素，返回一个迭代器
println("------grouped:指定分几个组，每组size个元素，返回一个迭代器----")
array.grouped(2).foreach(x=>{
x.foreach(y=>print(y+"\t"))
println()
})
println(array.grouped(2).map(x=>x.fold(0)(add5)).fold(0)(add5))
3、par
● 定义：def par: ParArray[T]
● 描述：返回一个并行实现，产生的并行序列不能被修改，其作用相当于hashcode进行分区
println("------par:返回一个并行实现------")
var lst3 = new ArrayBuffer[Int]
for (elem <- 1 to 5) {
lst3.append(Random.nextInt(100))
}
lst3.foreach(x=>print(s"$x "))
println()
print(lst3.par)
4、partition
● 定义：def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])
● 描述：按条件将序列拆分成两个数组，满足条件的放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组
println("----partition：拆分成两个数组--------")
a27.foreach(x=>print(s"$x "))
println()
// 放到第二个元组里
a27.partition(_>2)._2.foreach(x=>print(s"$x "))
println()
a27.partition(_>2)._1.foreach(x=>print(s"$x "))
5、span
● 定义：def span(p: (T) ⇒ Boolean): (Array[T], Array[T])
● 描述：将序列拆分成两个数组，从第一个元素开始，直到第一个不满足条件的元素为止，其中的元素放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组
println("------scan:拆分成两个数组-------")
a27.foreach(x=>print(s"$x "))
println()
a27.span(_<=2)._1.foreach(x=>print(s"$x "))
println()
a27.span(_<=2)._2.foreach(x=>print(s"$x "))
6、splitAt
● 定义：def splitAt(n: Int): (Array[T], Array[T])
● 描述：从指定位置开始，把序列拆分成两个数组，指定索引位置元素放入第二个数组中
在这里插入代码片
7、sliding(size)、sliding(size, step)
● 定义：def sliding(size: Int): collection.Iterator[Array[T]]、def sliding(size: Int): collection.Iterator[Array[T]]
● 描述：滑动，从第一个元素开始，每个元素和它后面的 size个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够size时，则结束。【该方法可以设置步长 step，每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始】
● 如果size=step，则等同于grouped(5)
println("-----sliding:两两构成一个数组-----")
a27.foreach(x=>print(s"$x "))
println()
a27.sliding(2).foreach(x=>{x.foreach(y=>print(s"$y "));println()})
println()
a27.sliding(2,2).foreach(x=>{x.foreach(y=>print(s"$y "));println()})
println()
a27.sliding(3).foreach(x=>{x.foreach(y=>print(s"$y "));println()})
8、sortBy
● 定义：def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]
● 描述：按指定的排序规则对序列排序
println("----sortBy:按指定规则排序-----")
a27.foreach(x=>print(s"$x "))
println()
a27.sortBy(x=>x).foreach(x=>print(s"$x "))
println()
a27.sortBy(x=>(-x)).foreach(x=>print(s"$x "))
9、sorted
● 定义：def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]]
● 描述：使用默认的排序规则对序列排序，默认升序排列，无参数
println("-----sorted:默认升序，无参数-----")
a27.foreach(x=>print(s"$x "))
println()
a27.sorted.foreach(x=>print(s"$x "))
10、sortWith
● 定义：def sortWith(t:(T,T)=>boolean)：Array[T]
● 描述：自定义排序方法
println("-----sortWith:自定义排序-----")
a27.foreach(x=>print(s"$x "))
println()
a27.sortWith(_>_).foreach(x=>print(s"$x "))
println()
a27.sortWith(_<_).foreach(x=>print(s"$x "))
九、数组长度
1、length
● 定义：def length: Int
● 描述：返回序列元素个数
println("----length-----")
println(a27.length)
println(a27.size)
2、lengthCompare
● 定义：def lengthCompare(len: Int): Int
● 描述：比较序列的长度和参数 len，返回序列的长度减去参数len,根据二者的关系返回不同的值，长度length更小的话则为负，比较规则是：
x>0, length > len
x=0, length = len
x<0, length < len
println("-----lengthCompare:比较序列和参数len-----")
a27.foreach(x=>print(s"$x "))
println()
println(a27.length)
println(a27.lengthCompare(3))
println(a27.lengthCompare(5))
println(a27.lengthCompare(7))
3、segmentLength
● 定义：def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
● 描述：从序列的 from 开始向后查找，返回满足条件 p 的连续元素的长度，只返回第一个，第一个不满足的话就结束
println("-----segmentLength:返回满足条件的连续元素长度----")
a27.foreach(x=>print(s"$x "))
println()
println(a27.segmentLength(_>0,0))
println(a27.segmentLength(_>4,2))
4、size
● 定义：def size: Int
● 描述：返回序列元素个数，同 length
println("-----size------")
a27.foreach(x=>print(s"$x "))
println()
println(a27.size)
println(a27.length)
十、两数组操作
1、++
● 定义：def ++[B](that: GenTraversableOnce[B]): Array[B]
● 描述：合并两个集合，新数组包含左右两个集合的内容，如果两个数组类型不同，合同之后的类型为Array[Any]，类似Java里的Object类型
println("--------++:合并---------")
var d1 = Array.range(1,5)
d1.foreach(x=>print(s"$x "))
println()
var d2 = Array('a','b','c')
d2.foreach(x=>print(s"$x "))
println()
(d1++d2).foreach(x=>print(s"$x "))
2、++:
● 定义：def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
● 描述：也是两个数组组合起来，冒号旁边的类型决定生成新数组的数据类型
println("----++:决定新数组的数据类型----")
var d3 = Array.range(1,5)
d3.foreach(x=>print(s"$x "))
println()
var d4 = Array(1,0,1,2.0)
d4.foreach(x=>print(s"$x "))
println()
(d1++d4).foreach(x=>print(s"$x "))
3、canEqual
● 定义：def canEqual(that: Any): Boolean
● 描述：判断两个对象数组是否可以进行比较，基本上都可以比较，应该不常用
println("-----canEqual-----")
d1.foreach(x=>print(s"$x "))
println()
d2.foreach(x=>print(s"$x "))
println()
println(d1.canEqual(d2))
4、union
● 定义：def union(that: collection.Seq[T]): Array[T]
● 描述：合并两个序列，同操作符 ++
println("--------union:同++------")
d1.foreach(x=>print(s"$x "))
println()
d2.foreach(x=>print(s"$x "))
println()
(d1 union d2).foreach(x=>print(s"$x "))
5、corresponds
● 定义：def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean
● 描述：判断两个序列的长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且 p(x, y)=true，则返回 true,不满足返回false
println("----corrrsponds:判断相应位置是否相等-----")
d1.foreach(x=>print(s"$x "))
println()
d2.foreach(x=>print(s"$x "))
println()
println(d1.corresponds(d2))
6、diff
● 定义：def diff(that: collection.Seq[T]): Array[T]
● 描述：计算当前数组与另一个数组的差集，即将当前数组中没有在另一个数组中出现的元素返回
println("------diff:差集--------")
var c1 = Array(1,2,3)
var c2 = Array(1,2,3,4)
(c2 diff(c1)).foreach(x=>print(s"$x "))
7、intersect
● 定义：def intersect(that: collection.Seq[T]): Array[T]
● 描述：返回两个集合的交集
println("----intersect:交集--------")
(c2 intersect c1).foreach(println)
8、sameElements
● 定义：def sameElements(that: GenIterable[A]): Boolean
● 描述：判断两个序列是否顺序和对应位置上的元素都一样，值比较
十一、数组克隆和复制
1、clone
● 定义：def clone(): Array[T]
● 描述：创建一个数组的副本，复制数组的值,但不会引用地址；就是说是浅克隆，不是深克隆。
println("-----clone-----")
var f1 = Array.range(1,5)
f1.foreach(x=>print(s"$x "))
println()
var f2 = f1.clone()
println(f2==f1)
println(f2.sameElements(f1))
2、copyToArray
●
●
3、copyToBuffer
●
●
4、Seq
●
●
十二、数组反转
1、reverse
●
●
2、reverseIterator
●
●
3、reverseMap
●
●
十三、数组的行列操作
1、flatMap
●
●
2、flatten
●
●
3、transpose
●
●
4、unzip
●
●
5、unzip3
●
●
6、zip
●
●
7、zipAll
●
●
8、zipWithIndex
●
●
十四、类型转换
1、toArray
●
●
2、toBuffer
●
●
3、toIndexedSeq
●
●
4、toIterable
●
●
5、toIterator
●
●
6、toList
●
●
7、toMap
●
●
8、toSeq
●
●
9、toSet
●
●
10、toStream
●
●
11、toVector
●
●
443
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
