一门多范式的编程语言Scala学习的第二天-函数的使用
2.12 scala中的函数式编程
* scala中的函数式编程
*
* 面向对象编程：将对象当作参数一样传来传去
* 1、对象可以当作方法参数传递
* 2、对象也可以当作方法的返回值返回
* 当看到类，抽象类，接口的时候，今后无论是参数类型还是返回值类型，都需要提供对应的实现类对象
*
* 面向函数式编程：将函数当作参数一样传来传去
* 1、函数A当作函数B的参数进行传递
* 2、函数A当作函数B的返回值返回
*
* 在scala中，将函数也当作一个对象，对象就有类型
* 函数在scala也有类型的说法
* 参数类型=>返回值类型
object Demo10fun {
def main(args: Array[String]): Unit = {
//是一个参数是字符串类型，返回值是整数类型的函数
def fun1(a1:String):Int={
a1.toInt
}
val res1: Int = fun1("1000")
println(res1)
//定义变量的方式，定义一个函数
//将函数当作对象，赋值给类型是函数类型的变量，将来可以直接通过变量调用函数
val fun2:String=>Int=fun1
val res2: Int = fun2("2000")
println(res2)
/**
* 函数A作为函数B的参数定义
*
* 本质上是将函数A的处理逻辑主体传给了函数B，在函数B中使用这个处理逻辑
*/
//f:String=>Int 相当于函数A
//fun3相当于函数B
def fun3(f:String=>Int):Int={
val a1:Int=f("100")
a1+100
}
def show1(a1:String):Int=a1.toInt
val res4: Int = fun3(show1)
println(res4)
def show2(a1: String): Int = a1.toInt+100
val res5: Int = fun3(show2)
println(res5)
//定义一个函数fun1, 函数的参数列表中，既有正常的类型参数，也有函数类型的参数
def fun4(s:String,f:String=>Int): Int = {
val b1:Int=f(s)
b1+111
}
def show3(a1: String): Int = a1.toInt + 100
val res6: Int = fun4("1000",show3)
println(res6)
//使用lambda表达式改写函数作为参数传递的调用形式
fun4("100",(s:String)=>s.toInt)
fun4("100",(s:String)=>s.toInt+100)
//在Scala中数据类型可以自动推断
val res7: Int = fun4("1000", s => s.toInt + 100)
println(res7)
////如果当作参数的函数的参数只在函数主体使用了一次，那么可以使用_代替
fun4("100",_.toInt+100)
}
}
1、函数当作参数传递的应用
object Demo11fun {
def main(args: Array[String]): Unit = {
val arr1: Array[Int] = Array(11, 22, 33, 44, 55)
def fun1(i:Int): Unit = {
println(i*2)
}
//def foreach[U](f: A => U): Unit
//foreach函数需要一个参数和数组元素一样类型的类型，返回值是Unit的函数
//foreach函数的主要作用是将调用该方法的序列中的元素，依次取出传递给后面的函数进行处理
arr1.foreach(fun1)
// scala自带的一个函数
// def println(x: Any) = Console.println(x)
// Any可以接收任意的数据类型元素
arr1.foreach(println)
}
}
2、函数当作返回值返回
object Demo12fun {
def main(args: Array[String]): Unit = {
/**
* fun1: 参数是String类型，返回值是一个函数（参数是String类型，返回值是Int）
*/
//定义返回值是函数的函数方式1:
def fun1(s1:String):String=>Int={
def fun2(s2:String):Int={
s2.toInt+s1.toInt
}
fun2
}
//调用函数的返回值是函数的方式1
val res1: String => Int = fun1("100")
val res2: Int = res1("100")
println(res2)
//定义方式2(是方式1的简化写法):
def fun2(s1:String)(s2:String):Int={
s1.toInt+s2.toInt
}
val res3: Int = fun2("1")("100")
println(res3)
//一般这么用方式二
val resfun: String => Int = fun2("10")
val res4: Int = resfun("11")
println(res4)
val res5: Int = resfun("22")
println(res5)
val res6: Int = resfun("33")
println(res6)
//另一种写法
def fun3(s1:String,s2:String):Int={
s1.toInt+s2.toInt
}
val res7: Int = fun3("100", "10")
println(res7)
/**
* 使用下划线进行占位，那么Scala会自动根据参数类型和返回值类型，创建一个新的相符合的函数
* 偏函数
*/
val funn3: String => Int = fun3("100", _)
val res8: Int = funn3("100")
println(res8)
val res9: Int = funn3("1000")
println(res9)
}
}
2.13数组
//数组：在内存中一块连续固定大小的空间，有索引可以检索数据，查询快，但是增删速度较慢
//创建一个数组
val arr1: Array[Int] = Array(11, 22, 33, 44, 55)
println(arr1(0))
println(arr1(1))
println(arr1(2))
println(arr1(3))
println(arr1(4))
3、Scala中的”_"的用法总结
在Scala中的大部分情况下，表示所有或者默认值或者占位符的时候，都使用下划线
1、导包时
- 多引用的方法，和Java中的*类似，相当于该类下面的任意子类
import scala.collection.mutable._
2、在访问元组时
- 和值在一起使用则表示第几个元素
val/var 元组名 = (元素1, 元素2, 元素3....)
//获取第一个元素
元组名._1
//获取第二个元素
元组名._2
3、根据定义的变量的类型的初始值进行的占位符
var gender:String = _
4、使用下划线来简化函数的定义
-
当函数的参数在函数体中只出现一次，而且函数体没有嵌套调用时，可以使用下划线来简化函数的定义
def main(args: Array[String]): Unit = {
val a = List(1,2,3,4,5)
// a.foreach(x=>println(x))
a.foreach(println(_))
}
5、用于元素匹配，匹配每一个元素
List(1,2,3,4,5,6,7,8,9).filter(_ % 2 == 0)
6、用于替换函数中的参数
-
函数参数在函数中只出现一次，则可以使用下划线代替
/**
* 偏函数
*/
val f1: String => Int = function1("1", _)
val res1: Int = f1("1000")
val res2: Int = f1("2000")
val res3: Int = f1("3000")
println(s"res1:$res1,res2:$res2,res3:$res3")
7、用于模式匹配中的默认匹配项
case表达式中的无需使用到的匹配到的变量，可以用下划线代替
变量 match {
case "常量1" => 表达式1
case "常量2" => 表达式2
case "常量3" => 表达式3
case _ => 表达式4 // 默认匹配项
}
str match {
case "hadoop" => println("大数据分布式存储和计算框架")
case "zookeeper" => println("大数据分布式协调服务框架")
case "spark" => println("大数据分布式内存计算框架")
case _ => println("未匹配")
}
在case校验时，变量没有被使用，也可以用下划线替代
-
下面是Scala中处理异常的时间的使用
/**
* 也可以手动的抛出异常
*/
val sc = new Scanner(System.in)
print("输入除数：")
val cs: Int = sc.nextInt()
if(cs!=0){
println(10/cs)
}else{
throw new ArithmeticException("您输入的除数是0")
}
}catch{
//类似于sql语句中case when
case e:ArithmeticException=>
// println("除0异常")
e.printStackTrace()
case e:ArrayIndexOutOfBoundsException=>
println("数组越界异常")
case _ =>
println("出现异常")
}finally {
//今后finally中的处理大部分情况下都与释放资源有关
println("这是finally代码块")
}
8、在定义变量时
- 在定义变量时，使用下划线占位，就表示将来会赋予该变量默认值
/**
* 定义成员变量
*/
val _name: String = name
val _age: Int = age
var _gender: String = _ // 这个下划线，就表示将来会赋予默认值
4、Scala中的集合
List: 元素有序，且可以发生重复，长度是固定的
Set：元素无序，且唯一，长度固定的
Map：元素是以键值对的形式，键是唯一的
Tuple：元组，长度是固定的，每一个元素的数据类型可以是不一样的
4.1ArrayList
object Demo13ArrayList {
def main(args: Array[String]): Unit = {
val list1: util.ArrayList[Int] = new util.ArrayList[Int]
list1.add(11)
list1.add(123)
list1.add(22)
list1.add(31)
list1.add(17)
println(list1)
var i=0
while (i<list1.size()){
val res1: Int = list1.get(i)
println(res1)
i+=1
}
}
}
4.2 List
- List中的基础用法，和Java中的集合用法一致
//创建一个scala中的List集合
//创建了一个空集合
// val list1: List[Nothing] = List()
val list2: List[Int] = List(34, 11, 22, 11, 33, 44, 55, 22, 75, 987, 1, 12, 34, 66, 77)
println(list2)
//获取List集合的长度
println(list2.size)
println(list2.length)
println("=" * 50)
//可以直接通过索引下标获取元素
println(list2(0))
println(list2(1))
println(list2(2))
println("=" * 50)
//scala推荐获取第一个元素的方式是调用head函数
println(list2.head)
println(list2.last)
//根据指定的分隔符拼接元素
println(list2.mkString("|"))
println("=" * 50)
val resList1: List[Int] = list2.reverse //返回一个新的集合
println(s"list2:$list2")
println(s"resList1:$resList1")
println("=" * 50)
//对集合中元素进行去重
val resList2: List[Int] = list2.distinct //返回一个新的集合
println(s"list2:$list2")
println(s"resList2:$resList2")
println("=" * 50)
val resList3: List[Int] = list2.tail // 除去第一个，其余的元素返回一个新的集合
println(s"list2:$list2")
println(s"resList3:$resList3")
println("=" * 50)
val resList4: List[Int] = list2.take(5) // 从左向右取元素，取若干个
println(s"list2:$list2")
println(s"resList4:$resList4")
println("=" * 50)
val resList5: List[Int] = list2.takeRight(5) //取右边的几个，组成新的集合
println(s"list2:$list2")
println(s"resList5:$resList5")
println("=" * 50)
//从第一个判断取数据，直到不符合条件停止
val resList10: List[Int] = list2.takeWhile((e: Int) => e % 2 == 0)
println(s"list2:$list2")
println(s"resList10:$resList10")
println("***********************************" * 50)
val res1: Int = list2.sum // 元素必须是数值
println(s"集合中的元素和为：$res1")
println("=" * 50)
val res2: Int = list2.max
println(s"集合中的元素最大值为：$res2")
println("=" * 50)
//集合的遍历
for (e <- list2) {
println(e)
}
println("=" * 50)
- Scala中的List高阶函数用法
/**
* 高阶函数:
* foreach: 将集合中的元素依次取出传入到后面的函数中
* 注意：没有返回值的，要么就输出，要么就其他方式处理掉了
*/
//def foreach[U](f: A => U)
// list2.foreach((e: Int) => println(e))
// list2.foreach(println)
//需求1：使用foreach求出集合中偶数的和
var ouSum = 0
var jiSum = 0
list2.foreach((e: Int) => {
if (e % 2 == 0) {
ouSum += e
} else {
jiSum += e
}
})
println(s"集合中偶数之和为：$ouSum")
println(s"集合中奇数之和为：$jiSum")
println("=" * 50)
/**
* 高阶函数:
* map: 依次处理每一个元素，得到一个新的结果，返回到一个新的集合中
*/
val list3: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
//需求2：将集合中的每一个元素*2
val resList6: List[Int] = list3.map((e: Int) => e * 2)
println(s"list3:$list3")
println(s"resList6:$resList6")
/**
* 高阶函数:
* filter: 保留符合条件的元素
*/
println("=" * 50)
val list4: List[Int] = List(4, 7, 9, 10, 12, 11, 14, 9, 7)
val resList7: List[Int] = list4.filter((e: Int) => e % 2 == 0)
println(s"list4:$list4")
println(s"resList7:$resList7")
/**
* 高阶函数:
* sortBy: 排序
* sortWith: 两个数之间的关系排序
*/
println("=" * 50)
val resList8: List[Int] = list4.sortBy((e: Int) => -e)
println(s"list4:$list4")
println(s"resList8:$resList8")
val resList9: List[Int] = list4.sortWith((x: Int, y: Int) => x > y)
println(s"list4:$list4")
println(s"resList9:$resList9")
/**
* 高阶函数:
* flatMap: 扁平化
*/
println("=" * 50)
val list5: List[String] = List("hello|world|java", "hello|hadoop|flink", "scala|spark|hadoop")
val resTmp1: List[String] = list5.flatMap((e: String) => e.split("\\|"))
resTmp1.foreach(println)
/**
* 高阶函数:
* groupBy: 分组
*/
val list6: List[String] = List("hello", "world", "java", "hadoop", "flink", "java", "hadoop", "flink", "flink", "java", "hadoop", "flink", "java", "hadoop", "hello", "world", "java", "hadoop", "hello", "world", "java", "hadoop")
val map: Map[String, List[String]] = list6.groupBy((e: String) => e)
for (e <- map) {
println(e)
}
/**
* 基本函数
*
* 高阶函数：
* foreach: 依次取出元素，进行后面函数逻辑，没有返回值
* map: 依次取出元素，进行后面函数逻辑，有返回值，返回新的集合
* filter: 所有数据中取出符合条件的元素
* sortBy/sortWith: 排序
* flatMap: 扁平化
* groupBy: 分组，结果是一个map集合
*/
4.3Set
set集合： scala中的Set集合也是不可变的，除了排序相关的函数以外，List集合有的高阶函数，Set集合也有
val set1: Set[Int] = Set(1, 4, 3, 6, 5)
val set2: Set[Int] = Set(3, 6, 5, 7, 8)
println(s"$set1")
println(s"$set2")
// val res1: Set[Int] = set1.&(set2)
//求交集
val res2: Set[Int] = set1 & set2
println(s"$res2")
//求并集
val res3: Set[Int] = set1.|(set2)
println(s"$res3")
//求差集
val res4: Set[Int] = set1.&~(set2)
println(s"$res4")
/**
* list集合和set集合可以相互转换
*/
val list1: List[Int] = List(11, 22, 33, 44, 55, 11, 22, 44, 88, 33, 44, 99, 11, 22, 55)
val set3: Set[Int] = list1.toSet
println(s"$set3")
val list2: List[Int] = set3.toList.sortBy((e: Int) => e)
println(s"$list2")
