數組
一、定長數組和變長數組
package cn.gec.scala
import scala.collection.mutable.ArrayBuffer
object ArrayDemo {
def main(args: Array[String]) {
//初始化一個長度爲8的定長數組，其全部元素均爲0
val arr1 = new Array[Int](8)
//直接打印定長數組，內容爲數組的hashcode值
println(arr1)
//將數組轉換成數組緩衝，就能夠看到原數組中的內容了
//toBuffer會將數組轉換長數組緩衝
println(arr1.toBuffer)
//注意：若是new，至關於調用了數組的apply方法，直接爲數組賦值
//初始化一個長度爲1的定長數組
val arr2 = Array[Int](10)
println(arr2.toBuffer)
//定義一個長度爲3的定長數組
val arr3 = Array("hadoop", "storm", "spark")
//使用()來訪問元素
println(arr3(2))
//////////////////////////////////////////////////
//變長數組（數組緩衝）
//若是想使用數組緩衝，須要導入import scala.collection.mutable.ArrayBuffer包
val ab = ArrayBuffer[Int]()
//向數組緩衝的尾部追加一個元素
//+=尾部追加元素
ab += 1
//追加多個元素
ab += (2, 3, 4, 5)
//追加一個數組++=
ab ++= Array(6, 7)
//追加一個數組緩衝
ab ++= ArrayBuffer(8,9)
//打印數組緩衝ab
//在數組某個位置插入元素用insert
ab.insert(0, -1, 0)
//刪除數組某個位置的元素用remove
ab.remove(8, 2)
println(ab)
}
} |
二、遍歷數組
1.加強for循環java
2.好用的until會生成腳標，0 until 10 包含0不包含10python
package cn.gec.scala
object ForArrayDemo {
def main(args: Array[String]) {
//初始化一個數組
val arr = Array(1,2,3,4,5,6,7,8)
//加強for循環
for(i <- arr)
println(i)
//好用的until會生成一個Range
//reverse是將前面生成的Range反轉
for(i <- (0 until arr.length).reverse)
println(arr(i))
}
} |
3.數組轉換
yield關鍵字將原始的數組進行轉換會產生一個新的數組，原始的數組不變算法
package cn.gec.scala
object ArrayYieldDemo {
def main(args: Array[String]) {
//定義一個數組
val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
//將偶數取出乘以10後再生成一個新的數組
val res = for (e <- arr if e % 2 == 0) yield e * 10
println(res.toBuffer)
//更高級的寫法,用着更爽
//filter是過濾，接收一個返回值爲boolean的函數
//map至關於將數組中的每個元素取出來，應用傳進去的函數
val r = arr.filter(_ % 2 == 0).map(_ * 10)
println(r.toBuffer)
}
} |
四、數組經常使用算法
在Scala中，數組上的某些方法對數組進行相應的操做很是方便！數組
映射
在Scala中，把哈希表這種數據結構叫作映射數據結構
一、構建映射
二、獲取和修改映射中的值
好用的getOrElseapp
注意：在Scala中，有兩種Map，一個是immutable包下的Map，該Map中的內容不可變；另外一個是mutable包下的Map，該Map中的內容可變函數
例子：oop
注意：一般咱們在建立一個集合是會用val這個關鍵字修飾一個變量（至關於java中的final），那麼就意味着該變量的引用不可變，該引用中的內容是否是可變，取決於這個引用指向的集合的類型spa
元組
映射是K/V對偶的集合，對偶是元組的最簡單形式，元組能夠裝着多個不一樣類型的值。scala
一、建立元組
二、獲取元組中的值
三、將對偶的集合轉換成映射
四、拉鍊操做
zip命令能夠將多個值綁定在一塊兒
注意：若是兩個數組的元素個數不一致，拉鍊操做後生成的數組的長度爲較小的那個數組的元素個數
集合
Scala的集合有三大類：序列Seq、集Set、映射Map，全部的集合都擴展自Iterable特質
在Scala中集合有可變（mutable）和不可變（immutable）兩種類型，immutable類型的集合初始化後就不能改變了（注意與val修飾的變量進行區別）
一、序列
不可變的序列 import scala.collection.immutable._
在Scala中列表要麼爲空（Nil表示空列表）要麼是一個head元素加上一個tail列表。
9 :: List(5, 2) :: 操做符是將給定的頭和尾建立一個新的列表
注意：:: 操做符是右結合的，如9 :: 5 :: 2 :: Nil至關於 9 :: (5 :: (2 :: Nil))
package cn.gec.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
val lst0 = List(4,5,6)
//將2個list合併成一個新的List
val lst7 = lst1 ++ lst0
//將lst0插入到lst1前面生成一個新的集合
val lst8 = lst1 ++: lst0
//將lst0插入到lst1前面生成一個新的集合
val lst9 = lst1.:::(lst0)
println(lst9)
}
} |
可變的序列 import scala.collection.mutable._
package cn.gec.collect
import scala.collection.mutable.ListBuffer
object MutListDemo extends App{
//構建一個可變列表，初始有3個元素1,2,3
val lst0 = ListBuffer[Int](1,2,3)
//建立一個空的可變列表
val lst1 = new ListBuffer[Int]
//向lst1中追加元素，注意：沒有生成新的集合
lst1 += 4
lst1.append(5)
//將lst1中的元素最近到lst0中， 注意：沒有生成新的集合
lst0 ++= lst1
//將lst0和lst1合併成一個新的ListBuffer 注意：生成了一個集合
val lst2= lst0 ++ lst1
//將元素追加到lst0的後面生成一個新的集合
val lst3 = lst0 :+ 5
} |
Set
不可變的Set
package cn.gec.collect
import scala.collection.immutable.HashSet
object ImmutSetDemo extends App{
val set1 = new HashSet[Int]()
//將元素和set1合併生成一個新的set，原有set不變
val set2 = set1 + 4
//set中元素不能重複
val set3 = set1 ++ Set(5, 6, 7)
val set0 = Set(1,3,4) ++ set1
println(set0.getClass)
} |
可變的Set
package cn.gec.collect
import scala.collection.mutable
object MutSetDemo extends App{
//建立一個可變的HashSet
val set1 = new mutable.HashSet[Int]()
//向HashSet中添加元素
set1 += 2
//add等價於+=
set1.add(4)
set1 ++= Set(1,3,5)
println(set1)
//刪除一個元素
set1 -= 5
set1.remove(2)
println(set1)
} |
Map
package cn.gec.collect
import scala.collection.mutable
object MutMapDemo extends App{
val map1 = new mutable.HashMap[String, Int]()
//向map中添加數據
map1("spark") = 1
map1 += (("hadoop", 2))
map1.put("storm", 3)
println(map1)
//從map中移除元素
map1 -= "spark"
map1.remove("hadoop")
println(map1)
} |
Scala寫wordcount程序
val lines = List("hello java hello python","hello scala","hello scala hello java hello scala")
// 切分並壓平
val words = lines.flatMap(_.split(" "))
// 把每一個單詞生成一個一個的pair
val tuples = words.map((_,1))
// 以key(單詞)進行分組
val grouped = tuples.groupBy(_._1)
// 統計value長度
val sumed = grouped.mapValues(_.size)
// 排序
val sorted = sumed.toList.sortBy(_._2)
// 降序排列
val result = sorted.reverse
println(result)
lines.map(x=>x.split(" ")).flatten.map((_,1)).groupBy(_ _1).mapValues(t=>t.size)
lines.map(_.split(" ")).flatten.map((_,1)).groupBy(_ _1).mapValues(_.size).toList.sortBy(_ _2).reverse
具體過程以下：