隨著大數據的發展，spark逐漸成為主流技術之一，而且支撐的scala語言也成為做大數據熱門的編程語言之一，在家無聊，就將scala中一些常用的的scala的高端函數以及set、map等代碼進行整理，在最後有一個完整的wordcount大數據入門源碼，
想要完整scala以及大數據學習文檔的可以私信“資料”博主獲取偏應用函數
偏應用函數是一種表達式，不需要提供函數需要的所有參數，只需要提供部分，或不提供所需參數。
/**
* 偏應用函數
*/
def log(date :Date, s :String)= {
println("date is "+ date +",log is "+ s)
}
val date = new Date()
log(date ,"log1")
log(date ,"log2")
log(date ,"log3")
//想要調用log，以上變化的是第二個參數，可以用偏應用函數處理
val logWithDate = log(date,_:String)
logWithDate("log11")
logWithDate("log22")
logWithDate("log33")
高階函數
函數的參數是函數，或者函數的返回類型是函數，或者函數的參數和函數的返回類型是函數的函數。
l 函數的參數是函數
l 函數的返回是函數
l 函數的參數和函數的返回是函數
/**
* 高階函數
* 函數的參數是函數 或者函數的返回是函數 或者函數的參數和返回都是函數
*/
//函數的參數是函數
def hightFun(f : (Int,Int) =>Int, a:Int ) : Int = {
f(a,100)
}
def f(v1 :Int,v2: Int):Int = {
v1+v2
}
println(hightFun(f, 1))
//函數的返回是函數
//1，2,3,4相加
def hightFun2(a : Int,b:Int) : (Int,Int)=>Int = {
def f2 (v1: Int,v2:Int) :Int = {
v1+v2+a+b
}
f2
}
println(hightFun2(1,2)(3,4))
//函數的參數是函數，函數的返回是函數
def hightFun3(f : (Int ,Int) => Int) : (Int,Int) => Int = {
f
}
println(hightFun3(f)(100,200))
println(hightFun3((a,b) =>{a+b})(200,200))
//以上這句話還可以寫成這樣
//如果函數的參數在方法體中只使用了一次 那麼可以寫成_表示
println(hightFun3(_+_)(200,200))
柯里化函數
l 可以理解為高階函數的簡化
/**
* 柯里化函數
*/
def fun7(a :Int,b:Int)(c:Int,d:Int) = {
a+b+c+d
}
println(fun7(1,2)(3,4))
Scala字符串
1. String
2. StringBuilder 可變
3. string操作方法舉例
Ø 比較:equals
Ø 比較忽略大小寫:equalsIgnoreCase
Ø indexOf：如果字符串中有傳入的assci碼對應的值，返回下標
/**
* String && StringBuilder
*/
val str = "abcd"
val str1 = "ABCD"
println(str.indexOf(97))
println(str.indexOf("b"))
println(str==str1)
/**
* compareToIgnoreCase
*
* 如果參數字符串等於此字符串，則返回值 0；
* 如果此字符串小於字符串參數，則返回一個小於 0 的值；
* 如果此字符串大於字符串參數，則返回一個大於 0 的值。
*
*/
println(str.compareToIgnoreCase(str1))
val strBuilder = new StringBuilder
strBuilder.append("abc")
// strBuilder.+('d')
strBuilder+ 'd'
// strBuilder.++=("efg")
strBuilder++= "efg"
// strBuilder.+=('h')
strBuilder+= 'h'
strBuilder.append(1.0)
strBuilder.append(18f)
println(strBuilder)
String方法：（見附件）
集合
數組
1. 創建數組
Ø new Array[Int](10)
賦值：arr(0) = xxx
Ø Array[String](“s1”,”s2”,”s3”)
2. 數組遍歷
Ø for
Ø foreach
3. 創建一維數組和二維數組
4. 數組中方法舉例
Ø Array.concate：合併數組
Ø Array.fill(5)(“bjsxt”)：創建初始值的定長數組
創建兩種方式:
/**
* 創建數組兩種方式：
* 1.new Array[String](3)
* 2.直接Array
*/
//創建類型為Int 長度為3的數組
val arr1 = new Array[Int](3)
//創建String 類型的數組，直接賦值
val arr2 = Array[String]("s100","s200","s300")
//賦值
arr1(0) = 100
arr1(1) = 200
arr1(2) = 300
遍歷兩種方式：
/**
* 遍歷兩種方式
*/
for(i arr1){
println(i)
}
arr1.foreach(i => {
println(i)
})
for(s arr2){
println(s)
}
arr2.foreach {
x => println(x)
}
創建二維數組
/**
* 創建二維數組和遍歷
*/
val arr3 = new Array[Array[String]](3)
arr3(0)=Array("1","2","3")
arr3(1)=Array("4","5","6")
arr3(2)=Array("7","8","9")
for(i 0 until arr3.length){
for(j 0 until arr3(i).length){
print(arr3(i)(j)+" ")
}
println()
}
var count = 0
for(arr arr3 ;i arr){
if(count%3 == 0){
println()
}
print(i+" ")
count +=1
}
arr3.foreach { arr => {
arr.foreach { println }
}}
val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))
arr4.foreach { arr => {
arr.foreach(i => {
println(i)
})
}}
println("-------")
for(arr arr4;i arr){
println(i)
}
數組中的方法
list
1. 創建list
val list = List(1,2,3,4)
Ø Nil長度為0的list
2. list遍歷
foreach ，for
3. list方法舉例
Ø filter:過濾元素
Ø count:計算符合條件的元素個數
Ø map：對元素操作
Ø flatmap ：壓扁扁平,先map再flat
//創建
val list = List(1,2,3,4,5)
//遍歷
list.foreach { x => println(x)}
// list.foreach { println}
//filter
val list1 = list.filter { x => x>3 }
list1.foreach { println}
//count
val value = list1.count { x => x>3 }
println(value)
//map
val nameList = List(
"hello bjsxt",
"hello xasxt",
"hello shsxt"
)
val mapResult:List[Array[String]] = nameList.map{ x => x.split(" ") }
mapResult.foreach{println}
//flatmap
val flatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") }
flatMapResult.foreach { println }
4. list方法總結
set
1. 創建set
注意：set集合會自動去重
2. set遍歷
foreach，for
3. set方法舉例
Ø 交集：intersect ,&
Ø 差集: diff ,&~
Ø 子集:subsetOf
Ø 最大:max
Ø 最小:min
Ø 轉成數組，toList
Ø 轉成字符串：mkString(“~”)
4. set方法總結
//創建
val set1 = Set(1,2,3,4,4)
val set2 = Set(1,2,5)
//遍歷
//注意：set會自動去重
set1.foreach { println}
for(s
println(s)
}
println("*******")
/**
* 方法舉例
*/
//交集
val set3 = set1.intersect(set2)
set3.foreach{println}
val set4 = set1.&(set2)
set4.foreach{println}
println("*******")
//差集
set1.diff(set2).foreach { println }
set1.&~(set2).foreach { println }
//子集
set1.subsetOf(set2)
//最大值
println(set1.max)
//最小值
println(set1.min)
println("****")
//轉成數組，list
set1.toArray.foreach{println}
println("****")
set1.toList.foreach{println}
//mkString
println(set1.mkString)
println(set1.mkString("\\t"))
set方法總結
map
1. map創建
Ø Map（1 –>”bjsxt’）
Ø Map((1,”bjsxt”))
注意：創建map時，相同的key被後面的相同的key頂替掉，只保留一個
val map = Map(
"1" -> "bjsxt",
2 -> "shsxt",
(3,"xasxt")
)
2. 獲取map的值
Ø map.get(“1”).get
Ø map.get(100).getOrElse(“no value”)：如果map中沒有對應項，賦值為getOrElse傳的值。
//獲取值
println(map.get("1").get)
val result = map.get(8).getOrElse("no value")
println(result)
3. 遍歷map
Ø for,foreach
//map遍歷
for(x
println("====key:"+x._1+",value:"+x._2)
}
map.foreach(f => {
println("key:"+ f._1+" ,value:"+f._2)
})
4. 遍歷key
Ø map.keys
//遍歷key
val keyIterable = map.keys
keyIterable.foreach { key => {
println("key:"+key+", value:"+map.get(key).get)
} }
println("---------")
5. 遍歷value
Ø map.values
//遍歷value
val valueIterable = map.values
valueIterable.foreach { value => {
println("value: "+ value)
} }
6. 合併map
Ø ++ 例：map1.++(map2) --map1中加入map2
Ø ++: 例：map1.++:(map2) –map2中加入map1
注意：合併map會將map中的相同key的value替換
//合併map
val map1 = Map(
(1,"a"),
(2,"b"),
(3,"c")
)
val map2 = Map(
(1,"aa"),
(2,"bb"),
(2,90),
(4,22),
(4,"dd")
)
map1.++:(map2).foreach(println)
7. map中的方法舉例
Ø filter:過濾，留下符合條件的記錄
Ø count:統計符合條件的記錄數
Ø contains：map中是否包含某個key
Ø exist：符合條件的記錄存在不存在
/**
* map方法
*/
//count
val countResult = map.count(p => {
p._2.equals("shsxt")
})
println(countResult)
//filter
map.filter(_._2.equals("shsxt")).foreach(println)
//contains
println(map.contains(2))
//exist
println(map.exists(f =>{
f._2.equals("xasxt")
}))
元組
1. 元組定義
與列表一樣，與列表不同的是元組可以包含不同類型的元素。元組的值是通過將單個的值包含在圓括號中構成的。
2. 創建元組與取值
Ø val tuple = new Tuple（1） 可以使用new
Ø val tuple2 = Tuple（1,2） 可以不使用new，也可以直接寫成val tuple3 =（1,2,3）
Ø 取值用”._XX” 可以獲取元組中的值
注意：tuple最多支持22個參數
//創建，最多支持22個
val tuple = new Tuple1(1)
val tuple2 = Tuple2("zhangsan",2)
val tuple3 = Tuple3(1,2,3)
val tuple4 = (1,2,3,4)
val tuple18 = Tuple18(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18)
val tuple22 = new Tuple22(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)
//使用
println(tuple2._1 + "\\t"+tuple2._2)
val t = Tuple2((1,2),("zhangsan","lisi"))
println(t._1._2)
3. 元組的遍歷
tuple.productIterator得到迭代器，進而遍歷
//遍歷
val tupleIterator = tuple22.productIterator
while(tupleIterator.hasNext){
println(tupleIterator.next())
}
4. swap,toString方法
注意：swap元素翻轉，只針對二元組
/**
* 方法
*/
//翻轉，只針對二元組
println(tuple2.swap)
//toString
println(tuple3.toString())
trait 特性
1. 概念理解
Scala Trait(特徵) 相當於 Java 的接口，實際上它比接口還功能強大。
與接口不同的是，它還可以定義屬性和方法的實現。
一般情況下Scala的類可以繼承多個Trait，從結果來看就是實現了多重繼承。Trait(特徵) 定義的方式與類類似，但它使用的關鍵字是 trait。
2. 舉例：trait中帶屬性帶方法實現
注意：
Ø 繼承的多個trait中如果有同名的方法和屬性，必須要在類中使用“override”重新定義。
Ø trait中不可以傳參數
trait Read {
val readType = "Read"
val gender = "m"
def read(name:String){
println(name+" is reading")
}
}
trait Listen {
val listenType = "Listen"
val gender = "m"
def listen(name:String){
println(name + " is listenning")
}
}
class Person() extends Read with Listen{
override val gender = "f"
}
object test {
def main(args: Array[String]): Unit = {
val person = new Person()
person.read("zhangsan")
person.listen("lisi")
println(person.listenType)
println(person.readType)
println(person.gender)
}
}
3. 舉例：trait中帶方法不實現
object Lesson_Trait2 {
def main(args: Array[String]): Unit = {
val p1 = new Point(1,2)
val p2 = new Point(1,3)
println(p1.isEqule(p2))
println(p1.isNotEqule(p2))
}
}
trait Equle{
def isEqule(x:Any) :Boolean
def isNotEqule(x : Any) = {
!isEqule(x)
}
}
class Point(x:Int, y:Int) extends Equle {
val xx = x
val yy = y
def isEqule(p:Any) = {
p.isInstanceOf[Point] && p.asInstanceOf[Point].xx==xx
}
}
模式匹配match
1. 概念理解：
Scala 提供了強大的模式匹配機制，應用也非常廣泛。
一個模式匹配包含了一系列備選項，每個都開始於關鍵字 case。
每個備選項都包含了一個模式及一到多個表達式。箭頭符號 => 隔開了模式和表達式。
2. 代碼及注意點
Ø 模式匹配不僅可以匹配值還可以匹配類型
Ø 從上到下順序匹配，如果匹配到則不再往下匹配
Ø 都匹配不上時，會匹配到case _ ,相當於default
Ø match 的最外面的”{ }”可以去掉看成一個語句
object Lesson_Match {
def main(args: Array[String]): Unit = {
val tuple = Tuple6(1,2,3f,4,"abc",55d)
val tupleIterator = tuple.productIterator
while(tupleIterator.hasNext){
matchTest(tupleIterator.next())
}
}
/**
* 注意點：
* 1.模式匹配不僅可以匹配值，還可以匹配類型
* 2.模式匹配中，如果匹配到對應的類型或值，就不再繼續往下匹配
* 3.模式匹配中，都匹配不上時，會匹配到 case _ ，相當於default
*/
def matchTest(x:Any) ={
x match {
case x:Int=> println("type is Int")
case 1 => println("result is 1")
case 2 => println("result is 2")
case 3=> println("result is 3")
case 4 => println("result is 4")
case x:String => println("type is String")
// case x :Double => println("type is Double")
case _ => println("no match")
}
}
}
樣例類(case classes)
1. 概念理解
使用了case關鍵字的類定義就是樣例類(case classes)，樣例類是種特殊的類。實現了類構造參數的getter方法（構造參數默認被聲明為val），當構造參數是聲明為var類型的，它將幫你實現setter和getter方法。
Ø 樣例類默認幫你實現了toString,equals，copy和hashCode等方法。
Ø 樣例類可以new, 也可以不用new
2. 例子：結合模式匹配的代碼
case class Person1(name:String,age:Int)
object Lesson_CaseClass {
def main(args: Array[String]): Unit = {
val p1 = new Person1("zhangsan",10)
val p2 = Person1 ("lisi",20)
val p3 = Person1("wangwu",30)
val list = List(p1,p2,p3)
list.foreach { x => {
x match {
case Person1("zhangsan",10) => println("zhangsan")
case Person1("lisi",20) => println("lisi")
case _ => println("no match")
}
} }
}
}
Actor Model
1. 概念理解
Actor Model是用來編寫並行計算或分佈式系統的高層次抽象（類似java中的Thread）讓程序員不必為多線程模式下共享鎖而煩惱,被用在Erlang 語言上, 高可用性99.9999999 % 一年只有31ms 宕機Actors將狀態和行為封裝在一個輕量的進程/線程中，但是不和其他Actors分享狀態，每個Actors有自己的世界觀，當需要和其他Actors交互時，通過發送事件和消息，發送是異步的，非堵塞的(fire-andforget)，發送消息後不必等另外Actors回覆，也不必暫停，每個Actors有自己的消息隊列，進來的消息按先來後到排列，這就有很好的併發策略和可伸縮性，可以建立性能很好的事件驅動系統。
Actor的特徵：
Ø ActorModel是消息傳遞模型,基本特徵就是消息傳遞
Ø 消息發送是異步的，非阻塞的
Ø 消息一旦發送成功，不能修改
Ø Actor之間傳遞時，自己決定決定去檢查消息，而不是一直等待，是異步非阻塞的
什麼是Akka
Akka 是一個用 Scala 編寫的庫，用於簡化編寫容錯的、高可伸縮性的 Java 和Scala 的 Actor 模型應用，底層實現就是Actor,Akka是一個開發庫和運行環境，可以用於構建高併發、分佈式、可容錯、事件驅動的基於JVM的應用。使構建高併發的分佈式應用更加容易。
spark1.6版本之前，spark分佈式節點之間的消息傳遞使用的就是Akka，底層也就是actor實現的。1.6之後使用的netty傳輸。
2. 例：Actor簡單例子發送接收消息
import scala.actors.Actor
class myActor extends Actor{
def act(){
while(true){
receive {
case x:String => println("save String ="+ x)
case x:Int => println("save Int")
case _ => println("save default")
}
}
}
}
object Lesson_Actor {
def main(args: Array[String]): Unit = {
//創建actor的消息接收和傳遞
val actor =new myActor()
//啟動
actor.start()
//發送消息寫法
actor ! "i love you !"
}
}
3. 例：Actor與Actor之間通信
case class Message(actor:Actor,msg:Any)
class Actor1 extends Actor{
def act(){
while(true){
receive{
case msg :Message => {
println("i sava msg! = "+ msg.msg)
msg.actor!"i love you too !"
}
case msg :String => println(msg)
case _ => println("default msg!")
}
}
}
}
class Actor2(actor :Actor) extends Actor{
actor ! Message(this,"i love you !")
def act(){
while(true){
receive{
case msg :String => {
if(msg.equals("i love you too !")){
println(msg)
actor! "could we have a date !"
}
}
case _ => println("default msg!")
}
}
}
}
object Lesson_Actor2 {
def main(args: Array[String]): Unit = {
val actor1 = new Actor1()
actor1.start()
val actor2 = new Actor2(actor1)
actor2.start()
}
}
附贈Wordcount源碼
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.rdd.RDD.rddToPairRDDFunctions
object WordCount {
def main(args: Array[String]): Unit = {
val conf = new SparkConf()
conf.setMaster("local").setAppName("WC")
val sc = new SparkContext(conf)
val lines :RDD[String] = sc.textFile("./words.txt")
val word :RDD[String] = lines.flatMap{lines => {
lines.split(" ")
}}
val pairs : RDD[(String,Int)] = word.map{ x => (x,1) }
val result = pairs.reduceByKey{(a,b)=> {a+b}}
result.sortBy(_._2,false).foreach(println)
//簡化寫法
lines.flatMap { _.split(" ")}.map { (_,1)}.reduceByKey(_+_).foreach(println)
}
}
老規矩，想要完整scala以及大數據學習文檔的可以私信“資料”博主獲取，博主已經打包準備好，這裡只展示一部分文檔，嘿嘿
閱讀更多 大數據互聯網架構師 的文章
