Spark---Scala与Java性能比较

自己分别用Java和Scala写了一个词频统计的例子，自己找了一个1000万的数据，然后模拟的是4个进程，读取的本地txt文件，然后统计两种语言的运行时间，做了十组对比，具体如下：

Java与Scala语言性能对比

组数/语言	Java语言(ms)	Scala语言(ms)
1	18270	9070
2	17917	8476
3	17599	9297
4	16992	8605
5	17633	9193
6	18271	9157
7	18223	8387
8	17503	8583
9	17804	8445
10	17293	8315

从上面的对比中可以看到，Scala语言速度明显比Java快，上述实验也和自己的电脑配置有关，虽然不能精确的计算出具体的时间，但是我们能发现两者之间的差异很大。

下来贴上代码：

Scala代码：

import org.apache.spark.{SparkConf, SparkContext}

object yb {
def main(args: Array[String]): Unit={
val startTime=System.currentTimeMillis()//获取开始时间
val conf=new SparkConf().setAppName("Test").setMaster("local[4]")
val sc = new SparkContext(conf)
val lines = sc.textFile("E:/Spark/xyz/data_format1/100W.txt")
/*
sortByKey参数有二个。1、true（升序），否则反之。2、标识分片数（分区数）
flatMap相当于获取一个朋友对象的列表。
*/
val worldcounts=lines.flatMap(line => line.split("\t")).map(word => (word,1)).reduceByKey((a,b) => a+b).map{case (key,value)=>(value,key)}.sortByKey(false,1)
/*val topK=worldcounts.top(10)
topK.foreach(println)*/
worldcounts.foreach(println)
val endTime=System.currentTimeMillis() //获取结束时间
println("Scala程序运行时间： "+(endTime-startTime)+"ms")
}
}

Java代码：

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import scala.Tuple2;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
* Created by Administrator on 2015/12/11.
*/
public class JavaWordCount {
public static void main(String[] args) {
long startTime=System.currentTimeMillis();//获取开始时间

SparkConf conf=new SparkConf().setAppName("JavaWordCount").setMaster("local[8]");
JavaSparkContext sc=new JavaSparkContext(conf);
JavaRDD<String>  dataline=sc.textFile("E:/Spark/xyz/data_format1/100w.txt");
JavaRDD<String> words=dataline.flatMap(new FlatMapFunction<String, String>() {
@Override//重写方法
public Iterable<String> call(String s) {
return Arrays.asList(s.split(" "));
}
});
JavaPairRDD<String,Integer> pair=words.mapToPair(new PairFunction<String, String, Integer>() {
@Override
public Tuple2<String, Integer> call(String s) {
return new Tuple2<String, Integer>(s, 1);
}
});
JavaPairRDD<String,Integer> counts=pair.reduceByKey(new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer a, Integer b) {
return a + b;
}
});
List<Tuple2<String,Integer>> ouput=counts.collect();
Collections.sort(ouput, new Comparator<Tuple2<String,Integer>>() {
@Override
public int compare(Tuple2<String, Integer> o1, Tuple2<String, Integer> o2) {
if(o1._2 < o2._2)
return 1;
else if(o1._2 > o2._2){
return -1;
}else{
return 0;
}
}
});
for(Tuple2 tuple:ouput){
System.out.println(tuple._1 + ": " + tuple._2);
}

long endTime=System.currentTimeMillis(); //获取结束时间
System.out.println("Java程序运行时间： "+(endTime-startTime)+"ms");
/* File fp=new File("E:/Spark/xyz/data_format1/out.txt");//这里是将结果保存到Txt中，也可以不要，在控制台输出。
PrintWriter pfp = null;
try {
pfp = new PrintWriter(fp);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
for(Tuple2 tuple:ouput){
pfp.println(tuple._1 + ": " + tuple._2);
}*/
}
}

由上面的代码可以看出，其实Scala代码量是非常少的，读起来也方便，Java代码比较多（也许我写的不够简洁，但是还是能看出Java的代码多），不易阅读。

所以我们可以选择Scala语言去写Spark，这样不仅速度快，代码量还少。仅供参考，具体自己也可以去试试。