scala的高阶函数
1、函数和方法二则都是在定义逻辑
方法
def sum_m(a:Int,b:Int):int=a+b
函数
val sum_f:(Int,Int)=>Int=(x,y)=>x+y
函数和方法可以互换
方法可以转为函数：
val f1=sum_m
函数可以转为方法：
def m1=sum_m
2、高阶函数的定义
(方法|函数)f可以作为（方法|函数）ff的参数，也可以作为（方法|函数）ff的返回值
方法和函数就是执行逻辑
高阶函数的通俗解释
1、可以把一段逻辑当做参数，传递给另一段处理逻辑
2、也可以让某一段处理逻辑的返回值，就是一个函数
方法可以作为方法的参数
函数可以作为方法的参数
方法可以作为函数的参数
函数可以作为函数的参数
方法可以作为方法的返回值
函数可以作为方法的返回值
方法可以作为函数的返回值
函数可以作为函数的返回值
object Basics_Day01 {
def main(args: Array[String]): Unit = {
//调用m1方法传入f1函数
val a= m1(f1)
println(a)
//调用m1方法传入f2函数
val a1=m1(f2)
println(a1)
//调用m2方法传入f1函数
val b= m2(f1,2,4)
println(b)
//调用m2方法传入f2函数
val b1=m2(f2,3,4)
println(b1)
//调用m2方法传入m3函数
println(m2(m3,2,4))
}
/**定一个方法
* 方法的参数是个函数，函数的参数是两个int类型
* 返回值为int类型
*/
def m1(f:(Int,Int)=>Int):Int=f(1,2)
//定义一个计算数据可变的函数
def m2(f:(Int,Int)=>Int,x:Int,y:Int):Int=f(x,y)
//定义一个需要两个Int类型参数的方法
def m3(a:Int,b:Int):Int=a+b
//定义一个函数，参数类型是两个int类型，返回值是一个int类型
val f1=(x:Int,y:Int)=>x+y
val f2=(a:Int,b:Int)=>a*b
}
数组
定长数组
package com.liu.meng.day13
/**
* scala的数组的学习
* 定长定长数组和可变数组
* 定长数组Arrray
* 定长数组没有add，inster，remove操作只能修改某个位置的元素的值，要实现删除
* 可以通过过滤生成新的 Array 的方式来删除不要的元素
* 可变数组ArrayBuffer
* 可变数组可以进行增加，删除等操作
*
* 定长数组和可变数组之间的转换 通过调用toBuffer（）和toArray()来实现
*
*/
object ArrayClass {
def main(args: Array[String]): Unit = {
//初始化一个数组
val arr=Array(1,2,3,4,5,6,7,8)
//增强for循环
for (i<-arr){
println(i)
}
println("=============================")
//使用to可以生成一个序列作为脚标
for (i<-(0 to arr.length-1)){
println(arr(i))
}
println("=============================")
for (i<-(0 until arr.length)){
println(arr(i))
}
println("=============================")
//步长为2
for (i<-0 until (arr.length,2)){
println(arr(i))
}
println("=============================")
//反转
for (i<-(0 until arr.length).reverse){
println(arr(i))
}
println("=============================")
//数组转换将偶数取出乘以10以后在生成一个新数组
val res=for (e<-arr if e%2==0)yield e * 10
println(res.toBuffer)
println("===============")
//更高级写法，filter 是过滤，接收一个返回值为boolean的函数
//map相当于将数组中的每一个元素取出来，应用传进去的函数
val r=arr.filter(_%2==0).map(_*10)
println(r.toBuffer)
//数组中的常用算法
//求和
println(arr.sum)
//最大值
println(arr.max)
//最小值
println(arr.min)
//返回带有集合元素信息的集合名称
println(arr.toString)
//数组转为字符串
println(arr.mkString())
//数组转为字符串指定分隔符
println(arr.mkString(“,”))
//数组转为字符串指定分隔符和前后标记
println(arr.mkString(“<”,“,”,“>”))
}
}
集合
不可变集合
package com.liu.meng.day13
/**
* scala集合简单操作
* scala集合有三大类序列Seq，集合Set，映射Map所有集合都扩展自iterable特质
* scala集合有可变（mutable）和不可变（immutable）两种类型
*
*
*/
object AggregateClass {
def main(args: Array[String]): Unit = {
/**List序列
*在scala中列表要么为空（NIl表示空列表）要么是一个head元素加上一个tail列表
*9::List(5,2) ::操作符是将给定的头和尾创建一个新的列表
*注意 ::操作符是右结合的，例如9::5::2::NIL相当于9::(5::(2::Nil))
*/
//创建集合
val list1=List(1,2,3)
val list2=0::list1
val list3=list1.::(0)
val list4=0+:list1
val list5=list1.+:(0)
val list6=list1:+3
val ls0=List(4,5,6)
//集合合并
val ls2=ls0++list1
//将list1插入到ls0前
val ls3=ls0++:list1
//将list1插入到ls0前
val ls4=list1.:::(ls0)
println(ls4)
//取列表最后一个元素
println(list1.last)
//取除了最后一个元素以外的元素
println(list1.init)
//反转
println(list1.reverse)
//截取前n个元素
println(list1.take(2))
//丢弃前n个元素
println(list1.drop(1))
//分割成2列表有第一个列表有n个元素
println(ls4.splitAt(4))
//输出
println(list1.toString())
//转为String
println(list1.mkString)
//转为数组
println(list1.toArray.toBuffer)
}
}
可变列表
package com.liu.meng.day13
import scala.collection.mutable.ListBuffer
/**
* 可变列表List
*/
object ArregateClass1 {
def main(args: Array[String]): Unit = {
//创建可变列表
val list0=ListBuffer[Int](1,2,3)
//创建空的可变列表
val list1=new ListBuffer[Int]
//向集合中追加元素和、未生成新的集合
list1+=4
list1.append(5)
//将list1中的元素追加到list0中，未生成新的集合
list0++=list1
//生成新集合
val list2=list0++list1
val list3=list1:+5
}
}
Set集合
package com.liu.meng.day13
import scala.collection.immutable.HashSet
import scala.collection.mutable
/**
* set集合
*/
object AggregateSet extends App {
//不可变set
val set1=new HashSet[Int]()
//生成新的Set
val set2=set1+4
//set中的元素不能重复
val set3=set2++Set(5,6,7)
val set4=Set(1,3,4)++set1
println(set4)
//创建一个可变的 HashSetval
val set5 = new mutable.HashSet[Int]()
//向 HashSet 中添加元素
set5 += 2
//add 等价于+=
set5.add(4)
set5 ++= Set(1,3,5)
println(set1)
//删除一个元素
set5 -= 5
set5.remove(2)
println(set5)
}
MAP集合
package com.liu.meng.day13
import scala.collection.mutable
object MapClass extends App {
//创建Map
val map1=new mutable.HashMap[String,Int]()
//向map中添加数据
map1.put("aa",1)
map1("b")=2
map1+=(("c",1))
println(map1)
//移除数据
map1-="aa"
map1.remove("b")
println(map1)
//修改数据
map1("c")=100
println(map1)
}