文章目錄

• Scala編程語言入門
• • Scala簡介
  • 搭建開發環境
  • • 安裝JDK
    • 安裝 Scala SDK
    • 安裝IDEA的scala插件
    • scala的REPL交互式解釋器
  • Scala語法基礎
  • • scala中聲明變量
    • scala中數據類型
    • scala中的條件表達式
    • scala中的塊表達式
    • 循環
    • • 1. for循環
      • 2. while循環
    • 方法和函數
    • • 1. 方法
      • 2. 函數
      • 3. 方法和函數的區別
      • 4. 方法轉換為函數
  • 數組、元組、映射
  • • 數組
    • • 1. 定長數組
      • 2. 變長數組
      • 3. 遍歷數組
      • 4. 數組常用操作
    • 元組
    • • 1. 定義元組
      • 2. 示例
      • 3. 訪問元組
    • 映射Map
    • • 1. 不可變Map
      • 2. 可變Map
      • 3. Map 基本操作
  • Set、List
  • • Set
    • • 1. 不可變 Set 集合
      • 2. 可變 Set 集合
    • List
    • List
    • • 1. 不可變列表
      • 2. 可變列表
      • 3. 列表操作

Scala編程語言入門

Scala簡介

• scala 是運行在 JVM 上的多范式編程語言，同時支持面向對象和函數式編程。
• 早期 scala 剛出現的時候，并沒有怎么引起重視，隨著 Spark 和 Kafka 這樣基于 scala 的大數據框架的興起，scala 逐步進入大數據開發者的眼簾。scala的主要優勢是它的表達性強。
• 官網地址：http://www.scala-lang.org

為什么要使用 Scala

• 開發大數據應用程序（Spark程序、Flink程序）
• 表達能力強，一行代碼抵得上Java多行，開發速度快
• 由于運行在JVM上，所以它兼容Java，可以訪問龐大的Java類庫，與Java框架進行互操作

搭建開發環境

• 學習如何編寫scala代碼之前，需要先安裝scala編譯器以及開發工具
• Java程序編譯執行流程

• Scala程序編譯執行流程

• scala程序運行需要依賴于Java類庫，必須要有**Java運行環境**，scala才能正確執行，要編譯運行scala程序需要
  • jdk ( jvm )
  • scala編譯器（scala SDK）

安裝JDK

• 安裝JDK 1.8 64位版本，并配置好環境變量

安裝 Scala SDK

• scala SDK是scala語言的編譯器，要開發scala程序，必須要先安裝SDK
• 訪問地址：https://www.scala-lang.org/download/2.11.8.html，根據自己電腦的實際情況下載對應的安裝包

• 下載好后，解壓縮并配置環境變量

$ vim ~/.bash_profile # Scala環境變量 export SCALA_HOME=/Volumes/D/tools/scala/scala-2.11.8 export PATH=$PATH:$SCALA_HOME/bin$ source ~/.bash_profile $ scala -version Scala code runner version 2.11.8 -- Copyright 2002-2016, LAMP/EPFL

安裝IDEA的scala插件

scala的REPL交互式解釋器

• Scala提供的最重要的一個工具是交互模式（REPL）。REPL是一個交互式解釋器，可以即時編譯、運行代碼并返回結果，方便前期做學習和測試
• REPL：R(read)、E(evaluate) 、P(print)、L(loop)

Scala語法基礎

scala中聲明變量

• 語法格式：

val/var 變量名稱:變量類型 = 初始值

• 其中：
  • val定義的是不可重新賦值的變量(值不可修改)
  • var定義的是可重新賦值的變量(值可以修改)
• 注意：
  • scala中聲明變量是變量名稱在前，變量類型在后，跟java是正好相反
  • scala的語句最后不需要添加分號

• 惰性變量：Scala中使用關鍵字lazy來定義惰性變量，實現延遲加載(懶加載)
• 惰性變量只能是不可變變量，并且只有在調用惰性變量時，才會去實例化這個變量。
• 語法格式：

lazy val 變量名 = 表達式

scala中數據類型

• scala中的類型絕大多數和Java類型對應

基礎類型類型說明

Byte	8位帶符號整數
Short	16位帶符號整數
Int	32位帶符號整數
Long	64位帶符號整數
Char	16位無符號Unicode字符
String	Char類型的序列（字符串）
Float	32位單精度浮點數
Double	64位雙精度浮點數
Boolean	true或false

• 注意下 scala類型與Java的區別

  • scala中所有的類型都使用大寫字母開頭，說明是它是“類”
  • 整形使用Int而不是Integer
  • scala中定義變量可以不寫類型，讓scala編譯器自動推斷

• Scala 類型層次結構

類型說明

Any	所有類型的父類，它有兩個子類AnyRef與AnyVal
AnyVal	所有數值類型的父類
AnyRef	所有對象類型（引用類型）的父類
Unit	表示空，Unit是AnyVal的子類，它只有一個的實例（），它類似于Java中的void，但scala要比Java更加面向對象
Null	Null是AnyRef的子類，也就是說它是所有引用類型的子類。它的實例是null, 可以將null賦值給任何對象類型
Nothing	所有類型的子類不能直接創建該類型實例，某個方法拋出異常時，返回的就是Nothing類型，因為Nothing是所有類的子類，那么它可以賦值為任何類型

scala中的條件表達式

• scala條件表達式的語法和Java類似

scala中的塊表達式

• 定義變量時用 {} 包含一系列表達式，其中塊的最后一個表達式的值就是塊的值。
• 在scala解釋器中先輸入 :paste ,然后寫多行代碼, 之后按=ctrl+d結束輸入

val x = 0 val result = {val y = x + 10val z = y + "-hello"val m = z + "-scala""over" } // result的值就是塊表達式的結果 // 后期一個方法的返回值不需要加上return,把要返回的結果放在方法的最后一行就可以了

循環

• 在scala中，可以使用for和while，但一般推薦使用for表達式，因為for表達式語法更簡潔

1. for循環

• 語法結構

for (i <- 表達式/數組/集合){//表達式 }

• 簡單 for 循環

scala> val nums = 1 to 10 nums: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)scala> for (i <- nums) println(i) 1 2 3 4 5 6 7 8 9 10

• 雙重 for 循環

scala> for (i <- 1 to 3; j <- 1 to 3) println(i * 10 + j) 11 12 13 21 22 23 31 32 33scala> :paste // Entering paste mode (ctrl-D to finish) // 雙重for循環打印99乘法表 for (i <- 1 to 9; j <- 1 to i) {print(i + "*" + j + "=" + i * j + "\t")if (i == j) println() }// Exiting paste mode, now interpreting.1*1=1 2*1=2 2*2=4 3*1=3 3*2=6 3*3=9 4*1=4 4*2=8 4*3=12 4*4=16 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81

• 守衛：在for表達式中可以添加if判斷語句，這個if判斷稱為守衛

// 語法結構 for(i <- 表達式/數組/集合 if 表達式) {// 表達式 } scala> for (i <- 1 to 10 if i > 5) println(i) 6 7 8 9 10

• for推導式：在for循環體中，以yield表達式開始，這類循環能構建出一個新的集合，我們把這類循環稱為推導式

// for表達式中以yield開始，該for表達式會構建出一個集合 val v = for (i <- 1 to 5) yield i * 10 v: scala.collection.immutable.IndexedSeq[Int] = Vector(10, 20, 30, 40, 50)

2. while循環

• scala中while循環和Java中是一致的

• 語法結構

while(返回值為布爾類型的表達式){//表達式 }

• 演示

scala> var x = 10 x: Int = 10scala> while (x > 5) { println(x); x -= 1 } 10 9 8 7 6

方法和函數

1. 方法

• 語法：

def methodName (參數名:參數類型, 參數名:參數類型) : [return type] = {// 方法體：一系列的代碼 }

• 說明：
  • 參數列表的參數類型不能省略
  • 返回值類型可以省略，由 scala 編譯器自動推斷
  • 返回值可以不寫 return，默認就是 {} 塊表達式的值
• 示例：

scala> def add(a: Int, b: Int) = a + b add: (a: Int, b: Int)Intscala> add(1, 2) res5: Int = 3

• 注意：
  • 如果定義遞歸方法，必須指定返回值類型，例如

// 錯誤定義 scala> def m1(x: Int) = {| if (x == 1) 1| else x * m1(x - 1)| } <console>:15: error: recursive method m1 needs result typeelse x * m1(x - 1)^ // 正確定義 scala> def m1(x: Int): Int = {| if (x == 1) 1| else x * m1(x - 1)| } m1: (x: Int)Intscala> m1(10) res0: Int = 3628800

• 方法的參數：
  • 默認參數：在定義方法時可以給參數定義一個默認值
  • 帶名參數：在調用方法時，可以指定參數的名稱來進行調用
  • 變長參數：如果方法的參數是不固定的，可以定義一個方法的參數是變長參數

// 默認參數 scala> def add(x: Int = 0, y: Int = 0) = x + y add: (x: Int, y: Int)Intscala> add(10) res1: Int = 10scala> add(10, 20) res2: Int = 30// 帶名參數 scala> def add(x: Int = 0, y: Int = 0) = x + y add: (x: Int, y: Int)Intscala> add(y = 1) res3: Int = 1// 變長參數 scala> def add(num: Int*) = num.sum add: (num: Int*)Intscala> add(1,2,3,4,5) res4: Int = 15

2. 函數

• 函數在scala中屬于頭等公民
  • 數字能做的事，函數也可以
  • 數字可以作為參數，所以函數也可以作為其他方法或函數的參數
  • 數字可以作為返回值，所以函數也可以作為其他方法或函數的返回值
  • 數字可以賦值給一個變量，所以函數也可以賦值給一個變量
• scala 支持函數式編程，將來編寫 Spark/Flink 程序中，會大量使用到函數
• 語法：

val 函數變量名 = (參數名:參數類型, 參數名:參數類型....) => 函數體 scala> val f1 = (x: Int, y: Int) => x + y f1: (Int, Int) => Int = <function2>scala> f1(1, 2) res5: Int = 3

• 注意：
  • 函數是一個對象（變量）
  • 類似于方法，函數也有輸入參數和返回值
  • 函數定義不需要使用 def 定義
  • 無需指定返回值類型
• 示例：

scala> val add = (x: Int, y: Int) => x + y add: (Int, Int) => Int = <function2>scala> add(1, 2) res6: Int = 3// 一個函數沒有賦予一個變量，則稱為匿名函數，在實際開發時，基本上都是使用匿名函數 scala> (x: Int, y: Int) => x + y res7: (Int, Int) => Int = <function2>

3. 方法和函數的區別

• 方法是隸屬于類或者對象的，在運行時，它是加載到 JVM 的方法區中

• 可以將函數對象賦值給一個變量，在運行時，它是加載到 JVM 的堆內存中

• 函數是一個對象，繼承自FunctionN，函數對象有apply，curried，toString，tupled這些方法，而方法則沒有。

4. 方法轉換為函數

• 有時候需要將方法轉換為函數，作為變量傳遞，就需要將方法轉換為函數
• 使用 _ 即可將方法轉換為函數
• 示例：

scala> def add(x: Int, y: Int) = x + y add: (x: Int, y: Int)Intscala> var a = add _ a: (Int, Int) => Int = <function2>

數組、元組、映射

數組

• scala中數組的概念是和Java類似，可以用數組來存放同類型的一組數據
• scala中，有兩種數組，一種是定長數組，另一種是變長數組

1. 定長數組

• 定長數組指的是數組的長度是不允許改變的，數組的元素是可以改變的
• 語法：

// 通過指定長度定義數組 val/var 變量名 = new Array[元素類型](數組長度)// 用元素直接初始化數組 val/var 變量名 = Array(元素1, 元素2, 元素3...)

• 注意
  • 在scala中，數組的泛型使用[]來指定
  • 使用()來獲取元素
• 示例：

scala> val a = new Array[Int](10) a: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)scala> a(0) res0: Int = 0scala> a(0) = 10scala> a res2: Array[Int] = Array(10, 0, 0, 0, 0, 0, 0, 0, 0, 0)scala> val b = Array("Hadoop", "Spark", "Hive") b: Array[String] = Array(Hadoop, Spark, Hive)scala> b(0) res3: String = Hadoopscala> b.length res4: Int = 3

2. 變長數組

• 變長數組指的是數組的長度是可變的，可以往數組中添加、刪除元素
• 創建變長數組，需要提前導入ArrayBuffer類

import scala.collection.mutable.ArrayBuffer// 創建空的ArrayBuffer變長數組 val/var a = ArrayBuffer[元素類型]() // 創建帶有初始元素的ArrayBuffer val/var a = ArrayBuffer(元素1，元素2，元素3....)

• 示例：

// 導入ArrayBuffer類型 scala> import scala.collection.mutable.ArrayBuffer import scala.collection.mutable.ArrayBuffer // 定義一個長度為0的整型變長數組 scala> val a = ArrayBuffer[Int]() a: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer() // 定義一個有初始元素的變長數組 scala> val b = ArrayBuffer("hadoop", "storm", "spark") b: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, storm, spark)

• 變長數組的增刪改操作

  • 使用+=添加元素

  • 使用-=刪除元素

  • 使用++=追加一個數組到變長數組

• 示例：

// 定義變長數組 scala> val a = ArrayBuffer("Hadoop", "Spark", "Flink") a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(Hadoop, Spark, Flink) // 追加一個元素 scala> a += "Flume" res0: a.type = ArrayBuffer(Hadoop, Spark, Flink, Flume) // 刪除一個元素 scala> a -= "Hadoop" res1: a.type = ArrayBuffer(Spark, Flink, Flume) // 追加一個數組 scala> a ++= Array("Hive", "Sqoop") res2: a.type = ArrayBuffer(Spark, Flink, Flume, Hive, Sqoop)

3. 遍歷數組

• 可以使用以下兩種方式來遍歷數組：

  • 使用for表達式 直接遍歷數組中的元素
  • 使用 索引 獲得數組中的元素

• 示例：

scala> for (i <- a) println(i) Spark Flink Flume Hive Sqoop //0 to n ——包含0，也包含n scala> for (i <- 0 to a.length - 1) println(a(i)) Spark Flink Flume Hive Sqoop //0 until n ——生成一系列的數字，包含0，不包含n scala> for (i <- 0 until a.length) println(a(i)) Spark Flink Flume Hive Sqoop

4. 數組常用操作

• scala中的數組封裝了豐富的計算操作，將來在對數據處理的時候，不需要我們自己再重新實現。

操作方法

求和	sum
求最大值	max
求最小值	min
排序	sorted

• 示例：

scala> val array = Array(1, 2, 3, 4, 5) array: Array[Int] = Array(1, 2, 3, 4, 5) // 求和 scala> array.sum res0: Int = 15 // 求最小值 scala> array.min res1: Int = 1 // 升序 scala> array.sorted res2: Array[Int] = Array(1, 2, 3, 4, 5) // 降序 scala> array.sorted.reverse res3: Array[Int] = Array(5, 4, 3, 2, 1)

元組

• 元組可以用來包含一組不同類型的值。例如：姓名，年齡，性別，出生年月。元組的元素是不可變 的。

1. 定義元組

// 使用括號來定義元組 val/var 元組變量名稱 = (元素1, 元素2, 元素3....) // 使用箭頭來定義元組（元組只有兩個元素） val/var 元組 = 元素1 -> 元素2

2. 示例

// 可以直接使用括號來定義一個元組 scala> val a = (1, "zhangsan", 20, "shenzhen") a: (Int, String, Int, String) = (1,zhangsan,20,shenzhen) // 使用箭頭來定義元素 scala> val b = 1 -> 2 b: (Int, Int) = (1,2)

3. 訪問元組

• 使用 _1、_2、_3....來訪問元組中的元素，元組的index從1開始，_1表示訪問第一個元素，依次類推
• 示例：

scala> val a = (1, "zhangsan", 20, "shenzhen") a: (Int, String, Int, String) = (1,zhangsan,20,shenzhen)scala> a._1 res0: Int = 1scala> a._2 res1: String = zhangsanscala> a._3 res2: Int = 20scala> a._4 res3: String = shenzhen // 不能修改元組中的值 scala> a._4 = "beijing" <console>:12: error: reassignment to vala._4 = "beijing"^

映射Map

• Map可以稱之為映射。它是由鍵值對組成的集合。scala當中的Map集合與java當中的Map類似，也是key，value對形式的。
• 在scala中，Map也分為不可變Map和可變 Map。

1. 不可變Map

• 定義語法：

val/var map = Map(鍵->值, 鍵->值, 鍵->值...) // 推薦這種寫法，可讀性更好 val/var map = Map((鍵, 值), (鍵, 值), (鍵, 值), (鍵, 值)...)

• 示例：

scala> val map1 = Map("zhangsan" -> 30, "lisi" -> 40) map1: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 40)scala> val map2 = Map(("zhangsan", 30), ("lisi", 40)) map2: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 40) // 根據key獲取value scala> map1("zhangsan") res4: Int = 30 // 獲取不存在的key，或報異常 scala> map1("zhangsan1") java.util.NoSuchElementException: key not found: zhangsan1at scala.collection.MapLike$class.default(MapLike.scala:228)at scala.collection.AbstractMap.default(Map.scala:59)at scala.collection.MapLike$class.apply(MapLike.scala:141)at scala.collection.AbstractMap.apply(Map.scala:59)... 32 elided

2. 可變Map

• 可變Map需要手動導入import scala.collection.mutable.Map，定義語法與不可變Map一致。
• 示例：

// 導包 scala> import scala.collection.mutable.Map import scala.collection.mutable.Map // 定義可變的 Map scala> val map3 = Map("zhangsan" -> 30, "lisi" -> 40) map3: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30) // 獲取zhangsan這個key對應的value scala> map3("zhangsan") res6: Int = 30 // 給zhangsan這個key重新賦值value scala> map3("zhangsan") = 50 // 顯示 map3 scala> map3 res8: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 50)

3. Map 基本操作

• 創建一個可變的Map

scala> val map = Map("zhangsan" -> 30, "lisi" -> 40) map: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30)

• 按照 key 獲取 value

scala> map("zhangsan") res9: Int = 30 // 獲取wangwu的年齡，如果wangwu不存在，則返回-1 比較友好，避免遇到不存在的key而報錯 scala> map.getOrElse("wangwu", -1) res10: Int = -1

• 修改 key 對應的 value

scala> map("lisi") = 50

• 添加 key-value 鍵值對

scala> map += ("wangwu" -> 35) res12: map.type = Map(lisi -> 50, zhangsan -> 30, wangwu -> 35)

• 刪除 key-value 鍵值對

scala> map -= "wangwu" res13: map.type = Map(lisi -> 50, zhangsan -> 30)

• 獲取所有 key 和所有 value

// 獲取所有的key scala> map.keys res14: Iterable[String] = Set(lisi, zhangsan) // 獲取所有的key scala> map.keySet res15: scala.collection.Set[String] = Set(lisi, zhangsan) // 獲取所有的value scala> map.values res16: Iterable[Int] = HashMap(50, 30)

• 遍歷 map

scala> for (k <- map.keys) println(k + " -> " + map(k)) lisi -> 50 zhangsan -> 30scala> for (kv <- map) println(kv._1 + " -> " + kv._2) lisi -> 50 zhangsan -> 30scala> for ((k, v) <- map) println(k + " -> " + v) lisi -> 50 zhangsan -> 30

Set、List

Set

• Set是代表沒有重復元素的集合，Set具備以下性質：
  • 元素不重復
  • 不保證插入順序
• scala中的set集合也分為兩種，一種是不可變集合，另一種是可變集合。

1. 不可變 Set 集合

• 語法：

//創建一個空的不可變集 val/var 變量名 = Set[類型]()//給定元素來創建一個不可變集 val/var 變量名 = Set[類型](元素1, 元素2, 元素3...)

• 示例：

// 創建set集合 scala> val s = Set(1, 1, 2, 3, 4, 4, 5) s: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4) // 獲取集合大小 scala> s.size res21: Int = 5 // 遍歷集合 scala> for (i <- s) println(i) 5 1 2 3 4 // 添加元素生成新的集合 scala> s + 6 res24: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4) // 刪除一個元素 scala> s - 1 res26: scala.collection.immutable.Set[Int] = Set(5, 2, 3, 4) // 刪除set集合中存在的元素 scala> s -- Set(2, 3) res27: scala.collection.immutable.Set[Int] = Set(5, 1, 4) // 求兩個集合的并集 scala> s ++ Set(6, 7, 8) res29: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4) // 求兩個集合的交集 scala> s & Set(3, 4, 5, 6) res31: scala.collection.immutable.Set[Int] = Set(5, 3, 4)// 注意：這里對不可變的set集合進行添加刪除等操作，對于該集合來說是沒有發生任何變化，這里是生成了新的集合，新的集合相比于原來的集合來說發生了變化。 scala> s res32: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

2. 可變 Set 集合

• 要使用可變集，必須要手動導入： import scala.collection.mutable.Set
• 示例：

// 導包 scala> import scala.collection.mutable.Set import scala.collection.mutable.Set // 定義可變的set集合 scala> val set = Set(1, 2, 3, 4, 5) set: scala.collection.mutable.Set[Int] = Set(1, 5, 2, 3, 4) // 添加單個元素 scala> set += 6 res33: set.type = Set(1, 5, 2, 6, 3, 4) // 添加多個元素 scala> set += (6, 7, 8, 9) res34: set.type = Set(9, 1, 5, 2, 6, 3, 7, 4, 8) // 添加一個set集合中的元素 scala> set ++= Set(10, 11) res35: set.type = Set(9, 1, 5, 2, 6, 3, 10, 7, 4, 11, 8) // 刪除一個元素 scala> set -= 11 res36: set.type = Set(9, 1, 5, 2, 6, 3, 10, 7, 4, 8) // 刪除多個元素 scala> set -= (9, 10) res37: set.type = Set(1, 5, 2, 6, 3, 7, 4, 8) // 刪除一個 set 子集 scala> set --= Set(7, 8) res38: set.type = Set(1, 5, 2, 6, 3, 4) // 移除remove方法 scala> set.remove(1) res39: Boolean = truescala> set res40: scala.collection.mutable.Set[Int] = Set(5, 2, 6, 3, 4)

List

List

• List是scala中最重要的、也是最常用的數據結構。List具備以下性質：
  • 可以保存重復的值
  • 有先后順序
• 在scala中，也有兩種列表，一種是不可變列表、另一種是可變列表

1. 不可變列表

• 不可變列表就是列表的元素、長度都是不可變的
• 語法：

val/var 變量名 = List(元素1, 元素2, 元素3...)//使用 Nil 創建一個不可變的空列表 val/var 變量名 = Nil//使用 :: 方法創建一個不可變列表 val/var 變量名 = 元素1 :: 元素2 :: Nil

• 示例：

// 創建一個不可變列表，存放以下幾個元素（1,2,3,4） scala> val list1 = List(1, 2, 3, 4) list1: List[Int] = List(1, 2, 3, 4) // 使用Nil創建一個不可變的空列表 scala> val list2 = Nil list2: scala.collection.immutable.Nil.type = List() // 使用 :: 方法創建列表，包含1、2、3三個元素 scala> val list3 = 1::2::3::Nil list3: List[Int] = List(1, 2, 3)

2. 可變列表

• 可變列表就是列表的元素、長度都是可變的。
• 要使用可變列表，先要導入 import scala.collection.mutable.ListBuffer
• 語法：

// 使用ListBuffer[元素類型]() 創建空的可變列表 val/var 變量名 = ListBuffer[Int]() // 使用ListBuffer(元素1, 元素2, 元素3...)創建可變列表，語法結構 val/var 變量名 = ListBuffer(元素1，元素2，元素3...)

• 示例：

// 導包 scala> import scala.collection.mutable.ListBuffer import scala.collection.mutable.ListBuffer // 定義一個空的可變列表 scala> val a = ListBuffer[Int]() a: scala.collection.mutable.ListBuffer[Int] = ListBuffer() // 定義一個有初始元素的可變列表 scala> val b = ListBuffer(1, 2, 3, 4) b: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)

3. 列表操作

// 定義一個可變的列表 scala> val list = ListBuffer(1, 2, 3, 4) list: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4) // 獲取第一個元素 scala> list(0) res41: Int = 1 scala> list.head res42: Int = 1 // 獲取除了第一個元素外其他元素組成的列表 scala> list.tail res43: scala.collection.mutable.ListBuffer[Int] = ListBuffer(2, 3, 4) // 添加單個元素 scala> list += 5 res44: list.type = ListBuffer(1, 2, 3, 4, 5) // 添加一個不可變的列表 scala> list ++= List(6, 7) res45: list.type = ListBuffer(1, 2, 3, 4, 5, 6, 7) // 添加一個可變的列表 scala> list ++= ListBuffer(8, 9) res46: list.type = ListBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9) // 刪除單個元素 scala> list -= 9 res47: list.type = ListBuffer(1, 2, 3, 4, 5, 6, 7, 8) // 刪除一個不可變的列表存在的元素 scala> list --= List(7, 8) res48: list.type = ListBuffer(1, 2, 3, 4, 5, 6) // 刪除一個可變的列表存在的元素 scala> list --= ListBuffer(5, 6) res49: list.type = ListBuffer(1, 2, 3, 4) // toList根據可變的列表生成一個不可變列表，原列表不變 scala> list.toList res50: List[Int] = List(1, 2, 3, 4) // toArray根據可變的列表生成一個新的不可變數組，原列表不變 scala> list.toArray res51: Array[Int] = Array(1, 2, 3, 4)

總結

以上是生活随笔為你收集整理的Scala编程语言入门（1）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。