Spark初识

Spark的背景、定义、特点

• 背景
  • MapReduce框架局限性
    • 仅支持Map和Reduce两种操作，提供给用户的只有这两种操作
    • 编程复杂度略高，学习和使用成本略高。
    • 处理效率低效
      • Map中间结果写磁盘，Reduce写HDFS，多个MR之间通过HDFS交换数据
      • 任务调度和启动开销大
    • 在机器学习、图计算等方面支持有限，性能效率表现比较差。
      • mapreduce的机器学习框架，称为mahout。

• 定义
  • 专为大规模数据处理而设计的快速通用的计算引擎，并形成一个高速发展应用广泛的生态系统。
• 特点
  • 速度快
    • 内存计算下，Spark 比 Hadoop 快100倍
  • 易用性
    • 80多个高级运算符
    • 跨语言：使用Java，Scala，Python，R和SQL快速编写应用程序。
  • 通用性
    • Spark 提供了大量的库，包括SQL、DataFrames、MLib、GraphX、Spark Streaming。
    • 开发者可以在同一个应用程序中无缝组合使用这些库。
• 支持多种资源管理器
  • Spark 支持 Hadoop YARN，Apache Mesos，及其自带的独立集群管理器
• 生态组件丰富与成熟
  • spark streaming:实时数据处理
  • shark/sparkSQL:用sql语句操作spark引擎
  • sparkR:用R语言操作Spark
  • mlib:机器学习算法库
  • graphx:图计算组件

在hadoop生态圈中位置

spark生态圈

• Spark Core：包含Spark的基本功能；尤其是定义RDD(弹性分布式数据集，resilient distributed dataset)的API、操作以及这两者上的动作。其他Spark的库都是构建在RDD和Spark Core之上的
• Spark SQL：提供通过Apache Hive的SQL变体Hive查询语言（HiveQL）与Spark进行交互的API。每个数据库表被当做一个RDD，Spark SQL查询被转换为Spark操作。
• Spark Streaming：对实时数据流进行处理和控制。Spark Streaming允许程序能够像普通RDD一样处理实时数据
• MLib：一个常用机器学习算法库，算法被实现为对RDD的Spark操作。这个库包含可扩展的学习算法，比如分类、回归等需要对大量数据集进行迭代的操作。
• GraphX：控制图、并行图操作和计算的一组算法和工具的集合。GraphX扩展了RDD API，包含控制图、创建子图、访问路径上所有顶点的操作
• SparkR是一个提供从R中使用Spark的轻量级前端的R包。在Spark1.6以后，SparkR提供了分布式数据框架，它支持selection,filtering,aggregation等操作。也支持使用MLib分布式机器学习。

scala 介绍

语言介绍

多范式（multi-paradigm）的编程语言，设计初衷是要集成面向 对象编程和函数式编程的各种特性。

运行在 Java 虚拟机上，并兼容现有的 Java 程序。

源代码被编译成 Java 字节码文件，运行于 JVM 之上，并可以调用 现有的 Java 类库。

语言特点

面向对象特性

        一种纯面向对象的语言，每个值都是对象

函数式编程

        函数式语言，其函数也能当成值来使用。

        提供了轻量级的语法用以定义匿名函数，支持高阶函数， 允许嵌套多层函数，并支持柯里化。

静态类型

        具备类型系统，通过编译时检查，保证代码的安全性和一 致性。

        像 scala，java,c/c++,c#,golang 等属于静态类型。         

        像 python，ruby，javascript 等属于动态语言。

扩展性

        提供了许多独特的语言机制，可以以库的形式轻易无缝添 加新的语言结构。

并发性

        其并没有在底层对语言的并发性做更新升级。

        使用 Actor 作为其并发模型

Scala基础篇

基础语法

基本概念

对象：类的一个具体实例，对象包含属性和方法，如旺财有属性毛色和看家本领能力。

类：类是对象的抽象，对象是类的一个实例。
方法：描述类所拥有的行为能力，一个类可以拥有多个方法。
属性：也称字段，即每个对象拥有它自身实例变量集合，通过赋值来创建真正的属性值。

基本语法

区分大小写
类名：首字母要大写，如 class HelloWorld{},classPerson{},class Student{},也称大驼峰

方法名称：首字母小写，从第 2个单词开启的首字段大写，如def toString(),def getName()，即为小驼峰
程序文件名：保持与类名或对象名一致，区分大小写，以".scala"来结尾。
主程序入口：defm ain(args:A rray[S tring])，scala 若要独立运行必须从 main方法开始处理，每个 scala 强制程序入口。

标识符

兼容 java标识符命名规范
命名规范：类为大驼峰，其它为小驼峰
多符号命名：可以加入“$,+,++,<“等符号参与命名，注意首字符和尾字符的若干限制，如"$"不要作为开头，"_"不要作为结尾。

有新增关键字，如 yield成为 scala新关键字，则在 scala调用时，则应由 Thread.yield()改成 Thread.`yield`来使用。

关键字

以下为保留关键字，不要以关键字作为变量命名。
abstract def case do catch else class extends for false final if finally implicit new  forSome lazy import null match override return throw object protected this package sealed trait private super
try true while - type with : val yield = var => >: <- <: @ <% #
 

注释

兼容 Java注释，支持单行和多行
支持多行注释的嵌套结构

换行符

面向行编程的语言，每行语句可以用显式的";"来结尾，或者以回车换行来结尾。即末尾的";"是可选的。

如果一行中包括多个语句，则必须用";"来分隔。

包定义

兼容 java包方式，如 package com.tl.utils;
类 c#的包定义方式
package com.tl.test {
class MyTest {
}

引用

引入单个类：import java.util.Date;
引入包下所有类：import java.util._;
引入包下若干类(选择器）：import java.util.{Date,HashSet,HashMap}
引入类后重命名：import java.util.{Date => OldDate}
隐藏包下的部分成员：import java.util.{Date=>_,_}
默认包引入为：java.lang._、scala._、Predef._，默认引入的包的情况下其内类的使用均不需要加上包名。
 

数据类型

与 Java相似部分（皆为对象类型，scala无原生数据类型）
Byte，Short，Int，Long，Float，Double，Char，String，Boolean

差异部分

Unit：即为空值或无值，与 Java中的 void等同。
 Null：即为 null，即空引用
 Nothing：是任何类型的子类型，在 scala类层级的最末端
 Any：是所有其它类的基（父）类
 AnyRef：是所有引用类的基础，即除了值类型之外
 AnyVal：是所有值类型的基类，包括 9个值类型
 

数据类型的关系图

 常见字面量

整型字面量：如：0，1，0xff,07L
浮点型字面量：0.0，3.14159f
布尔型字面量：true 或者 false
字符字面量：单引号括起来，如'a','b','\t'
字符串字面量：双引号括起来，如"HelloWorld"，"MyName"
Null值：是对引用对象类型的子类，不兼容值类型。

变量

常量

在程序运行过程中其值不会发生变化的量叫做常量。如："A"、"B"、"123"太丰富

使用 val来声明常量
val constString:String="hero";
constString="new_hero";

变量

在程序运行过程中其值可能发生改变的量叫做变量。如：对象的名称、年龄、发色、身材等

使用 var来声明变量
var varString:String="name";
varString="new_name";
变量类型声明

显式声明类型
var variableName : DataType [= Initial Value]
或
val constName: DataType [= Initial Value]
 隐式声明类型
var myString="HelloWorld";
var myInt=1;
 批量变量声明
var a,b=10;
println(a+b);

访问修饰符

scala访问修饰符包括 private,protected,public，对象的访问级别默认都是 public
private
仅在包含了成员定义的类或对象内部可见
在嵌套类情况下，外层类甚至不能访问被嵌套类的私有成员。

protected

比 java的 protected更严格，除了子类可以访问，同包下的类是不能访问的

public

跟 Java完全一致

作用域保护

通过 private[x]或 protected[x]来实现，可以修饰包、类、单例对象。
 private[x],即为"这个成员除了对[…]中的类或[…]中的包中的类及它们的伴生对像可见外，对其它所有类都是 private。
 protected[x],即为"这个成员除了对[…]中的类或[…]中的包中的类及它们的伴生对像可见外，对其它所有类都是 protected。

运算符

算术运算符

 关系运算符

 逻辑运算符

位运算符

 常用位运算
用来对二进制位进行操作，~,&,|,^分别为取反，按位与与，按位与或，按位与异或运算

全部位运算符

 赋值运算符

 控制语句

if

object TestControlSentence {
    def main(args: Array[String]): Unit = {
        var age = 15;
        if (age <= 18) {
            println("未成年人");
        }
    }
}

if...else

object TestControlSentence {
    def main(args: Array[String]): Unit = {
        var age = 15;
        if (age <= 18) {
            println("未成年人");
        } else {
            println("少年已成年了");
        }
    }
}

while

object TestControlSentence {
    def main(args: Array[String]): Unit = {
        var end = 10;
        var begin = 0;
        while (begin < end) {
            println(begin);
            begin = begin + 1;
        }
    }
}

do...while

object TestControlSentence {
    def main(args: Array[String]): Unit = {
        var end = 10;
        var begin = 0;
        do {
            println(begin);
            begin = begin + 1;
        } while (begin < end)
    }
}

for循环

for形式定义

for( var x <- Range ){
statement(s);
}
以上语法中，Range 可以是一个数字区间表示 i to j ，或者 i until j。左箭头 <- 用于为变量 x 赋值。
使用 i to j

object TestControlSentence {
    def main(args: Array[String]): Unit = {
        var end = 10;
        var begin = 0;
        for(x <- begin to end){
            println(x)
        }
    }
}

使用 i until j

object TestControlSentence {
    def main(args: Array[String]): Unit = {
        var end = 10;
        var begin = 0;
        for(x <- begin until end){
            println(x)
        }
    }
}

双变量循环

object TestControlSentence {
    def main(args: Array[String]): Unit = {
        var end = 5;
        var begin = 1;
        for(x <- begin to end;j <- begin to end){
            println(x+"*"+j)
        }
    }
}

集合循环

object TestControlSentence {
    def main(args: Array[String]): Unit = {
        val stringList = List("one","two","three","four","five","six");
        for(str <- stringList){
            println(str)
        }
    }
}