2017.09.06 scala spark学习
2.scala没有静态的修饰符，但object下的成员都是静态的 ,若有同名的class,这其作为它的伴生类。在object中一般可以为伴生类做一些初始化等操作,如我们常常使用的val array=Array(1,2,3) (ps:其使用了apply方法)
scala里的object一般特指的是伴生对象， 可以通过对象名直接调用其中的成员， 类似Java中的static成员， 如果不在当前作用域，需要import。object StudentModelMain{
private val MIX_ARGS_NUM = 3
private val GEN_MODEL_ARGS_NUM = 5
private val PRE__ARGS_NUM = 6
private def printUsage(): Unit = {
val usage: String = "Student Model Class\n" +
"\n" +
"Usage: GenerateModel PredictionFromModel\n" +
"\n" +
"GenerateModel params:\n" +
"\t sourceFilePath - (string) source file path for generate Model\n" +
"\t modelFilePath - (string) model file path for save Model\n" +
"PredictionFromModel\n" +
"\t modelFilePath - (string) model file path for save the model\n" +
"\t testFilePath - (string) test file path for prediction use the model\n" +
"\t resultFilePath - (string) result file path for save the result\n"
println(usage)
}
private def parseArgs(args: Array[String] , argsNum: Int): Unit = {
if (args.length < argsNum) {
printUsage()
System.exit(1)
}
}
Scala有两种变量，val和var。val就不能再赋值了。与之对应的，var可以在它生命周期中被多次赋值。
通常Unit只用来声明函数或方法的返回值，其他场景基本是没有意义的。 相当于void
SparkContext是Spark的入口，负责连接Spark集群，创建RDD，累积量和广播量等。从本质上来说，SparkContext是Spark的对外接口，负责向调用这提供Spark的各种功能。它的作用是一个容器。SparkContext类非常简洁，大多数函数体只有几行代码。
SparkContext.scala实现了一个class SparkContext和一个object SparkContext。
Scala语言不能定义静态成员，于是就出现了单例对象 singleton object，除了用object关键字代替了class之外，单例对象的定义跟class的定义完全一致。
如果单例对象和某个类的名字是一样的，如SparkContext，那么，它就是这个类的伴生对象-companion object。类和它的伴生对象必须定义在一个源文件里。类，被成为是这个单例对象的伴生类-companion class。类和它的伴生对象可以互相访问其私有成员。
单例对象有什么意义呢？
单例对象没有类型，所以，如果只有object SparkContext，就不能创建class SparkContext对象，那么，在需要把SparkContext作为参数的函数调用就不用使用了。因此，object SparkContext的类型，是由它的伴生类 class SparkContext定义的。
可以使用类型调用单例对象的方法，也可以用类的实例变量指代单例对象，并把它传递给需要类型参数的方法。
单例对象不带参数。
单例对象不是用new关键字实例化的，所以不能传递给它实例化参数。
单例对象在第一次被访问的时候才会被实例化。
如果单例对象没有伴生类，那么它就是独立对象-standalone object，可以作为相关功能方法的工具类，或者是scala应用的入口点。
RDD、DataFrame和DataSet是容易产生混淆的概念，必须对其相互之间对比，才可以知道其中异同。
RDD和DataFrame
提升执行效率
RDD API是函数式的，强调不变性，在大部分场景下倾向于创建新对象而不是修改老对象。这一特点虽然带来了干净整洁的API，却也使得Spark应用程序在运行期倾向于创建大量临时对象，对GC造成压力。在现有RDD API的基础之上，我们固然可以利用mapPartitions方法来重载RDD单个分片内的数据创建方式，用复用可变对象的方式来减小对象分配和GC的开销，但这牺牲了代码的可读性，而且要求开发者对Spark运行时机制有一定的了解，门槛较高。另一方面，Spark SQL在框架内部已经在各种可能的情况下尽量重用对象，这样做虽然在内部会打破了不变性，但在将数据返回给用户时，还会重新转为不可变数据。利用 DataFrame API进行开发，可以免费地享受到这些优化效果。
减少数据读取
分析大数据，最快的方法就是 ——忽略它。这里的“忽略”并不是熟视无睹，而是根据查询条件进行恰当的剪枝。
上文讨论分区表时提到的分区剪 枝便是其中一种——当查询的过滤条件中涉及到分区列时，我们可以根据查询条件剪掉肯定不包含目标数据的分区目录，从而减少IO。
对于一些“智能”数据格 式，Spark SQL还可以根据数据文件中附带的统计信息来进行剪枝。简单来说，在这类数据格式中，数据是分段保存的，每段数据都带有最大值、最小值、null值数量等 一些基本的统计信息。当统计信息表名某一数据段肯定不包括符合查询条件的目标数据时，该数据段就可以直接跳过（例如某整数列a某段的最大值为100，而查询条件要求a > 200）。
此外，Spark SQL也可以充分利用RCFile、ORC、Parquet等列式存储格式的优势，仅扫描查询真正涉及的列，忽略其余列的数据。
执行优化
为了说明查询优化，我们来看上图展示的人口数据分析的示例。图中构造了两个DataFrame，将它们join之后又做了一次filter操作。如果原封不动地执行这个执行计划，最终的执行效率是不高的。因为join是一个代价较大的操作，也可能会产生一个较大的数据集。如果我们能将filter下推到 join下方，先对DataFrame进行过滤，再join过滤后的较小的结果集，便可以有效缩短执行时间。而Spark SQL的查询优化器正是这样做的。简而言之，逻辑查询计划优化就是一个利用基于关系代数的等价变换，将高成本的操作替换为低成本操作的过程。
得到的优化执行计划在转换成物 理执行计划的过程中，还可以根据具体的数据源的特性将过滤条件下推至数据源内。最右侧的物理执行计划中Filter之所以消失不见，就是因为溶入了用于执行最终的读取操作的表扫描节点内。
对于普通开发者而言，查询优化 器的意义在于，即便是经验并不丰富的程序员写出的次优的查询，也可以被尽量转换为高效的形式予以执行。
RDD和DataSet
-
DataSet以Catalyst逻辑执行计划表示，并且数据以编码的二进制形式被存储，不需要反序列化就可以执行sorting、shuffle等操作。
-
DataSet创立需要一个显式的Encoder，把对象序列化为二进制，可以把对象的scheme映射为Spark
SQl类型，然而RDD依赖于运行时反射机制。
通过上面两点，DataSet的性能比RDD的要好很多，可以参见[3]
DataFrame和DataSet
Dataset可以认为是DataFrame的一个特例，主要区别是Dataset每一个record存储的是一个强类型值而不是一个Row。因此具有如下三个特点：
-
DataSet可以在编译时检查类型
-
并且是面向对象的编程接口。用wordcount举例：
//DataFrame
// Load a text file and interpret each line as a java.lang.String
val ds = sqlContext.read.text("/home/spark/1.6/lines").as[String]
val result = ds
.flatMap(_.split(" ")) // Split on whitespace
.filter(_ != "") // Filter empty words
.toDF() // Convert to DataFrame to perform aggregation / sorting
.groupBy($"value") // Count number of occurences of each word
.agg(count("*") as "numOccurances")
.orderBy($"numOccurances" desc) // Show most common words first//DataSet,完全使用scala编程，不要切换到DataFrame
val wordCount =
ds.flatMap(_.split(" "))
.filter(_ != "")
.groupBy(_.toLowerCase()) // Instead of grouping on a column expression (i.e. $"value") we pass a lambda function
.count()-
后面版本DataFrame会继承DataSet，DataFrame是面向Spark SQL的接口。
DataFrame和DataSet可以相互转化，df.as[ElementType]这样可以把DataFrame转化为DataSet，ds.toDF()这样可以把DataSet转化为DataFrame。
链接：http://www.jianshu.com/p/c0181667daa0
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
package cn.itcast.spark.sql
import org.apache.spark.sql.{Row, SQLContext}
import org.apache.spark.sql.types._
import org.apache.spark.{SparkContext, SparkConf}
/**
* Created by ZX on 2015/12/11.
*/
object SpecifyingSchema {
def main(args: Array[String]) {
//创建SparkConf()并设置App名称
val conf = new SparkConf().setAppName("SQL-2")
//SQLContext要依赖SparkContext
val sc = new SparkContext(conf)
//创建SQLContext
val sqlContext = new SQLContext(sc)
//从指定的地址创建RDD
val personRDD = sc.textFile(args(0)).map(_.split(" "))
//通过StructType直接指定每个字段的schema
val schema = StructType(
List(
StructField("id", IntegerType, true),
StructField("name", StringType, true),
StructField("age", IntegerType, true)
)
)
//将RDD映射到rowRDD
val rowRDD = personRDD.map(p => Row(p(0).toInt, p(1).trim, p(2).toInt))
//将schema信息应用到rowRDD上
val personDataFrame = sqlContext.createDataFrame(rowRDD, schema)
//注册表
personDataFrame.registerTempTable("t_person")
//执行SQL
val df = sqlContext.sql("select * from t_person order by age desc limit 4")
//将结果以JSON的方式存储到指定位置
df.write.json(args(1))
//停止Spark Context
sc.stop()
}
}
Scala => 把左边的转化为右边的
1.Schema是什么
DataFrame中提供了详细的数据结构信息，从而使得SparkSQL可以清楚地知道该数据集中包含哪些列，每列的名称和类型各是什么，
DataFrame中的数据结构信息，即为schema
2.输出schema
还是用官网中的people.json的文件，输出schema，看看schema到底长什么样子。people.json文件的show()在上一篇文章中已经写到，
为了大家方便，我再把people.json长啥样贴出来，如图：
输出schema就一行代码：
df.printSchema()object SparkSQLExample {
def main(args: Array[String]) {
val sparkConf = new SparkConf().setMaster("local").setAppName("spark SQL basic example")
val sc = new SparkContext(sparkConf)
val sqlContext = new SQLContext(sc)
val df = new SQLContext(sc).read.json("E:\\spark-2.1.0\\spark-2.1.0\\examples\\src\\main\\resources\\people.json")
df.show()
df.printSchema()
}
}
看截屏不清楚，为了让大家看的清楚，只截结果：
StringIndexer是指把一组字符型标签编码成一组标签索引，索引的范围为0到标签数量，索引构建的顺序为标签的频率，优先编码频率较大的标签，所以出现频率最高的标签为0号。如果输入的是数值型的，我们会把它转化成字符型，然后再对其进行编码。在pipeline组件，比如Estimator和Transformer中，想要用到字符串索引的标签的话，我们一般需要通过setInputCol来设置输入列。另外，有的时候我们通过一个数据集构建了一个StringIndexer，然后准备把它应用到另一个数据集上的时候，会遇到新数据集中有一些没有在前一个数据集中出现的标签，这时候一般有两种策略来处理：第一种是抛出一个异常（默认情况下），第二种是通过掉用 setHandleInvalid("skip")来彻底忽略包含这类标签的行。
VectorAssembler是一个transformer，将多列数据转化为单列的向量列。
转化前的数据：
id | hour | mobile | userFeatures | clicked
----|------|--------|------------------|---------
0 | 18 | 1.0 | [0.0, 10.0, 0.5] | 1.0
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
转化后的数据：
id | hour | mobile | userFeatures | clicked | features
----|------|--------|------------------|---------|-----------------------------
0 | 18 | 1.0 | [0.0, 10.0, 0.5] | 1.0 | [18.0, 1.0, 0.0, 10.0, 0.5]
随机森林
http://blog.csdn.net/ac540101928/article/details/51689505 感谢原作者