好程式設計師大資料學習路線分享函式+map對映+元祖

好程式設計師IT發表於2019-08-23

好程式設計師大資料學習路線分享函式+map 對映 + 元祖, 大資料各個平臺上的語言實現

hadoop   由java實現,2003年至今,三大塊:資料處理,資料儲存,資料計算

儲存: hbase --> 資料成表

處理: hive --> 資料倉儲的工具

計算: mapreduce --> 入門級

hive    java實現

flink   流失處理  scala實現  --> 計算引擎

kafka   資料快取  scala實現

spark scala實現 \ python

DL 4j scala實現

sklearning python實現

akka scala實現  --> 通訊

scala發展歷程

scala作者:

馬丁,函式程式設計的愛好者,一直在jvm平臺上工作

scala的魅力

scala針對spark叢集裡的spark -shell 進行指令碼程式設計

scala針對IDEA的maven,進行spark的app開發

 

大資料開發程式設計思想

1.載入資料集,(基於本地資料,win \ hdfs \ Array)

2.分割資料集,(聚合操作)

3.選擇apache框架(處理-Hive,儲存-HBSE,計算-mapreduce,)

4.除錯,測試程式碼

5.調優,程式碼,app,資料傾斜,troubleshooting故障排除

6.上線

 

val 和 var

val被final修飾,不可以修改變數值


var可以修改


java和scala共用jvm,但是思想不一樣

 

scala 資料型別:

scala中,一切類的基類為 Any

第一種:

AnyRef,是Any的子類,是所有的引用型別的基類,所有的繼承都來自AnyRef

第二種:

AnyVal,是Any的子類,Byte\Char\Short\int\Long\Float\Double(無包裝類)-->七種資料型別,Unit(無返回值型別)\Boolean

條件表示式

object test {

  def main(args: Array[String]): Unit = {

    val x = 1

    //判斷x的值,將結果賦給y

    val y = if (x > 0) 1 else -1

    println(y)   //1

    println("------------------------------------------")

 

    //支援混合型別表示式

    val z = if (x > 1) 1 else "error"

    println(z) //error

    println("------------------------------------------")

 

    //如果缺失else,相當於if(x>2) 1 else ()

    val m = if (x > 2) 1

    println(m)   //()

    println("-----------------------------------------------")

 

    //在scala裡每個表示式裡都有值,scala中有個unit類,寫作(),相當於java裡的void

    val n = if (x > 2) 1 else ()

    println(n)  //()

    println("----------------------------------------------")

 

    //if,else if

    val k = if (x < 0) 0

    else if (x >= 1) 1 else -1

    println(k)  //1

  }

}

塊表示式

* 在scala中"{}"中包含一系列的列表示式就形成了塊表示式

* 下面就是一個塊表示式

* 用lazy關鍵字來修飾,該程式碼局就是在呼叫才執行

object Block {

  def main(args: Array[String]): Unit = {

    

    val x = 0

 

    val result = {

      if (x < 0) {

        -1

      } else if (x >= 1) {

        1

      } else {

        "error"

      }

    }

    println(result) //result的值就是整塊的表示式的結果

  }

}

printf列印和foreach的使用

arr.toBuffer  -> 變常陣列

scala> val arr = Array(1,2,3,4)

arr: Array[Int] = Array(1, 2, 3, 4)

 

scala> print(arr.toString)

[I@108fa66

scala> print(arr.toBuffer)

ArrayBuffer(1, 2, 3, 4)

printf 用法 --> 相當於格式化


%s  表示字串

%d  表示數字

object game {

  def main(args: Array[String]): Unit = {

    //readline()允許我們從控制檯讀取使用者輸入的資料,類似於java中的System.in和Scanner

 

    val  name = readLine("Welcome to Game House,please tell me your name:\n")

    print("Thanks,then please tell me your age:\n")

 

    val age = readInt() //初始化

    if(age > 18){

      printf("Hi,%s,you are %d years old,so you are legal to come here",name,age)

    }

    else{

      printf("Sorry,%s,you are only %d years old,you are illegal to come here",name,age)

    }

  }

 

}

 

for迴圈的三種方式+filter

scala> val arr = Array(2,3,4,6)

arr: Array[Int] = Array(2, 3, 4, 6)

 

scala> for(i <- arr){

     | if(i%2 == 0){

     | println(i)

     | }

     | }

2

4

6

 

scala> for(i <- 0  until arr.length){

     | if(arr(i)%2 == 0){

     | print(arr(i))}}

246

scala> for(i <- 0  to arr.length-1){

     | if(arr(i)%2 == 0){

     | print(arr(i)+" ")}}

2 4 6

scala> println(arr.filter(_%2==0).toBuffer)  //filter內部呼叫for迴圈,進行過濾

ArrayBuffer(2, 4, 6)

三種for迴圈中,to包含最後一位,until不包含

高階for迴圈 -> 巢狀

scala> for(i <- 1 to 3; j <- 1 to 3 if i != j )

     | print((10 * i + j)+ " ")

12 13 21 23 31 32

關鍵字yield -> 生成新集合

scala> val value = for(i <- 1 to 10) yield i * 10

value: scala.collection.immutable.IndexedSeq[Int] = Vector(10, 20, 30, 40, 50, 6

0, 70, 80, 90, 100)

 

foreach 的引用

map方法返回的是一個新的Array,會佔用資源,foreach則直接輸出結果,不返回陣列

scala> arr

res19: Array[Int] = Array(2, 3, 4, 6)

 

scala> arr.map(x => print(x))

2346res20: Array[Unit] = Array((), (), (), ())

 

scala> arr.foreach(print)

2346

 

scala> val r = print(2)

2r: Unit = ()

函式和方法

---------------------------------- 定義方法 ---------------------------------


沒有返回型別不列印結果,除非在方法中print,或者加入預設Unit型別

scala> def test(x:Int,y:Int):Int = {x * y}

test: (x: Int, y: Int)Int

scala> test(3,4)

res22: Int = 12

 

scala> def test1(x:Int,y:Int){x * y}

test1: (x: Int, y: Int)Unit

scala> test1(2,3)

   //不出結果,沒有返回值型別

 

 

scala> def test3(x:Int,y:Int)={x * y}

  //如果加上=號,系統會自定判斷資料型別

test3: (x: Int, y: Int)Int

 

scala> test3(2,3)

res8: Int = 6

         

scala> def test2(x:Int,y:Int){

     | println(x * y)}

test2: (x: Int, y: Int)Unit

scala> test2(2,3)

6  //沒有返回值,是print出來的

 

對於遞迴方法,必須指定返回型別

object digui {

  def main(args: Array[String]): Unit = {

    println(fab(3))   

  }

 

  def fab(n:Int):Int = {

    if (n <= 1) 1

    else fab(n - 1) + fab(n - 2)

  }

}

----------------------------------- 定義函式 -----------------------------------


函式的返回值型別不能不寫,可以寫"()"

scala> val fun1 = (x:Int,y:Int) => x * y

fun1: (Int, Int) => Int = <function2>

 

scala> fun1(2,3)

res9: Int = 6

 

scala> val fun2 = () =>10

fun2: () => Int = <function0>

 

scala> fun2()

res10: Int = 10

 

scala> fun2

res11: () => Int = <function0>

 

呼叫函式:map提供陣列

object func {

  def main(args: Array[String]): Unit = {

    val arr = Array(2,3,4,5,6,7)

 

//    val fun = (x:Int) => x*20

//    val res = arr.map(fun) //第一種

 

//    val res = arr.map((x:Int) => x*20) //第二種  

    val res = arr.map(_ *20) //第三種

 

    println(res.toBuffer)  //輸出結果為 ArrayBuffer(40, 60, 80, 100, 120, 140)

  }

}

 

--------------------------- 方法與函式的區別 -----------------------

在函數語言程式設計語言中,函式是“頭等公民”, 它可以像任何其他資料型別一樣被傳遞和操作

案例:首先定義一個方法,在定義一個函式,然後將函式傳遞給方法裡面

object hanshu {

 

  //定義一個方法

  def t1(f:(Int,Int) => Int) : Int = {

    f(2,3)

  }

 

  //定義函式

  val f1=(x:Int,y:Int) => x * y

  val f2=(m:Int,n:Int) => m + n

 

  def main(args: Array[String]): Unit = {

    //呼叫函式方法

    println(t1(f1))    //6

    println(t1(f2))    //5

  }

}

Array陣列

陣列常用演算法

可變字串導包 : import scala.collection.mutable.ArrayBuffer

定義集合時 : Array()不可變,ArrayBuffer()可變

導包後的字串 (可變)


增加資料

 

scala> val arr2=new ArrayBuffer[Int](1)

arr2: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

 

scala> arr2 += 2

res24: arr2.type = ArrayBuffer(2)

 

scala> arr2 += (3,4,5)

res25: arr2.type = ArrayBuffer(2, 3, 4, 5)

 

scala> arr2 ++= ArrayBuffer(1)

res27: arr2.type = ArrayBuffer(2, 3, 4, 5, 1)

從指定位置增加資料

scala> arr2.insert(0,20,21)

 

scala> arr2

res29: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(20, 21, 2, 3, 4,5,1)

刪除元素

scala> arr2.remove(2,3) //第幾個元素開始,到第幾個元素結束

 

scala> arr2

res33: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(20, 21, 5, 1)

反轉


Map對映

首先導包 : import scala.collection.mutable.Map

定義map集合的兩種方法

scala> val age = Map("jack"-> 20,"Leo"-> 21)   //箭頭建立

age: scala.collection.immutable.Map[String,Int] = Map(jack -> 20, Leo -> 21)

 

scala> val age = Map(("jack"->20),("Leo"->30))  //元祖建立

age: scala.collection.immutable.Map[String,Int] = Map(jack -> 20, Leo -> 30)

檢視map集

scala> age("Leo")

res0: Int = 30

 

scala> age

res1: scala.collection.immutable.Map[String,Int] = Map(jack -> 20, Leo -> 30)

修改map集指定引數

scala> age("Leo")->20

res3: (Int, Int) = (30,20)

增加map集引數

scala> age += ("Mike"->18,"Heb"->23)

res9: age.type = Map(jack -> 20, Mike -> 18, Heb -> 23, Leo -> 21)

刪除map集引數

scala> age - "Mike"

res10: scala.collection.mutable.Map[String,Int] = Map(jack -> 20, Heb -> 23, Leo -> 21)

迴圈遍歷  (LinkedHashMap \ SortedMap)

scala> for((key,value) <- age) println(key+ " "+value)

jack 20

Mike 18

Heb 23

Leo 21

 

scala> for(key <- age.keySet) println(key)

jack

Mike

Heb

Leo

 

scala> for(value <- age.values) println(value)

20

18

23

21

 

--------------------- 元祖 ------------------------

小括號括起來的多種型別的值就叫元祖(tuple)

建立元祖

scala> val tuple = ("zhangsan",10,2.3,true)

tuple: (String, Int, Double, Boolean) = (zhangsan,10,2.3,true)

 

scala> val tuple,(a,b,c) = ("zhangsan",2,true)

tuple: (String, Int, Boolean) = (zhangsan,2,true)

a: String = zhangsan

b: Int = 2

c: Boolean = true

獲取元祖 元祖從1開始,陣列從下標0開始取

scala> tuple._1

res14: String = zhangsan

 

scala> tuple._3

res15: Boolean = true

將陣列轉成map對映

scala> val arr = Array(("xixi",2),("haha",1),("heihei",3))

arr: Array[(String, Int)] = Array((xixi,2), (haha,1), (heihei,3))

 

scala> arr.toMap

res16: scala.collection.immutable.Map[String,Int] = Map(xixi -> 2, haha -> 1, he

ihei -> 3)

拉鍊操作 : zip命令將多個值綁在一起

注意:如果兩個陣列的元素個數不一致,拉鍊操作後生成的陣列的長度為較小的那個陣列的元素個數

scala> val arr2 = Array(2,3,4)

arr2: Array[Int] = Array(2, 3, 4)

 

scala> arr zip arr2

res17: Array[((String, Int), Int)] = Array(((xixi,2),2), ((haha,1),3), ((heihei,

3),4))

對映是kv對偶的集合,對偶是元祖的最簡單形式,稱 對偶元祖

scala支援的元祖長度最大為22(個元素)

 

---------------------- 集合 ----------------------

scala的集合有三個類:序列sep,集合set,對映Map

scala中集合有 可變mutable和 不可變immutable(預設)兩種型別

 

--------------------------- 序列 --------------------------

-  不可變的序列 import scala.collection.immutable._

-  在Scala中列表要麼為空(Nil 表示空列表)要麼是一個head元素加上一個tail列表。

-  ::   表示右結合,列表從右開始向左結合

-  定義List時,List()不可變,ListBuffer()可變

package com.qf.collect

 

object ImmutListDemo {

 

  def main(args: Array[String]) {

    //建立一個不可變的集合

    val lst1 = List(1,2,3)

    //將0插入到lst1的前面生成一個新的List

    val lst2 = 0 :: lst1

    val lst3 = lst1.::(0)

    val lst4 = 0 +: lst1

    val lst5 = lst1.+:(0)

 

    //將一個元素新增到lst1的後面產生一個新的集合

    val lst6 = lst1 :+ 3

 

    //將2個list合併成一個新的List

        val lst0 = List(4,5,6)

    val lst7 = lst1 ++ lst0

 

    //將lst0插入到lst1後面生成一個新的集合

    val lst8 = lst1 ++: lst0

 

    //將lst0插入到lst1前面生成一個新的集合

    val lst9 = lst1.:::(lst0)

 

    println(lst9)

  }

}

 

----------------------------Set------------------------

不可變的

object ImmutableSet extends App{

  val set1 = new HashSet[Int]()

  //將元素和set合併並生成一個新的set,原有的set不變

  val set2 = set1 + 4

  println(set2)   //Set(4)

 

  //set中元素不能重複,自動去重

//  val set3 = set2 ++ Set(5,6,7) //Set(5,6,7,4)

  val set3 = Set(2,3) ++ set2

  println(set3)  //Set(2,3,4)

}

可變的    set是無序的不可重複的

scala> import scala.collection.mutable._

import scala.collection.mutable._

 

scala> val set1 = HashSet(2,3,4)

set1: scala.collection.mutable.HashSet[Int] = Set(2, 3, 4)

 

scala> set1 += 1

res0: set1.type = Set(1, 2, 3, 4)

 

scala> set1.add(4)

res1: Boolean = false

 

scala> set1.add(6)

res2: Boolean = true

 

scala> set1

res3: scala.collection.mutable.HashSet[Int] = Set(1, 2, 6, 3, 4)

 

scala> set1 ++= HashSet(2,7)

res4: set1.type = Set(1, 2, 6, 3, 7, 4)

 

scala> set1 -= 1

res5: set1.type = Set(2, 6, 3, 7, 4)

 

scala> set1.remove(2)

res6: Boolean = true


來自 “ ITPUB部落格 ” ,連結:http://blog.itpub.net/69913892/viewspace-2654757/,如需轉載,請註明出處,否則將追究法律責任。

相關文章