好程序員大數(shù)據(jù)學(xué)習(xí)路線分享函數(shù)+map映射+元祖-創(chuàng)新互聯(lián)

好程序員大數(shù)據(jù)學(xué)習(xí)路線分享函數(shù)+map映射+元祖，大數(shù)據(jù)各個平臺上的語言實現(xiàn)

成都創(chuàng)新互聯(lián)是一家企業(yè)級云計算解決方案提供商,超15年IDC數(shù)據(jù)中心運(yùn)營經(jīng)驗。主營GPU顯卡服務(wù)器，站群服務(wù)器，成都二樞機(jī)房，海外高防服務(wù)器，大帶寬服務(wù)器，動態(tài)撥號VPS，海外云手機(jī)，海外云服務(wù)器，海外服務(wù)器租用托管等。

hadoop ??由java實現(xiàn),2003年至今,三大塊:數(shù)據(jù)處理,數(shù)據(jù)存儲,數(shù)據(jù)計算

存儲: hbase --> 數(shù)據(jù)成表

處理: hive --> 數(shù)據(jù)倉庫的工具

計算: mapreduce --> 入門級

hive ???java實現(xiàn)

flink ??流失處理 ?scala實現(xiàn) ?--> 計算引擎

kafka ??數(shù)據(jù)緩存 ?scala實現(xiàn)

spark scala實現(xiàn) \ python

DL 4j scala實現(xiàn)

sklearning python實現(xiàn)

akka scala實現(xiàn) ?--> 通信

scala發(fā)展歷程

scala作者:

馬丁,函數(shù)編程的愛好者,一直在jvm平臺上工作

scala的魅力

scala針對spark集群里的spark -shell 進(jìn)行腳本編程

scala針對IDEA的maven,進(jìn)行spark的app開發(fā)

大數(shù)據(jù)開發(fā)編程思想

1.加載數(shù)據(jù)集,(基于本地數(shù)據(jù),win \ hdfs \ Array)

2.分割數(shù)據(jù)集,(聚合操作)

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

4.調(diào)試,測試代碼

5.調(diào)優(yōu),代碼,app,數(shù)據(jù)傾斜,troubleshooting故障排除

6.上線

val 和 var

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

var可以修改

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

scala 數(shù)據(jù)類型:

scala中,一切類的基類為 Any

第一種:

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

第二種:

AnyVal,是Any的子類,Byte\Char\Short\int\Long\Float\Double(無包裝類)-->七種數(shù)據(jù)類型,Unit(無返回值類型)\Boolean

條件表達(dá)式

object test {

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

val x = 1

//判斷x的值,將結(jié)果賦給y

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

println(y) ??//1

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

//支持混合類型表達(dá)式

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

println(z) //error

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

//如果缺失else,相當(dāng)于if(x>2) 1 else ()

val m = if (x > 2) 1

println(m) ??//()

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

//在scala里每個表達(dá)式里都有值,scala中有個unit類,寫作(),相當(dāng)于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

}

塊表達(dá)式

* 在scala中"{}"中包含一系列的列表達(dá)式就形成了塊表達(dá)式

* 下面就是一個塊表達(dá)式

* 用lazy關(guān)鍵字來修飾,該代碼局就是在調(diào)用才運(yùn)行

object Block {

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

val x = 0

val result = {

if (x < 0) {

-1

} else if (x >= 1) {

} else {

"error"

}

println(result) //result的值就是整塊的表達(dá)式的結(jié)果

}

printf打印和foreach的使用

arr.toBuffer ?-> 變常數(shù)組

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 用法 --> 相當(dāng)于格式化

%s ?表示字符串

%d ?表示數(shù)字

object game {

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

//readline()允許我們從控制臺讀取用戶輸入的數(shù)據(jù),類似于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循環(huán)的三種方式+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)

| }

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內(nèi)部調(diào)用for循環(huán),進(jìn)行過濾

ArrayBuffer(2, 4, 6)

三種for循環(huán)中,to包含最后一位,until不包含

高級for循環(huán) -> 嵌套

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

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

12 13 21 23 31 32

關(guān)鍵字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則直接輸出結(jié)果,不返回數(shù)組

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 = ()

函數(shù)和方法

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

沒有返回類型不打印結(jié)果,除非在方法中print,或者加入默認(rèn)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)

//不出結(jié)果,沒有返回值類型

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

//如果加上=號,系統(tǒng)會自定判斷數(shù)據(jù)類型

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)

}

-----------------------------------定義函數(shù)-----------------------------------

函數(shù)的返回值類型不能不寫,可以寫"()"

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>

調(diào)用函數(shù):map提供數(shù)組

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) ?//輸出結(jié)果為 ArrayBuffer(40, 60, 80, 100, 120, 140)

}

---------------------------方法與函數(shù)的區(qū)別-----------------------

在函數(shù)式編程語言中，函數(shù)是“頭等公民”，它可以像任何其他數(shù)據(jù)類型一樣被傳遞和操作

案例:首先定義一個方法,在定義一個函數(shù),然后將函數(shù)傳遞給方法里面

object hanshu {

//定義一個方法

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

f(2,3)

}

//定義函數(shù)

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

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

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

//調(diào)用函數(shù)方法

println(t1(f1)) ???//6

println(t1(f2)) ???//5

}

Array數(shù)組

數(shù)組常用算法

好程序員大數(shù)據(jù)學(xué)習(xí)路線分享函數(shù)+map映射+元祖

可變字符串導(dǎo)包?: import scala.collection.mutable.ArrayBuffer

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

導(dǎo)包后的字符串?(可變)

增加數(shù)據(jù)

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)

從指定位置增加數(shù)據(jù)

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) //第幾個元素開始,到第幾個元素結(jié)束

scala> arr2

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

反轉(zhuǎn)

Map映射

首先導(dǎo)包?: import scala.collection.mutable.Map

定義map集合的兩種方法

scala> val age = Map("jack"-> 20,"Leo"-> 21) ??//箭頭創(chuàng)建

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

scala> val age = Map(("jack"->20),("Leo"->30)) ?//元祖創(chuàng)建

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集指定參數(shù)

scala> age("Leo")->20

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

增加map集參數(shù)

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

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

刪除map集參數(shù)

scala> age - "Mike"

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

循環(huán)遍歷??(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)

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

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

創(chuàng)建元祖

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開始,數(shù)組從下標(biāo)0開始取

scala> tuple._1

res14: String = zhangsan

scala> tuple._3

res15: Boolean = true

將數(shù)組轉(zhuǎn)成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命令將多個值綁在一起

注意：如果兩個數(shù)組的元素個數(shù)不一致，拉鏈操作后生成的數(shù)組的長度為較小的那個數(shù)組的元素個數(shù)

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(默認(rèn))兩種類型

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

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

- ?在Scala中列表要么為空（Nil表示空列表）要么是一個head元素加上一個tail列表。

- ?:: ??表示右結(jié)合,列表從右開始向左結(jié)合

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

package com.qf.collect

object ImmutListDemo {

def main(args: Array[String]) {

//創(chuàng)建一個不可變的集合

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的后面產(chǎn)生一個新的集合

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中元素不能重復(fù),自動去重

// ?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是無序的不可重復(fù)的

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

另外有需要云服務(wù)器可以了解下創(chuàng)新互聯(lián)scvps.cn，海內(nèi)外云服務(wù)器15元起步，三天無理由+7*72小時售后在線，公司持有idc許可證，提供“云服務(wù)器、裸金屬服務(wù)器、高防服務(wù)器、香港服務(wù)器、美國服務(wù)器、虛擬主機(jī)、免備案服務(wù)器”等云主機(jī)租用服務(wù)以及企業(yè)上云的綜合解決方案，具有“安全穩(wěn)定、簡單易用、服務(wù)可用性高、性價比高”等特點與優(yōu)勢，專為企業(yè)上云打造定制，能夠滿足用戶豐富、多元化的應(yīng)用場景需求。

網(wǎng)站名稱：好程序員大數(shù)據(jù)學(xué)習(xí)路線分享函數(shù)+map映射+元祖-創(chuàng)新互聯(lián)
URL標(biāo)題：http://muchs.cn/article44/dpiphe.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供小程序開發(fā)、網(wǎng)站建設(shè)、App設(shè)計、云服務(wù)器、網(wǎng)站導(dǎo)航、定制開發(fā)

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源：創(chuàng)新互聯(lián)

猜你還喜歡下面的內(nèi)容