Scala 基礎鞏固 1 scala概述：     scala是多正規化程式語言，具有面向物件和函數語言程式設計，它執行在JVM平臺，靜態編譯 優雅，速度快，能融入到hadoop生態圈 2 安裝：     JDK安裝(配置環境變數)     windows下解壓安裝包，配置環境變數     （檢查是否安裝成功：cmd scala） 3 入門簡單案例：     object HelloScala{         def main(args:Array[String]){             println("Hello Scala")         }     }     編譯：scalac 檔名 ——> 執行：scala class檔名 一 scala 基礎     1 宣告變數：val a=1 val修飾變數不可變，相當於java中的final (編譯器自動推薦型別) 有利於gc                 var b=1 var修飾的變數可以改變它的值，可重新賦值                 val d:Int = 100 //可以有編譯器根據值進行推斷出型別，也可手動指出變數的型別                      2 常用型別：Scala和Java一樣，有7種數值型別Byte、Char、Short、Int、Long、Float、Double型別和1個Boolean型別。     3 條件表示式：(在定義一個變數的時候加上一些if else控制邏輯)         unit的例項物件 ()         val a=1         val b=if(a<0) -1 else 1         val b=if(a<0) -1 else "xyz"         val b=if(a<0) -1          val b=if(a<0) -1 else if (a==0) 0 else 100     4 塊表示式:          定義變數的時候後面用{} 其裡面包含多個表示式，其中最後一行表示式的值就是塊的值         val a=1         val result={             val b=a+1             val c=b+1             val d=c+1             d         }         scala方法中的返回值不需要return 直接把要返回的值放在最後一行返回就可     5 迴圈         for 和 while         for迴圈語法結構：for (i <- 表示式/陣列/集合) println(i)         for(i <- 1 to 10) println(i)         val abc=1 to 10         for(i <- abc) println(i)         雙重for迴圈         for(i<- 1 to 3: j<- 1 to 3 if i!=j) println(i*j)         for(i <- 1 to 10) yield i*10         擴充套件：九九乘法表         for(i <- 1 to 9){         for(j <- 1 to i){         print(i+"*"+j+"="+i*j+"\t")         if(i==j){         println()         }         }         }         while 迴圈         while(boolean型別表示式)         var a =0         while(a<10){         println(a)         a =a+1 // 若 a 為val修飾，此行會報錯          }     6 定義方法和函式         定義方法：             def m1(x:Int,y:Int):Int=x+y             m1(1,2)             簡化：def m2(x:Int,y:Int)=x+y // 根據方法體值的型別進行推斷                     m2(1,2)             遞迴：必須指定返回值型別             def m1(x:Int):Int={             if(x==1) 1             else x*m1(x-1)             }         定義函式：             (x:Int,y:Int) => x+y             val f1 = (x:Int,y:Int) => x+y             f1(1,2)                      方法和函式的區別:             函式是一個物件，繼承自FunctionN (N表示引數的個數)，具備該物件中的一些方法 apply   curried   toString   tupled             方法就是物件中的方法，不具備函式的這種特性                          方法轉函式                 val 函式=方法名 _                 def m1(f:(Int,Int) => Int)=f(1,2)                 val f1  二 陣列     1 定義定長陣列         val arr = new Array[Int](5)         val arr1 = Array(1,2,3,4,5)         // 獲取陣列中的元素 用小括號()         arr1(0)     2 定義變長陣列         導包：import scala.collection.mutable.ArrayBuffer         val arr=ArrayBuffer[Int]()         增：arr += 1             arr ++= Array(5,6)             arr ++= ArrayBuffer(7,8,9)             arr.insert(0,-3,-2,-1)//在陣列某個位置插入元素用insert，從0下標插入         刪：arr -= 1             arr --= Array(5,6)             arr --= ArrayBuffer(7,8)             arr.remove(0) // 按照下標來刪除         改：arr(0)=100         查：arr(0)     3 遍歷陣列：         val arr = Array(1,2,3,4,5,6)         for(i <- arr) println(i)         for(i <- 0 util arr.length) println(arr(i))         for(i <- (0 util arr.length).reverse) println(arr(i)) // 反向遍歷     4 陣列轉換：         var arr = Array(1,2,3,4,5,6,7,8,9,10)         for(i <- arr if i%2==0) println(i)         for(i <- arr if i%2==0) yield i*10         //filter 過濾，接收一個返回值為boolean的函式         arr.filter((x:Int)=>x%2==0)         arr.filter(_%2==0)         // map 相當於將陣列中的每一個元素取出來，應用傳進去的函式         arr.filter(_%2==0).map(_*10) //面向函式程式設計 _表示陣列中的每一個元素類似於java中的*         arr.sum 求和         arr.max 求最大值         arr.sorted 排序預設從小到大     5 對映：（map集合）         在Scala中把雜湊表這種資料結構叫做對映         1 定義不可變的map             val map = Map("zhangsan" -> 20,"lisi" -> 30)             val map1 = Map(("zhangsan",20),("lisi",30))         2 定義可變的map             導包：import scala.collection.mutable.Map             val hmap = HashMap(("zhangsan",30))                          增：hamp +=("wangwu" -> 30)             刪：hmap -=("wangwu")                 hmap.remove("lisi")             改: hmap("zhangsan")=100                 hmap("zhangdan" ->50)             查：hmap("zhangsan")                 hmap.getOrElse("lisi",100) // 有就獲取沒有就用預設值                              val表示該map在記憶體中的地址不變，但宣告的map中的內容是否可變要看包的型別     6 元組：（就是把很多不同型別的值聚集在一起）         1 定義元組             對映是K/V對偶的集合，對偶是元組的最簡單形式，元組可以裝著多個不同型別的值，使用小括號()             val tuple =("xyz",3.14,100)             獲取元組中的值：tuple._1                      val array=Array(("zhangsan",30),("lisi",20))             array.toMap // 將對偶的集合轉換為對映             拉鍊操作：                 val names=Array("zhangsan","lisi")                 val ages=Array(30,40)                 names.zip(ages)                 // 若兩個陣列的元素個數不一致，可使用zipAll用預設的元素進行填充                 names.zipAll(ages,"zhaoliu",50)     7 集合：     Scala集合有三大類：序列Seq、Set、對映Map，所有的集合都擴充套件自Iterable特質，在Scala中集合有可變（mutable）和不可變（immutable）兩種型別，immutable型別的集合初始化後就不能改變了（注意與val修飾的變數進行區別）。         List             (1)不可變的序列 import scala.collection.immutable._             操作符：             val list=List(1,23,4,5)             list.head // 1             list.tail // 23,4,5             val list=1::Nil // List(1)             1::2::3::Nil // List(1,2,3)                          list.:+(2) // List(1, 2)             list.++(List(2,3)) //List(1, 2,3)             list.:::(List(3,4)) //List(3, 4, 1) 在列表的頭部新增另一個列表 生成新的集合             （2）可變的序列,導包：import scala.collection.mutable.ListBuffer             val list=ListBuffer[Int]()             // 新增元素             list +=2             list.append(3)             list ++=List(3,4,5) // 不可變的新增到可變的裡面去             list ++=ListBuffer(6,7,8)                          list.toList //可變的轉化為不可變的集合             list.toArray //可變list轉變陣列                          list.sorted sortWith sortBy // 排序             list.grouped(4)             list.grouped(4).toList // List(ListBuffer(1, 2, 3, 4),ListBuffer(5, 6, 7, 8))             list.grouped(4).toList.flatten //List(1, 2, 3, 4, 5, 6, 7, 8)                          list.map(x=>x.split(" "))             list.map(x=>x.split(" ")).flatten             list.flatMap(_.split(" "))                          list.sum             list.par.sum // 並行求和             list.reduce(_+_) // 第一個下劃線acc 第二個下劃線是依次從集合中取出的元素                          list.reduceLeft()             list.reduceRight()                          val list =List(1,2,3,4)             list.reduce((x,y)=>x+y)                          list.fold(100)((x,y)=>x+y) // 摺疊 有初始值             list.fold(100)(_+_)                          list10.pat.aggregate(10)(_+_.sum,_+_)                          並集：l1.union(l2)             交集：l1.intersect(l2)             差集：l1.diff(l2)                          list.reduceRight((x,y)=>x-y)     Set:         1 不可變的set集合             val set = Set(2,3)             set.sum             set.max             set.min             set + 4 // 生成一個新的集合，自身沒有改變             set1 & set2 // 交             set1 ++ set2 // 合併                          set1.subsets(3).toSet // 排列組合             set1.subsets(3).foreach(s => println(s)) // 先排列組合再遍歷                      2 可變的set集合import scala.collection.mutable.HashSet             val hset = HashSet[Int]()             增：hset += 2                 hset.add(5)                 hset ++= Set(3,4)             刪：hset -=1                 hset.remove(2)                 hset --=Set(3,4,5)     Map：         1 不可變的Map             val map=Map(("zhangsan",30),("lisi",20))             map("lisi")             map.getOrElse("lisi",50)             map.keySet             for(k <- map.keys) println(k+"->"+map(k))             for((k,v) <- map) println(k+"->"+v)             map.foreach{case (k,v) => println(k+"->"+v)}