目录
PRFunctionTest
package test
object PRFunctionTest {
def main(args: Array[String]): Unit = {
//padTo 填充序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，
// 如果当前序列大于等于 len ，则返回当前序列
//填充一个长度为 7 的序列，不足位补 8
val a = Array(1, 2, 3, 4)
val b = a.padTo(7, 8)
println(b.mkString(",")) // 1,2,3,4,8,8,8
//par 返回一个并行实现，产生的并行序列不能被修改
val a1 = Array(1, 2, 3, 4)
val b1 = a1.par
println(b1.mkString(",")) // 1,2,3,4
//partition 按条件将序列拆分成两个数组，满足条件的放到第一个数组，
// 其余的放到第二个数组，返回的是包含这两个数组的元组
//下面以序列元素是否是偶数来拆分
val a2 = Array(1, 2, 3, 4)
val b2: (Array[Int], Array[Int]) = a.partition(x => x % 2 == 0)
println("偶数: " + b2._1.mkString(",")) // 偶数: 2,4
println("奇数: " + b2._2.mkString(",")) // 奇数: 1,3
//patch 批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 that
//从 a3 的第二个元素开始，取两个元素，即 2 和 3 ，将这两个元素替换为序列 b3
val a3 = Array(1, 2, 3, 4)
val b3 = Array(7, 8, 9)
val c3 = a3.patch(1, b3, 2)
println(c3.mkString(",")) // 1,7,8,9,4
//permutations
//permutations 表示排列，这个排列组合会选出所有排列顺序不同的字符组合，
//permutations 与 combinations 不同的是，相同的组合考虑排列，对于 “abc”、“cba”，视为不同的组合
val a4 = Array("a", "b", "c")
val b4 = a4.permutations.toList
b4.foreach(x => println(x.mkString(",")))
/**
* a,b,c
* a,c,b
* b,a,c
* b,c,a
* c,a,b
* c,b,a
*/
//def prefixLength(p: (T) ⇒ Boolean): Int
//prefixLength 给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p
val a5 = Array(1, 2, 3, 4)
println(a5.prefixLength(x => x < 3)) // 2
//product 返回所有元素乘积的值
val a6 = Array(1, 2, 3, 4)
println(a6.product) // 1*2*3*4=24
//reduce 同 fold，不需要初始值
//def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
def seqno(m: Int, n: Int): Int = {
val s = "seq_exp = %d + %d"
println(s.format(m, n))
m + n
}
val a7 = Array(1, 2, 3, 4)
val b7 = a7.reduce(seqno)
println("b = " + b7)
/**
* seq_exp = 1 + 2
* seq_exp = 3 + 3
* seq_exp = 6 + 4
* b = 10
*/
//reduceLeft 同 foldLeft，从左向右计算，不需要初始值
def seqno1(m: Int, n: Int): Int = {
val s1 = "seq_exp = %d + %d"
println(s1.format(m, n))
m + n
}
val a8 = Array(1, 2, 3, 4)
val b8 = a8.reduceLeft(seqno1)
println("b = " + b8)
/**
* seq_exp = 1 + 2
* seq_exp = 3 + 3
* seq_exp = 6 + 4
* b = 10
*/
//reduceRight 同 foldRight，从右向左计算，不需要初始值
def seqno2(m: Int, n: Int): Int = {
val s2 = "seq_exp = %d + %d"
println(s2.format(m, n))
m + n
}
val a9 = Array(1, 2, 3, 4)
val b9 = a9.reduceRight(seqno2)
println("b = " + b9)
/**
* seq_exp = 3 + 4
* seq_exp = 2 + 7
* seq_exp = 1 + 9
* b = 10
*/
//reduceLeftOption 同 reduceLeft，返回 Option
def seqno3(m: Int, n: Int): Int = {
val s3 = "seq_exp = %d + %d"
println(s3.format(m, n))
m + n
}
val a10 = Array(1, 2, 3, 4)
val b10 = a10.reduceLeftOption(seqno3)
println("b = " + b10)
/**
* seq_exp = 1 + 2
* seq_exp = 3 + 3
* seq_exp = 6 + 4
* b = Some(10)
*/
//reduceRightOption 同 reduceRight，返回 Option
def seqno4(m: Int, n: Int): Int = {
val s4 = "seq_exp = %d + %d"
println(s4.format(m, n))
m + n
}
val a11 = Array(1, 2, 3, 4)
val b11 = a11.reduceRightOption(seqno4)
println("b = " + b11)
/**
* seq_exp = 3 + 4
* seq_exp = 2 + 7
* seq_exp = 1 + 9
* b = Some(10)
*/
//reverse 反转序列
val a12=Array(1,2,3,4)
val b12=a12.reverse
println(b12.mkString(",")) //4,3,2,1
//reverseIterator 生成反向迭代器
val a13=Array(1,2,3,4)
val b13=a13.reverseIterator
b13.foreach(x=>println(x+" "))
/**
* 4
* 3
* 2
* 1
*/
//reverseMap 同 map，方向相反
val a14=Array(1,2,3,4)
val b14=a14.reverseMap(x=>x*10)
println(b14.mkString(",")) //40,30,20,10
}
}
SFunctionTest
package test
object SFunctionTest {
def main(args: Array[String]): Unit = {
//sameElements 判断两个序列是否顺序和对应位置上的元素都一样
val a = Array(1, 2, 3, 4)
val b = Array(1, 2, 3, 4)
println(a.sameElements(b)) // true
val c = Array(1, 3, 2, 4)
println(a.sameElements(c)) // false
//scan 同 fold，scan 会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是最后的结果
val a1 = Array(1, 2, 3, 4)
val b1 = a1.scan(5)(_ + _)
println(b1.mkString(",")) // 5,6,8,11,15
//scanLeft 同 foldLeft，从左向右计算，每一步的计算结果放到一个新的集合中返回
val a2 = Array(1, 2, 3, 4)
val b2 = a2.scanLeft(5)(_ + _)
println(b2.mkString(",")) // 5,6,8,11,15
//scanRight 同 foldRight，从右向左计算，每一步的计算结果放到（从右向左放）一个新的集合中返回
val a3 = Array(1, 2, 3, 4)
val b3 = a3.scanRight(5)(_ + _)
println(b3.mkString(",")) // 15,14,12,9,5
//segmentLength 从序列的 from 开始向后查找，返回满足条件 p 的连续元素的长度，只返回第一个
//def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
val a4 = Array(1, 2, 3, 1, 1, 1,4)
println(a4.segmentLength(x => x < 3, 3)) // 3
//seq 产生一个引用当前序列的 sequential 视图
val a5 = Array(1, 2, 3, 4)
val b5 = a5.seq
println(b5.mkString(",")) // 1,2,3,4
//size 返回序列元素个数，同 length
val a6 = Array(1, 2, 3, 4)
println(a6.size) // 4
//slice 返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素
val a7 = Array(1, 2, 3, 4)
val b7 = a7.slice(1, 3)
println(b7.mkString(",")) // 2,3
//sliding(size) 滑动，从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，
// 最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束
// val a8 = Array(1, 2, 3, 4, 5)
// val b8 = a8.sliding(3).toList
// for (i <- 0 to b.length - 1) {
// val s = "第 %d 组: %s"
// println(s.format(i + 1, b8(i).mkString(",")))
// }
/**
* 第 1 组: 1,2,3
* 第 2 组: 2,3,4
* 第 3 组: 3,4,5
*/
//sliding(size, step) 从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，
// 当剩余元素个数不够 size 时，则结束。该方法可以设置步长 step，
// 每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始
val a9 = Array(1, 2, 3, 4, 5)
val b9 = a9.sliding(3, 2).toList
for (i <- 0 to b9.length - 1) {
val s1 = "第 %d 组: %s"
println(s1.format(i + 1, b9(i).mkString(",")))
}
/**
* 第 1 组: 1,2,3
* 第 2 组: 3,4,5
*/
//sortBy 按指定的排序规则对序列排序
val a10 = Array(3, 2, 1, 4)
val b10 = a10.sortBy(x => x) // 按 x 从小到大，即对原序列升序排列
println("升序: " + b10.mkString(",")) // 1,2,3,4
val c10 = a10.sortBy(x => 0 - x) // 按 -x 从小到大，即对原序列降序排列
println("降序: " + c10.mkString(",")) // 4,3,2,1
//sorted 使用默认的排序规则对序列排序
val a11 = Array(3, 2, 1, 4)
val b11 = a11.sorted // 默认升序排列
println(b11.mkString(",")) // 1,2,3,4
//span 将序列拆分成两个数组，从第一个元素开始，直到第一个不满足条件的元素为止，
// 其中的元素放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组
val a12 = Array(1, 2, 3, 4)
val b12 = a12.span(x => x < 3)
println(b12._1.mkString(",")) // 1,2
println(b12._2.mkString(",")) // 3,4
//splitAt 从指定位置开始，把序列拆分成两个数组
val a13 = Array(1, 2, 3, 4,5,6)
val b13 = a13.splitAt(3)
println(b13._1.mkString(",")) // 1,2,3
println(b13._2.mkString(",")) // 4,5,6
//startsWith(that) 判断序列是否以某个序列开始
val a14 = Array(1, 2, 3, 4)
val b14 = Array(1, 2)
println(a14.startsWith(b14)) // true
//startsWith(that, offset) 判断序列从指定偏移处是否以某个序列开始
val a15 = Array(1, 2, 3, 4)
val b15 = Array(2, 3)
println(a15.startsWith(b15, 1)) // true
//stringPrefix 返回 toString 结果的前缀
val a16 = Array(1, 2, 3, 4)
println(a16.toString()) // [I@3ab39c39
println(a16.stringPrefix) // [I
//subSequence 返回 start 和 end 间的字符序列，不包含 end 处的元素
val a17 = Array('a', 'b', 'c', 'd')
val b17 = a17.subSequence(1, 3)
println(b17.toString) // bc
//sum 序列求和，元素需为 Numeric[T] 类型
val a18 = Array(1, 2, 3, 4)
println(a18.sum) // 10
}
}
TUWZFunctionTest
package test
object TUWZFunctionTest {
def main(args: Array[String]): Unit = {
//tail 返回当前序列中不包含第一个元素的序列
val a = Array(1, 2, 3, 4)
val b = a.tail
println(b.mkString(",")) // 2,3,4
//tails 同 inits，每一步都进行 tail 操作
val a1 = Array(1, 2, 3, 4)
val b1 = a1.tails.toList
for (i <- 0 until b1.length) {
val s = "第 %d 个值: %s"
println(s.format(i + 1, b1(i).mkString(",")))
}
/**
* 第 1 个值: 1,2,3,4
* 第 2 个值: 2,3,4
* 第 3 个值: 3,4
* 第 4 个值: 4
* 第 5 个值:
*/
//take 返回当前序列中，前 n 个元素组成的序列
val a2 = Array(1, 2, 3, 4)
val b2 = a2.take(2)
println(b2.mkString(",")) // 1,2
//takeRight 返回当前序列中，从右边开始，后 n 个元素组成的序列
val a3=Array(1,2,3,4)
val b3=a3.takeRight(2)
println(b3.mkString(",")) //3,4
//takeWhile 返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列
val a4 = Array(1, 2, 3, 4)
val b4 = a4.takeWhile(x => x < 3)
println(b4.mkString(",")) // 1,2
// toArray
// 定义：def toArray: Array[A]
//
// 描述：将序列转换成 Array 类型
//
//
// toBuffer
// 定义：def toBuffer[A1 >: A]: Buffer[A1]
//
// 描述：将序列转换成 Buffer 类型
//
//
// toIndexedSeq
// 定义：def toIndexedSeq: collection.immutable.IndexedSeq[T]
//
// 描述：将序列转换成 IndexedSeq 类型
//
//
// toIterable
// 定义：def toIterable: collection.Iterable[T]
//
// 描述：将序列转换成可迭代的类型
//
//
// toIterator
// 定义：def toIterator: collection.Iterator[T]
//
// 描述：将序列转换成迭代器，同 iterator 方法
//
//
// toList
// 定义：def toList: List[T]
//
// 描述：将序列转换成 List 类型
//
//
// toMap
// 定义：def toMap[T, U]: Map[T, U]
//
// 描述：将序列转转换成 Map 类型，需要被转化序列中包含的元素是 Tuple2 类型
//
//
// toSeq
// 定义：def toSeq: collection.Seq[T]
//
// 描述：将序列转换成 Seq 类型
//
//
// toSet
// 定义：def toSet[B >: A]: Set[B]
//
// 描述：将序列转换成 Set 类型
//
//
// toStream
// 定义：def toStream: collection.immutable.Stream[T]
//
// 描述：将序列转换成 Stream 类型
//
//
// toVector
// 定义：def toVector: Vector[T]
//
// 描述：将序列转换成 Vector 类型
//transpose 矩阵转置，二维数组行列转换 行转列
val a5 = Array(Array("a", "b"), Array("c", "d"), Array("e", "f"))
val b5 = a5.transpose
b5.foreach(x => println((x.mkString(","))))
/**
* a,b
* c,d
* e,f
*/
/**
* a,c,e
* b,d,f
*/
//union 合并两个序列，同操作符 ++
val a6 = Array((1, 2),(5,6))
val b6= Array(3, 4)
val c6 = a6.union(b6)
println(c6.mkString(",")) // (1,2),(5,6),3,4
//unzip 将含有两个二元组的数组，每个元组的第一个元素组成一个数组，
// 第二个元素组成一个数组，返回包含这两个数组的元组
val chars1 = Array(("a", "b"), ("c", "d"))
val b7 = chars1.unzip
println(b7._1.mkString(",")) // a,c
println(b7._2.mkString(",")) // b,d
//unzip3 将含有三个三元组的数组，每个元组的第一个元素组成一个数组，
// 第二个元素组成一个数组，第三个元素组成一个数组，返回包含这三个数组的元组
val chars2 = Array(("a", "b", "x"), ("c", "d", "y"), ("e", "f", "z"))
val b8 = chars2.unzip3
println(b8._1.mkString(",")) // a,c,e
println(b8._2.mkString(",")) // b,d,f
println(b8._3.mkString(",")) // x,y,z
//update 将序列中 i 索引处的元素更新为 x
//def update(i: Int, x: T): Unit
val a9 = Array(1, 2, 3, 4)
a9.update(1, 7)
println(a.mkString(",")) //1,7,3,4
//updated 将序列中 i 索引处的元素更新为 x，并返回替换后的数组 副本
val a10 = Array(1, 2, 3, 4)
val b10 = a10.updated(1, 7)
println(b10.mkString(",")) //1,7,3,4
//view 返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素
val a11 = Array(1, 2, 3, 4)
val b11 = a11.view(1, 3)
println(b11.mkString(",")) // 2,3
//withFilter 根据条件 p 过滤元素
val a12 = Array(1, 2, 3, 4)
val b12 = a12.withFilter(x => x > 2).map(x => x) //为了可以继续使用过滤
println(b12.mkString(",")) // 3,4
val a13 = Array(1, 2, 3, 4)
val b13 = a13.withFilter(x => x > 2).foreach(println(_))
/**
* 3
* 4
*/
val b14=a13.filter(x=>x<3)
println(b14.mkString(","))
//zip 将两个序列对应位置上的元素组成一个元组数组，要求两个序列长度相同
val a15 = Array(1, 2, 3, 4)
val b15 = Array(4, 3, 2, 1)
val c15 = a15.zip(b15)
println(c15.mkString(",")) // (1,4),(2,3),(3,2),(4,1)
//def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
//zipAll 同 zip ，但是允许两个序列长度不同，不足的自动填充，
// 如果当前序列短，不足的元素填充为 thisElem，
// 如果 that 序列短，填充为 thatElem
val a16 = Array(1, 2, 3, 4, 5, 6, 7)
val b16 = Array(5, 4, 3, 2, 1)
val c16 = a16.zipAll(b16, 8, 9) // (1,5),(2,4),(3,3),(4,2),(5,1),(6,9),(7,9)
println(c16.mkString(","))
val x16 = Array(1, 2, 3, 4)
val y16 = Array(6, 5, 4, 3, 2, 1)
val z16 = x16.zipAll(y16, 8, 9) // (1,6),(2,5),(3,4),(4,3),(8,2),(8,1)
println(z16.mkString(","))
println("------------------------------------------------------------")
//zipWithIndex 序列中的每个元素和它的索引组成一个元组数组
val a17 = Array('a', 'b', 'c', 'd')
val b17 = a17.zipWithIndex
println(b17.mkString(",")) // (a,0),(b,1),(c,2),(d,3)
}
}
533
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
