大數據系列第三課：scala基礎

第一階段：Spark streaming、spark sql、kafka、spark內核原理（必須有一個大型項目經驗）；

第二階段：spark運行的各種環境，各種故障的解決，性能優化（精通spark內核、運行原理）；

第三階段：流處理、機器學習爲鰲頭，需要首先掌握前兩個階段的內容；

跟隨王家林老師的零基礎講解，注重動手實戰，成爲spark高數，笑傲大數據之林！

第一部分：學習筆記

  def main(args: Array[String]): Unit = {
    /**
     * 函數定義 def
     */
    def fun1(x : Int, y : Int) = x + y
    println(fun1(2, 7))
    /**
     * 將函數賦值給變量
     */
    def fun2(name : String,age : Int){
      println(name + " : " + age)
    }
    val fun2_v = fun2 _//函數原型 注意（空格 + _）
    fun2_v("Spark",10)
    /**
     * 匿名函數
     */
    val fun3 = (content : String) => println(content)
    fun3("Hadoop")
    /**
     * 高階函數之函數作爲參數
     */
    val hiScala = (name : String, age : Int) => println(name + " : " + age)
    def bigData(func : (String, Int) => Unit, name : String, age : Int){
      func(name, age)
    }
    bigData(hiScala, "Java", 20)

    def bogData(func : (String,String,Int) => Unit, name : String, sex : String, age : Int){
      func(name,sex,age)
    }

    val arr = Array(1,3,5,7,9,11)
    arr.map(item => item * 2) //函數作爲參數
    arr.map(item => println) //函數作爲參數
    /**
     * 高階函數之函數返回值爲函數
     * 1、高階函數具有類型推斷
     */
    def funcReturned(content : String) = (message : String) => println(content + " : " + message)
    val returned = funcReturned("Programming")
    returned("Python")
    
    /**
     * spark源碼中有很多這種函數
     */
    def spark(func : (String) => Unit, name : String){
      func(name)
    }
    //以下爲簡寫
    spark((name : String) => println(name), "Scala")
    spark((name) => println(name), "Scala")
    spark(name => println(name), "Scala")
    spark(println, "Scala")
    spark(println _, "Scala")
    spark(println(_), "Scala")
    /**
     * 函數操作集合
     */
    val array = Array(1,3,5,7,9,11)
    array.map(2*_).foreach(println(_))
    array.map(2*_).foreach(println _)
    array.map(2*_).foreach(println)
    
    array.map(2*_).filter(_ > 10).foreach(println)
    
    /**
     * 閉包  函數的變量超出Scala作用域，內部變量依舊還可以訪問
     * 閉包原理scala內部生成了一個對象來記錄成員供外部訪問
     */
    def scala(content : String) = (message : String) =>println(content + " :" + message);
    val funcResult = scala("Spark")
    funcResult("Flink")
    
    /**
     * 柯里化函數
     */
    def sum(x : Int, y : Int) = x + y
    sum(1,2)
    def sum_Curring(x : Int) = (y : Int) => x + y
    sum_Curring(1)(2)
    
    def sum_Curring_Better(x : Int)(y : Int) = x + y
    println(sum_Curring_Better(1)(2))
    /**
     * 集合操作
     */
    val list = List("Scala","Spark","Filnk")
    list.map("The content is : " + _)
    list.map(println)
    val cal = list.map("The content is : " + _)
    cal.flatMap(_.split(" ")).foreach(print)
    
    //拉鍊操作
    list.zip(List(10,6,5))
    
    //reduce操作原理  先對第一個和第二個元素相加，結果再和第三個相加依次
    (1 to 100).reduceLeft(_+_)
    
    1 to 100 //Range immutable(不可變集合)
  }

第二部分：作業

import scala.io.Source  
import java.io.File
import scala.collection.mutable.ListBuffer  
object Task {
  
  //獲取目錄下的所有文件
  def subdirs(dir: File): Iterator[File] = {
    val d = dir.listFiles.filter(_.isDirectory)
		val f = dir.listFiles.toIterator
		f ++ d.toIterator.flatMap(subdirs _)
	 }
  
  def main(args: Array[String]): Unit = {
    
    val files = subdirs(new File("d:/data/"))
    //存儲所有行
    val list = new ListBuffer[String]
    //遍歷文件中的行
    for(file <- files){
      for(line <- Source.fromFile(file).getLines()){
        list += line
      }
    }
    val wordCount = list.flatMap(_.split(" ")).groupBy(key => key).map(item => (item._1, item._2.length)).foreach(println _)
  }
}

另一種實現

package org.rockyscala.course03

import java.io.File
import scala.io.Source
import scala.collection.mutable.Map

object Example {
  
  val map = Map.empty[String,Int]
  
  def scanDir(dir : File):Unit ={
    dir.listFiles().foreach{
      file => if(file.exists()){
        readFile(file)
        println(file)
      }
    }
  }
  def readFile(file : File):Unit ={
    for(line <- Source.fromFile(file).getLines()){
      count(line)
    }
  }
  
  def count(line : String) : Unit = {
    //for(word <- line.split("[,:.!\\s?*\\/-=+]()>< ")){
    for(word <- line.split("[ ]")){
      if(map.contains(word)){
        //map += (word -> (map(word)+1))
        map += (word -> (map(word) + 1))
      }else{
        map += (word -> 1)
      }
    }
  }
  
  def main(args: Array[String]): Unit = {
    scanDir(new File("D:/data/"))
    map.foreach(f => println(f))
  }
}