scala的高階函數(shù)
1、函數(shù)和方法二則都是在定義邏輯
方法
def sum_m(a:Int,b:Int):int=a+b
函數(shù)
val sum_f:(Int,Int)=>Int=(x,y)=>x+y
函數(shù)和方法可以互換
方法可以轉(zhuǎn)為函數(shù)：
val f1=sum_m
函數(shù)可以轉(zhuǎn)為方法：
def m1=sum_m
2望迎、高階函數(shù)的定義
(方法|函數(shù))f可以作為（方法|函數(shù)）ff的參數(shù)障癌，也可以作為（方法|函數(shù)）ff的返回值
方法和函數(shù)就是執(zhí)行邏輯
高階函數(shù)的通俗解釋
1、可以把一段邏輯當(dāng)做參數(shù)辩尊，傳遞給另一段處理邏輯
2涛浙、也可以讓某一段處理邏輯的返回值，就是一個(gè)函數(shù)
方法可以作為方法的參數(shù)
函數(shù)可以作為方法的參數(shù)
方法可以作為函數(shù)的參數(shù)
函數(shù)可以作為函數(shù)的參數(shù)
方法可以作為方法的返回值
函數(shù)可以作為方法的返回值
方法可以作為函數(shù)的返回值
函數(shù)可以作為函數(shù)的返回值
object Basics_Day01 {
? def main(args: Array[String]): Unit = {
//調(diào)用m1方法傳入f1函數(shù)
val? a= m1(f1)
println(a)
//調(diào)用m1方法傳入f2函數(shù)
val a1=m1(f2)
println(a1)
//調(diào)用m2方法傳入f1函數(shù)
val? b= m2(f1,2,4)
println(b)
//調(diào)用m2方法傳入f2函數(shù)
val b1=m2(f2,3,4)
println(b1)
//調(diào)用m2方法傳入m3函數(shù)
println(m2(m3,2,4))
}
? /**定一個(gè)方法
* 方法的參數(shù)是個(gè)函數(shù)摄欲，函數(shù)的參數(shù)是兩個(gè)int類型
* 返回值為int類型
*/
? def m1(f:(Int,Int)=>Int):Int=f(1,2)
? //定義一個(gè)計(jì)算數(shù)據(jù)可變的函數(shù)
? def m2(f:(Int,Int)=>Int,x:Int,y:Int):Int=f(x,y)
? //定義一個(gè)需要兩個(gè)Int類型參數(shù)的方法
? def m3(a:Int,b:Int):Int=a+b
? //定義一個(gè)函數(shù)轿亮，參數(shù)類型是兩個(gè)int類型，返回值是一個(gè)int類型
? val f1=(x:Int,y:Int)=>x+y
? val f2=(a:Int,b:Int)=>a*b
}
數(shù)組
定長數(shù)組
package com.liu.meng.day13
/**
? * scala的數(shù)組的學(xué)習(xí)
? * 定長定長數(shù)組和可變數(shù)組
? * 定長數(shù)組Arrray
? * 定長數(shù)組沒有add胸墙，inster我注，remove操作只能修改某個(gè)位置的元素的值，要實(shí)現(xiàn)刪除
? * 可以通過過濾生成新的 Array 的方式來刪除不要的元素
? * 可變數(shù)組ArrayBuffer
? * 可變數(shù)組可以進(jìn)行增加迟隅，刪除等操作
? *
? * 定長數(shù)組和可變數(shù)組之間的轉(zhuǎn)換 通過調(diào)用toBuffer（）和toArray()來實(shí)現(xiàn)
? *
? */
object ArrayClass {
? def main(args: Array[String]): Unit = {
//初始化一個(gè)數(shù)組
val arr=Array(1,2,3,4,5,6,7,8)
//增強(qiáng)for循環(huán)
for (i<-arr){
? println(i)
}
println("=============================")
//使用to可以生成一個(gè)序列作為腳標(biāo)
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("=============================")
//反轉(zhuǎn)
for (i<-(0 until arr.length).reverse){
? println(arr(i))
}
println("=============================")
? ? ? ? ? ? //數(shù)組轉(zhuǎn)換將偶數(shù)取出乘以10以后在生成一個(gè)新數(shù)組
val res=for (e<-arr if e%2==0)yield e * 10
println(res.toBuffer)
println("===============")
//更高級寫法但骨，filter 是過濾，接收一個(gè)返回值為boolean的函數(shù)
//map相當(dāng)于將數(shù)組中的每一個(gè)元素取出來智袭，應(yīng)用傳進(jìn)去的函數(shù)
val r=arr.filter(_%2==0).map(_*10)
println(r.toBuffer)
//數(shù)組中的常用算法
//求和
println(arr.sum)
//最大值
println(arr.max)
//最小值
println(arr.min)
//返回帶有集合元素信息的集合名稱
println(arr.toString)
//數(shù)組轉(zhuǎn)為字符串
println(arr.mkString())
//數(shù)組轉(zhuǎn)為字符串指定分隔符
println(arr.mkString(“,”))
//數(shù)組轉(zhuǎn)為字符串指定分隔符和前后標(biāo)記
println(arr.mkString(“<”,“,”,“>”))
? }
}
集合
不可變集合
? package com.liu.meng.day13
/**
? * scala集合簡單操作
? * scala集合有三大類序列Seq奔缠，集合Set，映射Map所有集合都擴(kuò)展自iterable特質(zhì)
? * scala集合有可變（mutable）和不可變（immutable）兩種類型
? *
? *
? */
object AggregateClass {
? def main(args: Array[String]): Unit = {
/**List序列
*在scala中列表要么為空（NIl表示空列表）要么是一個(gè)head元素加上一個(gè)tail列表
*9::List(5,2) ::操作符是將給定的頭和尾創(chuàng)建一個(gè)新的列表
*注意 ::操作符是右結(jié)合的补履，例如9::5::2::NIL相當(dāng)于9::(5::(2::Nil))
*/
? //創(chuàng)建集合
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)
//取列表最后一個(gè)元素
println(list1.last)
//取除了最后一個(gè)元素以外的元素
println(list1.init)
//反轉(zhuǎn)
println(list1.reverse)
//截取前n個(gè)元素
println(list1.take(2))
//丟棄前n個(gè)元素
println(list1.drop(1))
//分割成2列表有第一個(gè)列表有n個(gè)元素
println(ls4.splitAt(4))
? //輸出
println(list1.toString())
//轉(zhuǎn)為String
println(list1.mkString)
//轉(zhuǎn)為數(shù)組
println(list1.toArray.toBuffer)
? }
}
可變列表
? ? ? ? package com.liu.meng.day13
import scala.collection.mutable.ListBuffer
/**
? * 可變列表List
? */
object ArregateClass1 {
? def main(args: Array[String]): Unit = {
//創(chuàng)建可變列表
val list0=ListBuffer[Int](1,2,3)
//創(chuàng)建空的可變列表
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中的元素不能重復(fù)
val set3=set2++Set(5,6,7)
val set4=Set(1,3,4)++set1
println(set4)
? //創(chuàng)建一個(gè)可變的 HashSetval
? val? set5 = new mutable.HashSet[Int]()
? //向 HashSet 中添加元素
? set5 += 2
? //add 等價(jià)于+=
? set5.add(4)
? set5 ++= Set(1,3,5)
? println(set1)
? //刪除一個(gè)元素
? set5 -= 5
? set5.remove(2)
? println(set5)
}
MAP集合
package com.liu.meng.day13
import scala.collection.mutable
object MapClass? extends? App {
? //創(chuàng)建Map
val map1=new mutable.HashMap[String,Int]()
? //向map中添加數(shù)據(jù)
? map1.put("aa",1)
? map1("b")=2
? map1+=(("c",1))
? println(map1)
? //移除數(shù)據(jù)
? map1-="aa"
? map1.remove("b")
? println(map1)
? //修改數(shù)據(jù)
? map1("c")=100
? println(map1)
}
