大数据系列第三课：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))
  }
}