大數據知識:快學Scala(一)Scala的函數、方法和數據結構

大數據知識:快學Scala(一)Scala的函數、方法和數據結構

簡介

上一章，我們已經學習了Scala語言的特點，它是運行在JVM上的一種多範式編程式語言，具有開發快，靈活等特點。如果對於基礎不好的同學可以看一下我的文章大數據知識:快學Scala(一)Scala基礎。這一章我們將會介紹Scala語言的函數和方法、以及在Scala語言中常用的數據結構。

方法和函數

Scala中的+ - * / %等操作符的作用與Java一樣，位操作符& | ^ >> <<也一樣。只是有

一點特別的：這些操作符實際上是方法。例如：

a + b

是如下方法調用的簡寫：

a.+(b)

a 方法b可以寫成a.方法(b)

方法

方法的返回值類型可以不寫，編譯器可以自動推斷出來，但是對於遞歸函數，必須指定返回類型

函數

方法和函數的區別

在函數式編程語言中，函數是「頭等公民」，它可以像任何其他數據類型一樣被傳遞和操作

案例：首先定義一個方法，再定義一個函數，然後將函數傳遞到方法裡面

[cpp] view plain copy

1. package cn.edu.hust.scala
2. object FuctionDemo {
3. //定義方法，方法和函數是不一樣的，方法可以不指定返回類型，只有遞歸函數需要指定
4. def calculate(x:Int,y:Int): Int=x+y
5. def f1(x:Int,y:Int): Int={
6. x*y
7. }
8. //定義函數
9. val f=(x:Int) => { x+10 }
10. //在方法裡面調用函數
11. def f2(f:Int=>Int,x:Int):Int={
12. f(x)
13. }
14. //定義一個函數，返回元祖，用(a,b)接受參數，具體實現如下
15. val func:(Int,Double)=>(Double,Int)={
16. (a,b)=>(b,a)
17. }
18. //定義一個沒有返回值的方法,主要使用unit
19. def func2(x:Int,y:Int):Unit={
20. println(x+y)
21. }
22. def main(args: Array[String]): Unit = {
23. val x=10
24. val y=20
25. println(calculate(x,y))
26. //定義函數
27. val z=(x:Int,y:Int) => { x+y }
28. val t=(x:String,y:String) => {x+y}
29. //方法裡面調用函數
30. println(f2(f,10))
31. //函數的使用
32. println(z(100,200))
33. val arr=Array(1,2,3,4,5)
34. val arr1=arr.map(f)
35. println(arr1.toBuffer)
36. //原始對象沒有變化
37. println(arr.toBuffer)
38. // 調用函數
39. println(func(2,3.0))
40. //將方法轉化為函數,原來的方法不變
41. val b=func2 _
42. b(10,20)
43. }
44. }

Scala語言中的數據結構

Scala中的數組

[cpp] view plain copy

1. package cn.edu.hust.scala
2. import scala.collection.mutable.ArrayBuffer
3. object ArrayDemo {
4. def main(args: Array[String]): Unit = {
5. //聲明一個array，需要指定類型和長度，默認值是0
6. val arr=new Array[Int](8)
7. println(arr.toBuffer)
8. //也可以使用如下的操作聲明
9. val arr2=Array(1,2,3,4,5)
10. //取出下標為1的元素
11. println(arr2(1))
12. //可以使用一下方式,這裡定義了一個長度為1的array，初始值為10
13. val arr3=Array[Int](10)
14. println(arr3.toBuffer)
15. //定義一個可變長度的數組
16. val a=new ArrayBuffer[Int]()
17. a+=1
18. a++=Array(9,8,7,6)
19. println(a)
20. //在特定的下標中插入值
21. a.insert(0,-1,-2)
22. println(a)
23. //移除下標2
24. a.remove(2,1)
25. println(a)
26. //使用下標取值
27. println(a(2))
28. }
29. }

Scala中的

[cpp] view plain copy

1. package cn.edu.hust.scala
2. import scala.collection.mutable.ListBuffer
3. object ListDemo {
4. def main(args: Array[String]): Unit = {
5. //不可變的數組
6. val list1=List(1,2,3,4,5)
7. val list2=List(7,8,9)
8. // 取值
9. println(list1(1))
10. //添加新的元數,添加到前段
11. val list3=list1.+:(0)
12. println(list3)
13. //添加到後段
14. val list4=list1.:+(3)
15. println(list4)
16. val list5=list1++list2
17. //三個一組
18. val lst=list5.grouped(3)
19. println(lst.toList)
20. //將lst壓平
21. val t=lst.toList
22. println(t.flatten)
23. println(list5)
24. val list6=list1:::list2
25. println(list6)
26. println("listbuffer")
27. val lb=new ListBuffer[Int]
28. //添加元素
29. lb+=2
30. //批量添加元素
31. lb+=(3,4,5)
32. //使用方法添加元素
33. lb.append(-1,0)
34. println(lb)
35. val lb2=ListBuffer("a","b","c")
36. //添加成為新的list
37. val lb3=lb2++lb
38. println(lb3)
39. //添加list到lb3中
40. lb3++=lb2
41. println(lb3)
42. }
43. }

Scala中的Map

[cpp] view plain copy

1. package cn.edu.hust.scala
2. import scala.collection.mutable.Map
3. object MapDemo {
4. def main(args: Array[String]): Unit = {
5. //創建一個map
6. val m1=Map("a"->1,"b"->2,"c"->3)
7. println(m1)
8. //修改map的值
9. m1("a")=10
10. println(m1)
11. //添加一些kv
12. m1+="d"->8
13. println(m1)
14. //添加一些元組
15. m1+=(("e",9),("h",10))
16. println(m1)
17. //查詢元素如果不包含的處理,如果沒有就默認設置0
18. val z=m1.getOrElse("z",0)
19. print(z)
20. }
21. }

Scala中的Set

[cpp] view plain copy

1. package cn.edu.hust.scala
2. import scala.collection.mutable
3. object SetDemo {
4. def main(args: Array[String]): Unit = {
5. val s=new mutable.HashSet[Int]
6. //添加元素
7. s+=1;
8. //批量添加元素
9. s+=(2,3,4,5,6)
10. println(s)
11. //改變set
12. s++=mutable.HashSet(0,-1)
13. println(s)
14. //移除元素
15. s.remove(3)
16. println(s)
17. //按照元素
18. s.remove(2)
19. println(s)
20. }
21. }

Scala中的元組

[cpp] view plain copy

1. package cn.edu.hust.scala
2. object TupleDemo {
3. def main(args: Array[String]): Unit = {
4. //元組的聲明與初始化
5. val t=(1,"spark",2.0)
6. println(t)
7. //元祖的取值,元祖的下標是從1開始的
8. println(t._1)
9. //對偶元組
10. val t1=Array(("1",1),("a",2),("c",4))
11. //將元組轉化成map
12. println(t1.toMap)
13. val t2=Array("a","2",10)
14. val t3=Array(1,"spark",2.0);
15. //拉鏈操作
16. println(t2.zip(t3).toBuffer)
17. //
18. val t4=Array(2,5,"t",10)
19. //如果元素個數對稱那麼將會捨棄多餘的
20. println(t2.zip(t4).toBuffer)
21. }
22. }

Scala練習

在學習完Scala的函數和數據結構後，我們可以做這樣一個練習，這裡我們使用Scala來做一個簡單的WordCount例子。

[cpp] view plain copy

1. package cn.edu.hust.scala
2. object Test {
3. def main(args: Array[String]): Unit = {
4. val list=List("hello word li hao","ming hao wo ai ni ai hello word")
5. //將文本拿出後按照空格分離然後壓平
6. val words=list.map(_.split(" ")).toBuffer.flatten
7. println(words)
8. // 將每一個單詞統計為1映射成為map
9. val t=words.map((_,1))
10. println(t)
11. //按照元組分組
12. val x=t.groupBy(_._1)
13. // 取出key
14. val key=x.map(_._1)
15. //取出value
16. val value=x.map(_._2.size)
17. //拉鏈操作
18. val result=key.zip(value)
19. println(result)
20. //排序
21. var a=result
22. println(a)
23. }
24. }

推薦閱讀：