Scala學習筆記（一）編程基礎

阿新 • • 發佈：2017-05-07

大數據上一個 extends 移除 condition api arr 調用方法 tab

強烈推薦參考該課程：http://www.runoob.com/scala/scala-tutorial.html

1. Scala概述

1.1. 什麽是Scala

Scala是一種多範式的編程語言，其設計的初衷是要集成面向對象編程和函數式編程的各種特性。Scala運行於Java平臺（Java虛擬機），並兼容現有的Java程序。

技術分享

1.2. 為什麽要學Scala

1.優雅：這是框架設計師第一個要考慮的問題，框架的用戶是應用開發程序員，API是否優雅直接影響用戶體驗。

2.速度快：Scala語言表達能力強，一行代碼抵得上Java多行，開發速度快；Scala是靜態編譯的，所以和JRuby,Groovy比起來速度會快很多。

3.能融合到Hadoop生態圈：Hadoop現在是大數據事實標準，Spark並不是要取代Hadoop，而是要完善Hadoop生態。JVM語言大部分可能會想到Java，但Java做出來的API太醜，或者想實現一個優雅的API太費勁。

2. Scala編譯器安裝

2.1. 安裝JDK

因為Scala是運行在JVM平臺上的，所以安裝Scala之前要安裝JDK。

2.2. 安裝Scala

2.2.1. Windows安裝Scala編譯器

訪問Scala官網http://www.scala-lang.org/下載Scala編譯器安裝包，下載scala-2.12.2.msi後點擊下一步就可以了。

2.2.2. Linux安裝Scala編譯器

下載Scala地址http://downloads.typesafe.com/scala/2.12.2/scala-2.12.2.tgz，然後解壓Scala到指定目錄。

tar -zxvf scala-2.12.2.tgz -C /usr/java

配置環境變量，將scala加入到PATH中。

vi /etc/profile
export JAVA_HOME=/usr/java/jdk1.7.0_45
export PATH=$PATH:$JAVA_HOME/bin:/usr/java/scala-2.12.2/bin

2.2.3. Scala開發工具安裝

目前Scala的開發工具主要有兩種：Eclipse和IDEA，這兩個開發工具都有相應的Scala插件，如果使用Eclipse，直接到Scala官網下載即可http://scala-ide.org/download/sdk.html。

由於IDEA的Scala插件更優秀，大多數Scala程序員都選擇IDEA，可以到http://www.jetbrains.com/idea/download/下載社區免費版，點擊下一步安裝即可，安裝時如果有網絡可以選擇在線安裝Scala插件。這裏我們使用離線安裝Scala插件：

1.安裝IDEA，點擊下一步即可。由於我們離線安裝插件，所以點擊Skip All and Set Defaul

2.下載IEDA的scala插件，地址http://plugins.jetbrains.com/?idea_ce

技術分享

3.安裝Scala插件：Configure -> Plugins -> Install plugin from disk -> 選擇Scala插件 -> OK -> 重啟IDEA

技術分享

這裏下載插件，一定要對應好scala版本，否則報錯。建議參考：http://blog.csdn.net/a2011480169/article/details/52712421

3. Scala基礎

3.1. 聲明變量

package cn.itcast.scala


  object VariableDemo {

  def main(args: Array[String]) {

    //使用val定義的變量值是不可變的，相當於java裏用final修飾的變量

    val i = 1

    //使用var定義的變量是可變得，在Scala中鼓勵使用val

    var s = "hello"

    //Scala編譯器會自動推斷變量的類型，必要的時候可以指定類型
    //變量名在前，類型在後

    val str: String = "itcast"

  }

}

3.2. 常用類型

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

3.3. 條件表達式

Scala的的條件表達式比較簡潔，例如：

package cn.itcast.scala

  
  object ConditionDemo {

  def main(args: Array[String]) {

    val x = 1

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

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

    //打印y的值

    println(y)

  

    //支持混合類型表達式

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

    //打印z的值

    println(z)

  

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

    val m = if (x > 2) 1

    println(m)

  

    //在scala中每個表達式都有值，scala中有個Unit類，寫做(),相當於Java中的void

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

    println(n)

  

    //if和else if

    val k = if (x < 0) 0

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

    println(k)

  }

}

3.4. 塊表達式

package cn.itcast.scala

  

  object BlockExpressionDemo {

  def main(args: Array[String]) {

    val x = 0

    //在scala中{}中課包含一系列表達式，塊中最後一個表達式的值就是塊的值

    //下面就是一個塊表達式

    val result = {

      if (x < 0){

        -1

      } else if(x >= 1) {

        1

      } else {

        "error"

      }

    }

    //result的值就是塊表達式的結果

    println(result)

  }

}

3.5. 循環

在scala中有for循環和while循環，用for循環比較多

for循環語法結構：for (i <- 表達式/數組/集合)

package cn.itcast.scala

  
  object ForDemo {

  def main(args: Array[String]) {

    //for(i <- 表達式),表達式1 to 10返回一個Range（區間）
//每次循環將區間中的一個值賦給i

    for (i <- 1 to 10)

      println(i)

  

    //for(i <- 數組)

    val arr = Array("a", "b", "c")

    for (i <- arr)

      println(i)
//to是含首含尾，until是含首不含尾
for (i <- (0 until arr.length))

      println(arr(i))

  

    //高級for循環

    //每個生成器都可以帶一個條件，註意：if前面沒有分號

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

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

    println()

  

    //for推導式：如果for循環的循環體以yield開始，則該循環會構建出一個集合
    //每次叠代生成集合中的一個值

    val v = for (i <- 1 to 10) yield i * 10

      println(v)

  

  }

  

}

3.6. 調用方法和函數

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

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

a + b

是如下方法調用的簡寫：

a.+(b)

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

3.7. 定義方法和函數

3.7.1. 定義方法

技術分享

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

3.7.2. 定義函數

技術分享

兩種寫法：

Val func1 = (x:Int, y:Double) => (y, x)

Val func2 = (Int, Double) => (Double, Int) = {

(a, b)=>(b, a)

}

3.7.3. 方法和函數的區別

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

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

技術分享

package cn.itcast.scala



  object MethodAndFunctionDemo {

  //定義一個方法

  //方法m2參數要求是一個函數，函數的參數必須是兩個Int類型
  //返回值類型也是Int類型

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

    f(2, 6)

  }

  

  //定義一個函數f1，參數是兩個Int類型，返回值是一個Int類型

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

  //再定義一個函數f2

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

  

  //main方法

  def main(args: Array[String]) {

  

    //調用m1方法，並傳入f1函數

    val r1 = m1(f1)

    println(r1)

  

    //調用m1方法，並傳入f2函數

    val r2 = m1(f2)

    println(r2)

  }

}

3.7.4. 將方法轉換成函數（神奇的下劃線）

技術分享

4. 數組、映射、元組、集合

4.1. 數組

4.1.1. 定長數組和變長數組

package cn.itcast.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)

  

  }

}

4.1.2. 遍歷數組

1.增強for循環

2.好用的until會生成腳標，0 until 10 包含0不包含10

技術分享

package cn.itcast.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))

  }

}

4.1.3. 數組轉換

yield關鍵字將原始的數組進行轉換會產生一個新的數組，原始的數組不變。

技術分享

package cn.itcast.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)

  

  }

}

4.1.4. 數組常用算法

在Scala中，數組上的某些方法對數組進行相應的操作非常方便！

技術分享

Arr.sortBy(key)

Arr.sortWith(_>_):從大到小

Arr.sortWith(_<_):從小到大

Arr.sortWith((x,y)=>x>y):從大到小

Arr.sortWith((x,y)=>x<y):從小到大

4.2. 映射

在Scala中，把哈希表這種數據結構叫做映射。

4.2.1. 構建映射

技術分享

4.2.2. 獲取和修改映射中的值

技術分享

好用的getOrElse。

技術分享

註意：在Scala中，有兩種Map，一個是immutable包下的Map，該Map中的內容不可變；另一個是mutable包下的Map，該Map中的內容可變。

例子：

技術分享

註意：通常我們在創建一個集合是會用val這個關鍵字修飾一個變量（相當於java中的final），那麽就意味著該變量的引用不可變，該引用中的內容是不是可變，取決於這個引用指向的集合的類型。

4.3. 元組

映射是K/V對偶的集合，對偶是元組的最簡單形式，元組可以裝著多個不同類型的值。

4.3.1. 創建元組

技術分享

4.3.2. 獲取元組中的值

技術分享

4.3.3. 將對偶的集合轉換成映射

技術分享

4.3.4. 拉鏈操作

zip命令可以將多個值綁定在一起

技術分享

註意：如果兩個數組的元素個數不一致，拉鏈操作後生成的數組的長度為較小的那個數組的元素個數。

4.4. 集合

Scala的集合有三大類：序列Seq、集Set、映射Map，所有的集合都擴展自Iterable特質

在Scala中集合有可變（mutable）和不可變（immutable）兩種類型，immutable類型的集合初始化後就不能改變了（註意與val修飾的變量進行區別）。

4.4.1. 序列

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

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

9 :: List(5, 2) :: 操作符是將給定的頭和尾創建一個新的列表

註意：:: 操作符是右結合的，如9 :: 5 :: 2 :: Nil相當於 9 :: (5 :: (2 :: Nil))

package cn.itcast.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

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

    val lst8 = lst1 ++: lst0

  

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

    val lst9 = lst1.:::(lst0)

  

    println(lst9)

  }

}

可變的序列 import scala.collection.mutable._

package cn.itcast.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

  }

4.4.2. Set

不可變的Set。

package cn.itcast.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.itcast.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)

}

4.4.3. Map

package cn.itcast.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)

}

補充：實現單機版的WordCount。

val lines = List("hello tom hello jerry", "hello jerry", "hello kitty")
lines.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).mapValues(_.foldLeft(0)(_+_._2)).toList.sortBy(_._2).reverse
lines.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).map(t=>(t._1, t._2.size)).toList.sortBy(_._2).reverse

Scala學習筆記（一）編程基礎

大數據上一個 extends 移除 condition api arr 調用方法 tab 強烈推薦參考該課程：http://www.runoob.com/scala/scala-tutorial.html 1. Scala概述 1.1. 什麽是Scala Scala

Scala學習筆記（一）編程基礎

1. Scala概述

1.1. 什麽是Scala

1.2. 為什麽要學Scala

2. Scala編譯器安裝

2.1. 安裝JDK

2.2. 安裝Scala

2.2.1. Windows安裝Scala編譯器

2.2.2. Linux安裝Scala編譯器

2.2.3. Scala開發工具安裝

3. Scala基礎

3.1. 聲明變量

3.2. 常用類型

3.3. 條件表達式

3.4. 塊表達式

3.5. 循環

3.6. 調用方法和函數

3.7. 定義方法和函數

3.7.1. 定義方法

3.7.2. 定義函數

3.7.3. 方法和函數的區別

3.7.4. 將方法轉換成函數（神奇的下劃線）

4. 數組、映射、元組、集合

4.1. 數組

4.1.1. 定長數組和變長數組

4.1.2. 遍歷數組

4.1.3. 數組轉換

4.1.4. 數組常用算法

4.2. 映射

4.2.1. 構建映射

4.2.2. 獲取和修改映射中的值

4.3. 元組

4.3.1. 創建元組

4.3.2. 獲取元組中的值

4.3.3. 將對偶的集合轉換成映射

4.3.4. 拉鏈操作

4.4. 集合

4.4.1. 序列

4.4.2. Set

4.4.3. Map

補充：實現單機版的WordCount。

相關推薦