scala基本語法和單詞統計

scala 基本語法

1.聲明變量

(1)val i = 1 使用val聲明的變量值是不可變的，至關於java裏final修飾的變量，推薦使用。
(2)var i = "hello" 使用var聲明的變量值是可變的
(3)val s = "hi" scala編譯器會自動推斷變量的類型，必要的時候能夠指定類型，變量名在前，類型在後

2.經常使用的類型

Scala和Java同樣，有7種數值類型Byte、Char、Short、Int、Long、Float和Double（無包裝類型）和一個Boolean類型

3.條件表達式

(1)if else
val s = if(x>1)1 else 2
(2)支持混合類型表達式
val s = if(x>1)1 else "Hello"
(3)在scala中每一個表達式都有值，scala中有個Unit類，寫做（），至關於java中的void
val n = if(x>2)1 else()
(4)if else if else
val s = if(x>1)1 else if(x=0)0 else -1

4.循環
（1）for循環
for(i <- 1 to 10)
println(i)

1 to 10 表達式1 to 10返回一個Range（區間）全部1到10之間的數值，println打印i的值

（2）高級for循環
for（i <- 1 to 3;j <-1 to 3 if i!=j）{
print(i+j)
}

先會循環i的值（i=1）在循環j的值，將j的值所有循環完畢後，再此循環i的值（i=2），在此循環j的全部的值

（3）for推導式：若是for循環的循環體以yield開始，則該循環會構建出一個集合
val v = for (i <- 1 to 10) yield i * 10
println(v)

5.調用方法和函數

Scala中的+ - * / %等操做符的做用與Java同樣，位操做符 & | ^ >> <<也同樣。只是有
一點特別的：這些操做符其實是方法。例如：
a + b
是以下方法調用的簡寫：
a.+(b)
a 方法 b能夠寫成 a.方法(b)

6.定義方法

def m（x: Int，y: Int）：Int{
x*y
}

def 定義方法的關鍵字
m 定義方法的名稱
x: Int，y: Int 定義方法的參數列表，兩個Int類型的參數
：Int 方法返回的參數類型
x*y 方法的具體執行內容，定義對參數x和y的操做

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

7.定義函數

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

8.將方法轉換成函數

val f2 = m _

9.定長數組

（1）初始化一個長度爲8的定長數組，其全部元素均爲0
val arr1 = new ArrayInt
（2）直接打印定長數組，內容爲數組的hashcode值
println(arr1)
（3）將數組轉換成數組緩衝，就能夠看到原數組中的內容了 ，toBuffer會將數組轉換長數組緩衝
println(arr1.toBuffer)
（4）若是不new，至關於調用了數組的apply方法，直接爲數組賦值
初始化一個長度爲1的定長數組
val arr = ArrayInt
（5）定義一個長度爲3的定長數組
val arr3 = Array("hadoop", "storm", "spark")
(6)使用()來訪問元素
println(arr3(2))

10.變長數組（數組緩衝）

(1)定義若是想使用數組緩衝，須要導入import scala.collection.mutable.ArrayBuffer包
val ab = ArrayBuffer[Int]()
(2)向數組緩衝的尾部追加一個元素
ab += 1
(3)追加多個元素
ab += (2, 3, 4, 5)
(4)追加一個數組++=
ab ++= Array(6, 7)
(5)追加一個數組緩衝
ab ++= ArrayBuffer(8,9)
(6)在數組某個位置插入元素用insert
ab.insert(0, -1, 0) 在數組0的位置前面插入-1和0
（7）刪除數組某個位置的元素用remove
ab.remove(3, 2) 移除數組3位置的後面兩個元素

11.循環數組

（1）用until會生成腳標，0 until 10 包含0不包含10
0 until 10
res6: scala.collection.immutable.Range = Range(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
（2）for循環
val arr = Array(1,2,3,4,5,6,7,8)
for(i <- arr)
println(i)
i接收arr循環過程當中的每個元素
（3）用until生產一個Range，使用reverse是將前面生成的Range反轉
for(i <- (0 until arr.length).reverse)
println(arr(i))

12.數組轉換

（1）val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
arr.map(_ *2)
轉換成爲一個新的數組，每一個元素乘以2，map是循環獲得每一個元素，_ 是對每一個循環中元素的匿名引用
（2）filter是過濾，接收一個返回值爲boolean的函數
val r = arr.filter(_ % 2 == 0)
過濾出全部的偶數

13.數組經常使用算法

(1)數組求和(arr爲自定義的一個數組)
arr.sum
(2)數組最大值
arr.max
(3)數組排序 （默認是正序）
arr.sorted

14.映射（java中的Map）
在Scala中，有兩種Map，一個是immutable包下的Map，該Map中的內容不可變；另外一個是mutable包下的Map，該Map中的內容可變

不可變map
(1)構建映射
用箭頭的方式構建Map
val m = Map("a" -> 11,"b" ->12 ,"c" -> 13)

用元組的方式構建Map
val m = Map(("a",11),("b",12),("c",13))
(2)獲取映射中的值
m("a")
(3)getOrElse
當m("e")的時候由於e這個key不存在因此會報錯，使用m.getOrElse("e",0)當e不存在時返回默認值0

可變map
（1）構建
import scala.collection.mutable.Map
val m1 = Map("a" -> 111,"b" ->112 )

val修飾是不可變的，不可變的是對Map的引用，Map中打的元素是能夠改變的
（2）修改map中的內容
m1("a")=88
(3)用+=號向原來的map中追加元素
m1+=("c" ->55)

15.元組
定義元祖時用小括號將多個元素包起來，元素之間用逗號分隔，元素類型能夠不同，元素類型能夠任意多個

（1）定義元組
val y = ("a",3.14,111)
(2)獲取元組中的值
val r = y._1
r="a"
獲取元組中的值使用下劃線加角標（_1）元組中的元素角標是從1開始的

（3）將對偶的集合轉換成爲映射
val arr = Array(("a",88),("b",66))
arr.toMap

Array(("a",88),("b",66))位對偶的集合
toMap能夠把對偶的集合轉換成爲映射

（4）拉鍊操做
val names = Array("a","b","c")
val s = Array(1,2,3)
val ns = names.zip(s)
ns: Array[(String, Int)] = Array((a,1), (b,2), (c,3))

將names的每個元素和s中的每個元素組成元組放入到Array中

16.集合

(1)建立一個不可變的集合
val lst1 = List(1,2,3)
(2)將0插入到lst1的前面生成一個新的List
val lst2 = 0 :: lst1

:: 操做符是將給定的頭和尾建立一個新的列表
注意：:: 操做符是右結合的，如9 :: 5 :: 2 :: Nil至關於 9 :: (5 :: (2 :: Nil))

(3)將一個元素添加到lst1的後面產生一個新的集合
val lst6 = lst1 :+ 3
(4)將2個list合併成一個新的List
val lst7 = lst1 ++ lst6
(5)將lst0插入到lst1前面生成一個新的集合
val lst9 = lst1.:::(lst0)

可變的序列
(1)構建一個可變列表，初始有3個元素1,2,3
val lst0 = ListBuffer[Int](1,2,3)
(2)向lst1中追加元素，注意：沒有生成新的集合
lst1 += 4
lst1.append(5)
(3)將lst1中的元素最近到lst0中， 注意：沒有生成新的集合
lst0 ++= lst1

17.Set

不可變的Set
(1)定義set
import scala.collection.immutable.HashSet
val set1 = new HashSet[Int]()
（2）將元素和set1合併生成一個新的set，原有set不變
val set2 = set1 + 4

可變的Set
(1)建立一個可變的HashSet
import scala.collection.mutable
val set1 = new mutable.HashSet[Int]()
(2)向HashSet中添加元素
set1 += 2
//add等價於+=
set1.add(4)
set1 ++= Set(1,3,5)

(3)刪除一個元素
set1 -= 5
set1.remove(2)

18.Map

(1)建立一個map
import scala.collection.mutable
val map1 = new mutable.HashMap[String, Int]()
(2)向map中添加數據
map1("spark") = 1
(3)從map中移除元素
map1.remove("spark")

19.單詞統計

val lines = List("hello tom hello jerry", "hello jerry", "hello kitty")

實現1：

lines.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).mapValues(_.foldLeft(0)(_+_._2))

分析：

（1）lines.flatMap(_.split(" ")) 將集合中的單詞進行壓平，其中每一個元素經過" "來切分

lines.flatMap(_.split(" "))後爲
res17: List[String] = List(hello, tom, hello, jerry, hello, jerry, hello, kitty)

（2）lines.flatMap(_.split(" ")).map((_, 1))統計每個單詞出現的次數，出現一次計數1
執行後爲
res18: List[(String, Int)] = List((hello,1), (tom,1), (hello,1), (jerry,1), (hel
lo,1), (jerry,1), (hello,1), (kitty,1))

（3）.groupBy(_._1)將集合進行分組，分組是按照集合中每個元組如（hello，1）的第一個單詞（_._1）進行分組

分組後爲一個map：

res19: scala.collection.immutable.Map[String,List[(String, Int)]] = Map(tom -> L
ist((tom,1)), kitty -> List((kitty,1)), jerry -> List((jerry,1), (jerry,1)), hel
lo -> List((hello,1), (hello,1), (hello,1), (hello,1)))

（4）.mapValues(_.foldLeft(0)(_+_._2)) 獲取map中的全部values如 List((tom,1))，foldLeft進行統計，(0)初始化參數爲0，_+_._2進行求和，第一個_在循環時可能爲初始化參數和進行求和後的值

執行後爲：
res20: scala.collection.immutable.Map[String,Int] = Map(tom -> 1, kitty -> 1, je
rry -> 2, hello -> 4)

實現2：

lines.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).map(t=>(t._1, t._2.size)).toList.sortBy(_._2).reverse