第一阶段: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))
}
}