Scala與Java的關係：
一：它們都是基於JVM的，但Scala可以呼叫Java的任何功能，比如Spark執行在Hadoop上，它可以呼叫Hadoop上的一切功能。
二：你可以認為Scala它是一個升級版的Java，因為Scala它本身是一門支援面向物件的語言，在Scala中，一切皆物件，它是一門純面向物件的語言，同時Scala也是面向物件以及函式式結合的語言。

大資料的開發語言是Scala，原因如下：
一：大資料的本身是計算資料，而Scala即有面向物件組織專案工程的能力，又有計算資料的功能。
二：現在大資料事實上的計算標準框架Spark，它是用Scala開發的，因為計算資料，Scala它是函數語言程式設計，它實現演算法非常簡潔優雅。
例：kafka，它是一個訊息中介軟體，如果外部資料要流進大資料中心，我們一般都要用kafka作介面卡，那如果大資料中心的資料流到外部，也是用kafka（如Spark計算的資料要交給HBASE或MySql,期間我們都會用kafka），很多的大資料元件都是用的Scala編寫的，SO，如果你想成為一個頂級的大資料開發高手，你一定要掌握Scala。

對Scala語法的基本操作：

Scala>2*3.5
Res0:Double=7.0 //可以自動得知型別
Res0.to //按Tab鍵可以出現提示
val age1,age2,age3=0 //1行多個變數申明，val是不可變變數
var age=0                     //var是可變變數
age=1  //重新賦值

0.to(5)   //To方法   結果為一個數據集合Range<0,1,2,3,4,5> 

min(20,4)    //函式的呼叫 求一個最小值

printf("%s is the future's Framwork ","Spark")  //輸出
readLine            //讀入
readLine(“ xxx”)
readInt
 

If 語句：

 val age=19
 val buffered=0
 if (age>18) "adult" else "child"
 val result=if (age>10){
   "adult"
    buffered=10
    buffered  //最後一行的值是整個程式碼塊的返回值
}

迴圈語句：

val element=10
for (i <- 0 to element if (i%3==0)) printf("%d",i) //新增判斷語句，是元素的判斷
for (i <- 0 to element) printf("%d",i)
Break用 法:      //需要匯入 scala.util.control.Breaks
   for (i <- 0 to 10){
      if (i==4) break
    println(i)
   }
 

函式定義：

val n=10
 def f1:Any={        //Any型別是因為返回的型別無法確定
   for (i<- 0 to 20){
     if (i==n) return 10
     println(i)
   }
 }  
 def f3(param1:String,param2:Int=20)=param1+param2
 f3("Spark")                    //函式呼叫
 f3(param2=100,param1="Scala")  //可以改變引數順序
 def sum(number:Int*)={       //求和，元素個數任意               
 sum(1,2,3,4,6)
 sum(1 to 100:_*)   //-*把每個元素都提取出來
 var result=0;
   for (element<-number) result +=element
   result
 }
 def morming(content:String) { }
def morming1(content:String):Unit=" " //過程，沒有返回值

lazy：如果一個變數宣告為lazy，表示這個變數只有在第一次使用時，才會發生計算，比如說開啟檔案，開啟資料庫，操作網路，如果將變數宣告為lazy，特別有用。

 lazy val content=fromFile("test.txt")   //匯入 scala.io.Source._

異常： //匯入 java.io.FileNotFoundException

 try{
   val content=fromFile("...").mkString
 }catch {
   case _:FileNotFoundException => println("can not find")
 }finally {
   println("Bye!!")
 }

陣列：

 val arr=new Array[Int](5)    //新建陣列包含5個元素
        arr(3)=4                       //改變第3個元素
 import scala.collection.mutable.ArrayBuffer
 val arrBuffer=ArrayBuffer[Int]()  //大小可以變的陣列
 arrBuffer+=10                     //新增元素
 arrBuffer++=Array(1,4,3,4)  
 arrBuffer.trimEnd(3)              //截掉後面3個元素
 arrBuffer.insert(5,2,3)           //在第5個元素後加入2，3
 arrBuffer.remove(6,3)             //從第6個元素開始移除3個
 val arr2=arrBuffer.toArray        
 arr2.toBuffer
 for (elem <- arr2) println(elem)
 for (i<-0 until(arr2.length,2)) println(arr(i))  //間隔輸出
 for (i<- (0 until arr2.length).reverse) println(arr(i))
 arr2.sum  //逆序輸出
 scala.util.Sorting.quickSort<arrBuffer>
 val arr3=for (i<-arr if (i%2==0)) yield  i*i
 arr.filter(_%3==0).map(i=>i*i)

Map:

  val person=Map("spark"->6,"hadoop"->11)
  val persons=scala.collection.mutable.Map("spark"->6,"hadoop"->11)
  persons += ("Filnk"->5)    //新增
  persons -= "Flink"         //刪除
 for ((key,value)<-person) println(key+":"+value)
 val person=scala.collection.immutable.SortedMap("spark"->6,"hadoop"->11)        //對Map排序
 val tuple("spark",6,99.9)   //元組 包含各種型別
 tuple._1                    //spark

task1:移除一個數組中第一個負數後的所有負數
思想：先找到第一個負數，進行標記，然後對後面出現的每一個負數進行計數，並統計後面負數出現的總數，每一個非負數移動負數個位數，這樣末尾刪除負數的統計總數，剩下就是滿足題意的

     val arr=Array(1,34,-6,23,-1,24,-12,-23,23,45,-4,-34,-36,19)
      var bool,num,tol=0
       for (i <- 0 until(arr.length,1)){
       if (bool==0 && arr(i)< 0) bool=1
       else if (bool==1){
         if (arr(i) < 0){
           num+=1
           tol+=1
         }else arr(i-num)=arr(i)
       }
      }
     val arr2=arr.toBuffer
     arr2.remove(arr.length-tol,tol)
     arr2.mkString(",")