C/C++教程
2021.12.11Scala函数A-N
本文主要是介绍2021.12.11Scala函数A-N，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
目录
++ ++： +： ：+ /: :\
ACFunctionTest
DEFFunctionTest
GHIFunctionTest
LMNFunctionTest
++ ++： +： ：+ /: :\
package test
object demo1 {
def main(args: Array[String]): Unit = {
val arr=Array(1,2,3,4)
val first=arr(0)
arr(3)=100
val newarr=arr.map(_ *2)
println(first)
println(newarr.mkString(","))
val a=List(1,2)
val b=scala.collection.mutable.LinkedList(3,4)
val c=a++:b
val d=b++:a
val e=a++b
val f=b++a
println(e)
println(f)
println(c)
println(d)
println(c.getClass().getName())
val g=List(1,2)
val h=0 +:g
println(h.mkString(","))
}
}
package test
object demo2 {
def main(args: Array[String]): Unit = {
val a=List(1,2,3,4)
val b=(10/:a)(_+_)
println(b)
val c=List(1,2,3,4)
val d=(c :\ 10)(_-_)
println(d)
}
}
ACFunctionTest
package test
import scala.collection.mutable.ArrayBuffer
object ACFunctionTest {
def main(args: Array[String]): Unit = {
//apply 获取指定索引处的元素
val a=List(1,10,100,100)
val b=a.apply(1)
println(b) //10
// val a1=List(1,2,3,4)
// val b1=new StringBuilder()
// a1.addString(b1)
// println(b1)
//
//
// val a2=List(1,2,3,4)
// val b2=new StringBuilder()
// a2.addString(b2,"-")
// println(b2)
//canEqual 判断两个对象是否可以进行比较
val a1=List(1,2,3,4)
val b1=Array('a','b','c')
println(a1.canEqual(b1)) //true
//charAt 获取 index 索引处的字符，这个方法会执行一个隐式的转换，
// 将 Array[T] 转换为 ArrayCharSequence，只有当 T 为 Char 类型时，这个转换才会发生
val chars = Array('a', 'b', 'c')
println(chars.charAt(0)) // a
//clone 创建一个副本
val a2 = Array(1, 2, 3, 4)
val b2 = a2.clone()
println(b2.mkString(",")) // 1,2,3,4
//collect 偏函数 通过执行一个并行计算（偏函数），得到一个新的数组对象
val fun1: PartialFunction[Char, Char] = {
case 'a' => 'A'
case x => x
}
val a3 = Array('a', 'b', 'c')
val b3 = a3.collect(fun1)
println(b3.mkString(",")) // A,b,c
//collectFirst 查找第一符合偏函数定义的元素 执行偏函数计算
val fun2:PartialFunction[Any,Int]={
case x:Int=>x*100
}
val a4=Array(3,1,'a',"b")
val b4=a4.collectFirst(fun2)
println(b4) //Some(300)
// b = arr.collectFirst({ case x: Int => x * 100 })
//combinations combinations 表示组合，这个排列组合会选出所有包含字符不一样的组合，
// 但不考虑顺序，对于 “abc”、“cba”，视为相同组合，
// 参数 n 表示序列长度，就是几个字符为一组
val a5=Array("a","b","c","d")
val b5=a5.combinations(2)
b5.foreach(x=> println(x.mkString(","))) //foreach遍历
//a,b
//a,c
//a,d
//b,c
//b,d
//c,d
//contains 判断序列中是否包含指定对象
val a6=List(1,2,3,4)
println(a.contains(1)) //true
//containsSilce 判断当前序列中是否包含另一个序列
val a7=List(1,2,3,4)
val b6=List(3.2)
val b7=List(2,3)
println(a7.containsSlice(b6)) //false
println(a7.containsSlice(b7)) //true
//copyToArray(xs) 将当前数组元素复制到另一个数组中
val a8=Array(1,2,3)
val b8:Array[Int]=new Array(5)
println(b8.mkString(","))
a8.copyToArray(b8)
println(b8.mkString(","))
//0,0,0,0,0
//1,2,3,0,0
//copyToArray(xs, start) 将当前数组元素复制到另一个数组中，从 start 位置开始复制
val a9=Array(1,2,3)
val b9:Array[Int]=new Array(7)
a9.copyToArray(b9,3)
println(b9.mkString(","))
//0,0,0,1,2,3,0
//copyToArray(xs, start, len) 将当前数组元素复制到另一个数组中，从 start 位置开始复制，长度为 len
val a10=Array(1,2,3)
val b10:Array[Int]=new Array(10)
a10.copyToArray(b10,1,2)
println(b10.mkString(",")) //0,1,2,0,0,0,0,0,0,0
//copyToBuffer 将数组中的元素复制到 Buffer 中
val a11 = Array(1, 2, 3, 4)
val b11: ArrayBuffer[Int]=ArrayBuffer()
a11.copyToBuffer(b11)
println(b11.mkString(",")) // 1,2,3,4
// corresponds 判断两个序列的长度以及对应位置元素是否符合某个条件。
// 如果两个序列具有相同的元素数量并且 p(x, y)=true，则返回 true
val a12=Array(1,2,3,4)
val b12=Array(5,6,7,8)
println(a12.corresponds(b12)(_ < _)) //true
// count 统计符合条件的元素个数
val a13=Array(1,2,3,4)
println(a13.count(x => x > 2)) //2
}
}
package test
object TestAggregate {
def main(args: Array[String]): Unit = {
}
val a=Array(7,8,9,10,11,12,13)
println(a.par.aggregate((10, 0))(
(x, y) => {
println("seqop",x,y)
if (y > x._1)
{
(x._1, x._2 + 1)
}
else
{
x
}
},
(x, y) => {
println("combop",x,y)
(x._1, x._2 + y._2)
}
))
println("----------------------------------")
println(a.par.aggregate(0)(
(x, y) => {
println("seqop",x, y)
if (x > y) {
x
}
else {
y
}
},
(x, y) => {
println("combop",x, y)
x + y
}
))
println("---------------------------------")
println(a.aggregate((10, 0))(
(x, y) => {
if (y > x._1)
{
(x._1, x._2 + 1)
}
else
{
x
}
},
(x, y) => {
(x._1, x._2 + y._2)
}
))
}
DEFFunctionTest
package test
object DEFFunctionTest {
def main(args: Array[String]): Unit = {
//diff 计算当前数组与另一个数组的差集，即将当前数组中没有在另一个数组中出现的元素返回
val a=Array(1,2,3,4)
val b=Array(3,4,5,6)
val c=a.diff(b)
println(c.mkString(","))
//distinct 去除当前集合中重复的元素，只保留一个
val a1=Array(1,2,3,4,4,3)
val b1=a1.distinct
println(b1.mkString(","))
//drop 将当前数组中前 n 个元素去除，返回一个新数组
val a2=Array(1,2,3,4)
val b2=a2.drop(2)
println(b2.mkString(","))
//dropRight 功能同 drop，去掉尾部的 n 个元素
val a3=Array(1,2,3,4)
val b3=a3.dropRight(2)
println(b3.mkString(","))
//dropWhile 去除当前数组中符合条件的元素，返回剩余的数组，
// 这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，
// 直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组
//下面去除数组 a 中大于 2 的元素，第一个元素 3 满足，它后面的元素 2 不满足，所以返回 (2,3,4)
val a4 = Array(1, 2, 3, 4)
val b4= a4.dropWhile(x => x < 2)
println(b4.mkString(",")) // 2,3,4
val a5 = Array(1, 2, 3, 4)
val b5 = a5.dropWhile(x => x > 2)
println(b5.mkString(",")) // 1,2,3,4
//endsWith 判断当前序列是否以某个序列结尾
val a6=Array(1,2,3,4)
val b6=Array(3,4)
println(a6.endsWith(b6)) //true
//exists 判断当前数组是否包含符合条件的元素
val a7=Array(1,2,3,4)
println(a7.exists(x => x == 3)) //true
println(a7.exists(x => x > 10)) //false
//filter 取得当前数组中符合条件的元素，组成新的数组返回
val a8=Array(1,2,3,4)
val b8=a8.filter(x=>x>2)
// val b8=a8.filterNot()
println(b8.mkString(",")) //3,4
//find 查找第一个符合条件的元素，返回 Option
val a9=Array(1,2,3,4)
val b9=a9.find(x=>x>2)
println(b9) //Some(3)
//flatMap 对当前序列的每个元素进行操作，结果放入新序列返回，
// 参数要求是 GenTraversableOnce 及其子类
val a10=Array(1,2,3,4)
val b10=a10.flatMap(x=> 1 to x)
println(b10.mkString(",")) //1,1,2,1,2,3,1,2,3,4
/**
* 1,1,2,1,2,3,1,2,3,4
* 从 1 开始，分别对集合 a 中的每个元素生成一个递增序列，过程如下
* 1
* 1,2
* 1,2,3
* 1,2,3,4
*/
//flatten 扁平化，将二维数组的所有元素组合在一起，形成一个一维数组返回
val a11=Array(Array(1,2,3),Array(4,5,7))
val b11=a11.flatten
println(b11.mkString(","))
//forall 检测序列中的元素是否都满足条件 p，如果序列为空，则返回 true
val a12=Array(1,2,3,4)
println(a12.forall(x => x > 0)) //true
println(a12.forall(x => x > 2)) //false
//foreach 遍历序列中的元素，进行 f 操作
// def foreach(f: (A) ⇒ Unit): Unit
val a13=Array(1,2,3,4,6)
a13.foreach(x=>println(x*10))
/**
* 10
* 20
* 30
* 40
*/
}
}
package test
object FoldLeftTest {
//foldLeft 从左到右计算，简写方式：def /:[B](z: B)(op: (B, T) ⇒ B): B
def seqno(m: Int, n: Int): Int = {
val s = "seq_exp = %d + %d"
println(s.format(m, n))
m + n
}
def main(args: Array[String]): Unit = {
val a = Array(1, 2, 3, 4)
val b = a.foldLeft(5)(seqno) // 简写: (5 /: a)(_ + _)
println("b = " + b)
/**
* seq_exp = 5 + 1
* seq_exp = 6 + 2
* seq_exp = 8 + 3
* seq_exp = 11 + 4
* b = 15
*/
}
}
package test
object FoldRightTest {
def seqno(m: Int, n: Int): Int = {
val s = "seq_exp = %d + %d"
println(s.format(m, n))
m + n
}
def main(args: Array[String]): Unit = {
val a = Array(1, 2, 3, 4)
val b = a.foldRight(5)(seqno) // 简写: (a :\ 5)(_ + _)
println("b = " + b)
/**
* seq_exp = 4 + 5
* seq_exp = 3 + 9
* seq_exp = 2 + 12
* seq_exp = 1 + 14
* b = 15
*/
}
}
package test
object FoldTest {
//fold 对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同
def seqno(m:Int,n:Int):Int={
val s="seq_exp=%d+%d"
println(s.format(m, n))
m+n
}
def main(args: Array[String]): Unit = {
val a12=Array(1,2,3,4)
val b12=a12.fold(5)(seqno) //不分区
println("b12="+b12)
/**
* seq_exp = 5 + 1
* seq_exp = 6 + 2
* seq_exp = 8 + 3
* seq_exp = 11 + 4
* b12 = 15
*/
val c12=a12.par.fold(5)(seqno) //分区
println("c12="+c12)
/**
* seq_exp=5+1
* seq_exp=5+2
* seq_exp=6+7
* seq_exp=5+3
* seq_exp=8+4
* seq_exp=13+12
* c12=25
*/
}
}
GHIFunctionTest
package test
object GHIFunctionTest {
def main(args: Array[String]): Unit = {
// def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]
//groupBy 按条件分组，条件由 f 匹配，返回值是 Map 类型，每个 key 对应一个数组
//把数组中小于 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"
})
b.foreach(x => println(x._1 + ": " + x._2.mkString(",")))
/**
* small: 1,2
* big: 3,4
*/
val a1=Array(59,60,100,96,87,102)
val b1=a1.groupBy(s=>s match{
case s if (s<60)=>"不及格"
case s if (s<90)=>"优秀"
case s if (s<=100)=>"完美"
case _=>"其他"
})
b1.foreach(s => println(s._1 + ": " + s._2.mkString(",")))
/**
* 其他: 102
* 完美: 100,96
* 优秀: 60,87
* 不及格: 59
*/
//grouped 按指定数量分组，每组有 size 个元素，返回一个迭代器
val a2=Array(1,2,3,4,5)
val b2=a2.grouped(2).toList
b2.foreach(x => println("第 " + (b2.indexOf(x) + 1) + " 组: " + x.mkString(",")))
/**
* 第 1 组: 1,2
* 第 2 组: 3,4
* 第 3 组: 5
*/
//hasDefiniteSize 检测序列是否存在有限的长度，对应 Stream 这样的流数据则返回 false
val a3 = Array(1, 2, 3, 4)
println(a3.hasDefiniteSize) // true
//head 返回序列的第一个元素，如果序列为空，将引发错误
val a4 = Array(1, 2, 3, 4)
println(a4.head) // 1
//headOption 返回序列的第一个元素的 Option 类型对象，如果序列为空，则返回 None
val a5 = Array(1, 2, 3, 4)
println(a5.headOption) // Some(1)
//indexOf(elem) 返回元素 elem 在序列中第一次出现的索引
val a6 = Array(1, 3, 2, 3, 4)
println(a6.indexOf(3)) // 1
//indexOf(elem, from) 返回元素 elem 在序列中第一次出现的索引，指定从索引 from 开始查找
val a7 = Array(1, 3, 2, 3, 4)
println(a7.indexOf(3, 2)) // 3
//indexOfSlice(that) 检测当前序列中是否包含序列 that，并返回第一次出现该序列的索引
val a8 = Array(1,7,8,2, 3, 2, 3, 4)
val b8 = Array(2, 3)
println(a8.indexOfSlice(b8)) // 3
//indexOfSlice(that, from) 检测当前序列中是否包含另一个序列 that
// 指定从索引 from 开始查找，并返回第一次出现该序列的索引
val a9 = Array(1, 2, 3, 2, 3, 4)
val b9 = Array(2, 3)
println(a9.indexOfSlice(b9, 2)) // 3
//indexWhere(p) 返回当前序列中第一个满足条件 p 的元素的索引
val a10 = Array(1, 2, 3, 4)
println(a10.indexWhere(x => x > 2)) // 2
//indexWhere(p, from) 返回当前序列中第一个满足条件 p 的元素的索引，指定从索引 from 开始查找
val a11 = Array(1, 2, 3, 4)
println(a11.indexWhere(x => x > 2, 3)) // 3
//indices 返回当前序列索引集合
val a12 = Array(1, 2, 3, 4)
val b12 = a12.indices
println(b12.mkString(",")) // 0,1,2,3
//init 返回当前序列中不包含最后一个元素的序列
val a13 = Array(1, 2, 3, 4)
val b13 = a13.init
println(b13.mkString(",")) // 1,2,3
//inits 对集合中的元素进行 init 迭代操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，
// 每一步都进行 init 操作，上一步的结果作为下一步的操作对象
val a14 = Array(1, 2, 3, 4)
val b14 = a14.inits.toList
for (i <- 0 until b14.length) {
val s = "第 %d 个值: %s"
println(s.format(i + 1, b14(i).mkString(",")))
}
/**
* 第 1 个值: 1,2,3,4
* 第 2 个值: 1,2,3
* 第 3 个值: 1,2
* 第 4 个值: 1
* 第 5 个值:
*/
//intersect 取两个集合的交集
val a15 = Array(1, 2, 3, 4)
val b15 = Array(3, 4, 5, 6)
val c15 = a15.intersect(b15)
println(c15.mkString(",")) // 3,4
//isDefinedAt 判断序列中是否存在指定索引
val a16=Array(1,2,3,4)
println(a16.isDefinedAt(1)) //true
println(a16.isDefinedAt(5)) //false
//isEmpty 判断序列是否为空
val a17=Array(1,2,3,4)
val b17=new Array[Int](0)
println(a17.isEmpty) //false
println(b17.isEmpty) //true
println("-------------------------------------------------")
//isTraversableAgain 判断序列是否可以反复遍历，该方法是 GenTraversableOnce 中的方法，
// 对于 Traversables 一般返回 true，对于 Iterators 返回 false，除非被复写
val a18 = Array(1, 2, 3, 4)
val b18 = a18.iterator
println(a18.isTraversableAgain) // true
println(b18.isTraversableAgain) // false
}
}
LMNFunctionTest
package test
object LMNFunctionTest {
def main(args: Array[String]): Unit = {
//last 返回序列的最后一个元素，如果序列为空，将引发错误
val a = Array(1, 2, 3, 4)
println(a.last) // 4
//lastIndexOf(elem) 返回元素 elem 在序列中最后一次出现的索引
val a1 = Array(1, 3, 2, 3, 4)
println(a1.lastIndexOf(3)) // 3
//lastIndexOf(elem, end) 返回元素 elem 在序列中最后一次出现的索引，
// 指定在索引 end 之前（包括）的元素中查找
val a2 = Array(1, 3, 2, 3, 4)
println(a2.lastIndexOf(3, 2)) // 1
//lastIndexOfSlice(that) 检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引
val a3 = Array(1, 2, 3, 2, 3, 4)
val b3 = Array(2, 3)
println(a3.lastIndexOfSlice(b3)) // 3
//lastIndexOfSlice(that, end) 检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引，
// 指定在索引 end 之前（包括）的元素中查找
val a4 = Array(1, 2, 3, 2, 3, 4)
val b4 = Array(2,3)
println(a4.lastIndexOfSlice(b4, 2)) // 1
//lastIndexWhere(p) 返回当前序列中最后一个满足条件 p 的元素的索引
val a5=Array(1,2,3,4,1,8)
println(a5.lastIndexWhere(_>2)) //5
//lastIndexWhere(p, end) 返回当前序列中最后一个满足条件 p 的元素的索引，
// 指定在索引 end 之前（包括）的元素中查找
val a6 = Array(1, 2, 3, 4)
println(a6.lastIndexWhere(x => x > 2, 2)) // 2
//lastOption 返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None
val a7 = Array(1, 2, 3, 4)
println(a7.lastOption) // Some(4)
//length 返回序列元素个数
val a8 = Array(1, 2, 3, 4)
println(a8.length) // 4
//lengthCompare 比较序列的长度和参数 len，返回序列的长度 - len
//def lengthCompare(len: Int): Int
val a9 = Array(1, 2, 3, 4)
println(a9.lengthCompare(3)) // 1
println(a9.lengthCompare(4)) // 0
println(a9.lengthCompare(5)) // -1
//map def map[B](f: (A) ⇒ B): Array[B] 对序列中的元素进行 f 操作，返回生成的新序列
val a10 = Array(1, 2, 3, 4)
val b10 = a10.map(x => x * 10)
println(b10.mkString(",")) // 10,20,30,40
//max 返回序列中最大的元素
val a11 = Array(1, 2, 3, 4)
println(a11.max) // 4
//maxBy 返回序列中符合条件的第一个元素
val a12 = Array(1, 2, 3, 4)
println(a12.maxBy(x => x > 2)) // 3
//min 返回序列中最小的元素
val a13 = Array(1, 2, 3, 4)
println(a13.min) // 1
//minBy 返回序列中不符合条件的第一个元素
val a14 = Array(1, 2, 3, 4)
println(a14.minBy(x => x < 2)) // 2
//mkString 将序列中所有元素拼接成一个字符串
val a15 = Array(1, 2, 3, 4)
println(a15.mkString) // 1234
//mkString(sep) 将序列中所有元素拼接成一个字符串，以 sep 作为元素间的分隔符
val a16 = Array(1, 2, 3, 4)
println(a16.mkString(",")) // 1,2,3,4
//mkString(start, sep, end) 将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾
val a17 = Array(1, 2, 3, 4)
println(a17.mkString("(", ",", ")")) // (1,2,3,4)
//nonEmpty 判断序列是否不为空
val a18 = Array(1, 2, 3, 4)
val b18 = new Array[Int](0)
println(a18.nonEmpty) // true
println(b18.nonEmpty) // false
}
}
这篇关于2021.12.11Scala函数A-N的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
Excel中实现拖动排序的简单教程11-27
-
Rocket消息队列资料：新手入门指南11-27
-
rocket消息队资料详解与入门指南11-27
-
RocketMQ底层原理资料详解入门教程11-27
-
RocketMQ项目开发资料：新手入门教程11-27
-
RocketMQ项目开发资料详解11-27
-
RocketMQ消息中间件资料入门教程11-27
-
初学者指南：深入了解RocketMQ源码资料11-27
-
Rocket消息队列学习入门指南11-27
-
Rocket消息中间件教程：新手入门详解11-26
-
RocketMQ项目开发教程：新手入门指南11-26
-
MQ源码教程：轻松入门Apache MQ源码解析11-26
-
Rocket消息队列教程：新手入门必读11-26
-
Rocket消息队列教程：新手入门指南11-26
-
RocketMQ底层原理教程：新手入门指南11-26
栏目导航
