原文引自：http://blog.sina.com.cn/s/blog_628cc2b70102w9up.html
一、初始化SparkContext
System.setProperty("hadoop.home.dir", "D:\\spark-1.6.1-bin-hadoop2.6\\spark-1.6.1-bin-hadoop2.6");
SparkConf conf = new SparkConf().setAppName("spark test1").setMaster("local[2]");
JavaSparkContext context = new JavaSparkContext(conf);
二、使用parallelize方法
创建RDD最简单的方式就是把程序中一个已有的集合传给SparkContext的parallelize()方法
JavaRDD lines = context.parallelize(Arrays.asList("pandas", "i like pandas"));
System.out.println(lines.collect());
输出：[pandas, i like pandas]
三、RDD操作（filter方法）
RDD支持两种操作：转化操作和行动操作。RDD的转化操作是返回一个新的RDD的操作，比如map()和filter()，而行动操作则是想驱动器程序返回结果或把结果写入外部系统的操作，会触发实际的计算，比如count()和first()。
JavaRDD inputRDD = context.textFile("D:\\log\\521.txt");
JavaRDD errorsRDD = inputRDD.filter(
new Function(){
@Override
public Boolean call(String x) throws Exception {
// TODO Auto-generated method stub
return x.contains("error");
}
});
System.out.println("errors显示为：" + errorsRDD.collect());
System.out.println("errors个数为：" + errorsRDD.count());
其中521.log为android的logcat文件，里面包含很多错误信息。
四、使用lambda表达式
Java8 开始支持lambda表达式，可以简洁地实现函数接口。
JavaRDD inputRDD = context.textFile("D:\\log\\521.txt");
JavaRDD errors = inputRDD.filter(s -> s.contains("error"));
System.out.println(errors.count());
输出：23
五、使用map方法
将函数应用于RDD中的每个元素，将返回值构成新的RDD
JavaRDD rdd = context.parallelize(Arrays.asList(1, 3, 5, 7));
JavaRDD result = rdd.map(
new Function(){
@Override
public Integer call(Integer x) throws Exception {
// TODO Auto-generated method stub
return x * x;
}
});
System.out.println(StringUtils.join(result.collect(), ","));
输出：1,9,25,49
六、使用flatMap方法
将函数应用于RDD中的每个元素，将返回的迭代器的所有内容构成新的RDD，通常用来切分单词。与map的区别是：这个函数返回的值是list的一个，去除原有的格式
JavaRDD lines = context.parallelize(Arrays.asList("hello world", "hi"));
JavaRDD words = lines.flatMap(
new FlatMapFunction(){
@Override
public Iterable call(String lines) throws Exception {
// TODO Auto-generated method stub
return Arrays.asList(lines.split(" "));
}
});
System.out.println(words.collect());
System.out.println(words.first());
输出：
[hello, world, hi]
hello
七、使用PairRDD方法
Spark为包含键值对类型的RDD提供了一些专有的操作，这些RDD称为pair RDD。当需要把一个普通的RDD转为pair RDD时，可以调用map()函数来实现。
JavaRDD lines = context.parallelize(Arrays.asList("hello world", "hangtian is from hangzhou", "hi", "hi"));
PairFunction keyData = new PairFunction(){
@Override
public Tuple2 call(String x) throws Exception {
// TODO Auto-generated method stub
return new Tuple2(x.split(" ")[0], x);
}
};
JavaPairRDD pairs = (JavaPairRDD) lines.mapToPair(keyData);
System.out.println(pairs.collect());
输出：[(hello,hello world), (hangtian,hangtian is from hangzhou), (hi,hi), (hi,hi)]
八、计算单词个数
JavaRDD input = context.textFile("D:\\test.txt");
JavaRDD words = input.flatMap(new FlatMapFunction(){
@Override
public Iterable call(String x) throws Exception {
// TODO Auto-generated method stub
return Arrays.asList(x.split(" "));
}
});
JavaPairRDD wordspair = words.mapToPair(new PairFunction(){
@Override
public Tuple2 call(String x) throws Exception {
// TODO Auto-generated method stub
return new Tuple2(x, 1);
}
});
JavaPairRDD result = wordspair.reduceByKey(new Function2(){
@Override
public Integer call(Integer x, Integer y) throws Exception {
// TODO Auto-generated method stub
return x + y;
}
});
System.out.println(result.sortByKey().collect());
输出：[(,2), (are,1), (can,1), (go,1), (i,2), (love,1), (me,1), (much,1), (ok?,1), (should,1), (so,2), (with,1), (you,3)]
九、使用Accumulator方法
Spark有两种共享变量：累加器 和 广播变量。累加器用来对信息进行聚合，而广播变量用来高效分发较大的对象。累加器提供了将工作节点中的值聚合到驱动器程序中国的简单语法。
JavaRDD rdd = context.textFile("D:\\test.txt");
final Accumulator blankLines = context.accumulator(0);
JavaRDD callSigns = rdd.flatMap(new FlatMapFunction(){
@Override
public Iterable call(String line) throws Exception {
// TODO Auto-generated method stub
if(line.equals("")){
blankLines.add(1);
}
return Arrays.asList(line.split(" "));
}
});
System.out.println(callSigns.collect());
System.out.println("Blank lines: " + blankLines.value());
输出：
[i, love, you, so, much, , so, i, should, you, can, go, with, me, , are, you, ok?]
Blank lines: 2
十、Spark SQL使用
Spark提供Spark SQL来操作结构化和半结构化数据。直白说就是，可以使用sql语句操作json和txt文件进行数据查询等操作。
JavaRDD rdd = context.textFile("D:\\test.json");
SQLContext sqlContext = SQLContext.getOrCreate(rdd.context());
DataFrame dataFrame = sqlContext.read().json(rdd);
dataFrame.registerTempTable("person");
DataFrame resultDataFrame = sqlContext.sql("select * from person where lovesPandas=true");
resultDataFrame.show(false);
输出：
+-----------+---------+
|lovesPandas|name |
+-----------+---------+
|true |nanchang |
|true |qier |
|true |kongshuai|
+-----------+---------+
十一、Spark Stream使用
用来实时计算数据，其构造函数接口用来指定多久时间处理一次新数据的批次间隔作为输入。以下代码在本地未能执行通过。设想是把netcat工具作为输入源，在程序中打印输入信息并进行处理
JavaStreamingContext jssc = new JavaStreamingContext(conf, new Duration(2000));
JavaDStream lines = jssc.socketTextStream("localhost", 7778);
lines.print();
jssc.start();
jssc.awaitTermination();
以上代码运行还需要删除最上面的context初始化的代码。
