Scala 語言學習之語言基礎（2）
--------Scala 可以對數據類型進行自動推導，所以定義變量時可省去數據類型
==> 數據類型
--> 數值類型
--- Byte 8位
--- Short 16 位
--- Int 32 位
--- long 64位
--> 字符和字符串類型
--- Char
--> Unit 類型 相當於 Java 的 void
--> Nothing 類型 般表示運行過程中出現了 Exception
==> 定義變量
--> 格式： var | val 變量名：類型 = 內容
--> var 定義值可變的變量
var a = "hello" // var a:String = "hello" var b = 12345 // var b: Int = 12345
--> val 定義值不可變的常量
val a = "word"
==> 函數
--> 格式： def 函數名（變量名：類型 | 變量名：=> 類型）: 函數返回值類型 = {}
--> 函數參數：
--- call by value : def demo(x:Int, y: Int): Int = x + x 對函數的實參求值
demo(3+4, 8)
計算過程：
7 + （3+4）
7 + 7
14
--- call by name : def demo(x: => Int, y: => Int): Int = x + x 函數的實參每次在函數體內部被調用的時候都會求值
demo(3+4, 8)
計算過程：
7 + 7
14
--- 默認參數： def func1(name: String = "Tom"): String = "Hello" + name
--- 代名參數 :
def func2(str: String="My name", name: String="Marry", age: Int=18): String = {
str + " is " + name + ", I'm " + age + "啦！"
}
func2(name="Tom")
func2()--- 可變參數 : 求多個數字的和
def sum(args: Int*) = {
var result = 0
for(arg <- args)
result += arg
result
}
sum(1, 2, 3)==> 懶值（lazy）: 如果一個變量是 lazy ， 他的初始化會被推遲，直到第一次使用它的時候才會執行
--> 正常的變量定義後會直接賦給變量，如:
var a = "hello"
定義變量後會返回： a : String = "hello"
--> 使用 lazy 定義變量時，不會執行，只有在第一次執行的時候才會執行賦值操作，如：
lazy var a = "hello"
定義變量後返回： a: String = <lazy>
只有使用變量時，才會進行賦值操作：
a
String = "hello"
==> 異常: 異常的處理機制是什麽？ 向上處理
-->采用 try{ …… }catch{ …… }finally{……} 捕獲和處理異常
try{
val words = scala.io.Source.fromFile("d:\\demo\\a.txt").mkString
}catch{
case ex:java.io.FileNotFoundException => {
println("File Not Found!!!")
}
case ex: IllegalArgumentException => {
println("Illegal Argument Exception!!!")
}
case _:Exception => {
println("othe Exception")
}
}finally{
println("finally block")
}--> 如果一個函數的返回類型是Nothing， 表示在函數執行過程中產生異常
def func1() = throw new IllegalArgumentException("Some Error Happened")--> if else 語句，如果在一個分支中產生了異常，則另一個分支的返回值，將作為if else 返回值的類型
val x = 10
if(x >= 0){
scala.math.sqrt(x)
}else{
throw new IllegalArgumentException("The value should be not")
}==> 數組
--> 定長數組：使用關鍵字 Array
val a = new Array[Int](10)
val str = new Array[String](5)
val demo_list = Array("Tom", "Marry", "Mike")--> 變長數組：使用關鍵字 ArrayBuffer
val list1 = ArrayBuffer[Int]() // 向數組中插入元素 list1 += 1 list1 += 5 // 向數組中插入多個元素 list1 += (20, 55, 47) // 去掉最後三個值 list1.trimEnd(3) // 將 ArrayBuffer 轉換為 Array list1.toArray
--> 遍歷數組
// 創建數組
var names = Array("Tom","Marry","Linda")
// 使用 for 循環遍歷
for(name <- names)
println(name)
// 使用 foreach 遍歷
names.foreach(println)
// 對數組進行轉換，生成一個新的數組
val newnames = for{
name <- names
new = name.toUpperCase
}yeild(new) --> 數組常用操作
import scala.collection.mutable.ArrayBuffer val demoArray = Array(6,8,4,,5,2,6,5,4) // 最大值 demoArray.max // 最小值 demoArray.min // 求和 demoArray.sum // 定義一個變長數組 demoArrayBuffer = ArrayBuffer(5,3,5,7,8,7,9,5,74) // 降序排序 demoArrayBuffer.sortWith(_ > _) // 升序排序 demoArrayBuffer.sortWith(_ < _)
==> 映射： 一個由 key, value 組成的集合
--> 使用 -> 符號創建
val demoMap = Map("Tom" -> 11, "Marry" -> 44)--> 不可變 Map
val testMap = scala.collection.immutable.Map("Tom" -> 20, "Marry" -> 18)--> 可變 Map
val testMap = scala.collection.mutable.Map("Tom" -> 20, "Marry" -> 18)
val testMap1 = scala.collection.mutable.Map(("Tom", 20),("Marry", 18))--> 映射操作
// 獲取映射中的值，如果不存在，會拋出 Exception
testMap("Tom")
// 可通過 Map.constains 事先判斷數據是否存在，然後再取值
if(testMap.contains("Tom")){
testMap("Tom")
}else{
-1
}
// 簡寫
testMap.getOrElse("Tom", -1)
// 更新值
testMap("Tom") = 25
// 添加新元素
testMap += "lily" -> 18
// 移除元素
testMap -= "Tom"
// 叠代，使用 for，或者 foreach
for(m <- testMap)println(m)
testMap.foreach(println)==> 元組： 不同類型的值的聚集
--> 創建元組： val 名稱+個數 = （元素，元素）
val tu1 = (1, 2, 3)
val tu2 = new Tuple2("hello", "world") --> 訪問元組中的元素
tu1._1 //點後面跟的是第幾個元素 1
--> 遍歷元組,使用foreach 遍歷元組，註意，元組遍歷前首先需要生成對應的叠代器，不能直接使用for 或者 foreach 進行遍歷
tu1.productIterator.foreach(println)
Scala 語言學習之語言基礎（2）