《Java8实战》拥抱变化 有更新!

推荐一本《java8实战》,图灵系列值得一看

Java的发展历程

一、Java SE 8

Java SE 8发行于2014年3月18日,代号culture,这是一个在Java历史上的重大发布
Java SE 8 新特性:

  • Lambda Expressions(Lambda表达式)
  • Pipelines and Streams(管道和流)
  • Date and Time API(日期和时间API)
  • Default Methods(接口可以有默认方法)
  • Type Annotations(类型注解)
  • Nashhorn JavaScript Engine
  • Concurrent Accumulators(并行累加器)
  • Parallel operations(平行作业)
  • PermGen Error Removed
  • TLS SNI

二、Java SE 7

开发代号是Dolphin(海豚),于2011-07-28发行。
引入的新特性包括:

  • switch语句块中允许以字符串作为分支条件;
  • 在创建泛型对象时应用类型推断;
  • 在一个语句块中捕获多种异常;
  • 支持动态语言;
  • 支持try-with-resources;
  • 引入Java NIO.2开发包;
  • 数值类型可以用2进制字符串表示,并且可以在字符串表示中添加下划线;
  • 钻石型语法;
  • null值的自动处理。

三、Java Version SE 6

开发代号为Mustang(野马),于2006-12-11发行。

引入的新特性包括:

  • 支持脚本语言;
  • 引入JDBC 4.0 API;
  • 引入Java Compiler API;
  • 可插拔注解;
  • 增加对Native PKI(Public Key Infrastructure)、Java GSS(Generic Security Service)、Kerberos和LDAP(Lightweight Directory Access Protocol)的支持;
  • 继承Web Services;
  • 做了很多优化。

四、Java Version SE 5.0

开发代号为Tiger(老虎),于2004-09-30发行。
引入的新特性包括:

  • 引入泛型;
  • 增强循环,可以使用迭代方式;
  • 自动装箱与自动拆箱;
  • 类型安全的枚举;
  • 可变参数;
  • 静态引入;
  • 元数据(注解);
  • 引入Instrumentation。

五、J2SE Version 1.4

开发代号为Merlin(隼),于2004-02-06发行(首次在JCP下发行)。
引入的新特性包括:

  • XML处理;
  • Java打印服务;
  • 引入Logging API;
  • 引入Java Web Start;
  • 引入JDBC 3.0 API;
  • 引入断言;
  • 引入Preferences API;
  • 引入链式异常处理;
  • 支持IPv6;
  • 支持正则表达式;
  • 引入Image I/O slot machine API。

六、J2SE Version 1.3

开发代号为Kestrel(红隼),于2000-05-08发行。
* 引入的新特性包括:
* 引入Java Sound API;
* jar文件索引;
* 对Java的各个方面都做了大量优化和增强。

七、J2SE Version 1.2

开发代号为Playground(操场),于1998-12-08发行。
引入的新特性包括:

  • 引入集合(Collection)框架;
  • 对字符串常量做内存映射;
  • 引入JIT(Just In Time)编译器;
  • 引入对打包的Java文件进行数字签名;
  • 引入控制授权访问系统资源的策略工具;
  • 引入JFC(Java Foundation Classes),包括Swing 1.0、拖放和Java 2D类库;
  • 引入Java 插件;
  • 在JDBC中引入可滚动结果集、BLOB、CLOB、批量更新和用户自定义类型;
  • 在Applet中添加声音支持。

八、JDK Version 1.1

于1997-02-19发行。
引入的新特性包括:

  • 引入JDBC(Java Database Connectivity);
  • 支持内部类;
  • 引入Java Bean;
  • 引入RMI(Remote Method Invocation);
  • 引入反射(仅用于内省)。

九、JDK Version 1.0

开发代号为Oak(橡树),于1996-01-23发行

原文[英]:http://javapapers.com/core-java/java-features-and-history/
中文转自:http://www.importnew.com/844.html 并添加了Java8

拥抱JAVA8

以上是java的版本演化,java9即将发布,java8你学会了吗?作为一个发行三年革命性的版本,java8并没有得到很好的运用,以至于很多人都在谈论java的发展前景,但是在很多地方来说,我们并没有真正感受到他的新特新所带来的变化和便利。以至于怀疑他能否在不断升级的业务场景中满足需求。但是并不能否定它的霸主地位,至少在大数据生态系统中各个组件都是基于java开发的。并且很多企业级的web应用都充满了java的身影。
java的地位冲击可能一部分可能是受python,scala的影响,python是一门简洁的脚本式语言,在数据科学和机器学习不断兴起的今天,他的地位也是不断上升。scala作为spark的原生语言,随着spark的强势崛起,也变得炙手可热,一句话来说就是用过的人都说好!,函数式编程和链式调用相比于同样功能的java代码宛如天书,不知所云,高度的抽象能力和诡异的风格都让他作为一门不好上手的语言,但是一旦上手威力无穷。对比与scala编写的spark程序和java7编写的程序就会发现代码量要少三分之二,这对于追求简(tou)洁(lan)的我们是无法忍受的,纵然对于运行效率来说,相差无几,毕竟scala是运行在在JVM上,甚至有时候并没有java效率高。
但是java8完全可以达到同样的代码量,java8的Lambda表达式和行为参数化提供了函数式编程的环境,麻麻在也不担心被scala鄙视了。。
不管怎么样,我觉得java8是可以担当大任,毕竟要和曾经很长一段时间的java历程对接,java8无疑是更好的选择,至少在web,分布式,spark是这样,但是在ML/DL,java确实不是个好选择。

下面我用108种wordCount来对比向大家展示java8的美。。。

MapReduce(hadoop)

import java.io.IOException;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

public class WordCount {

	public static class WordCountMap extends
			Mapper<LongWritable, Text, Text, IntWritable> {

		private final IntWritable one = new IntWritable(1);
		private Text word = new Text();

		public void map(LongWritable key, Text value, Context context)
				throws IOException, InterruptedException {
			String line = value.toString();
			StringTokenizer token = new StringTokenizer(line);
			while (token.hasMoreTokens()) {
				word.set(token.nextToken());
				context.write(word, one);
			}
		}
	}

	public static class WordCountReduce extends
			Reducer<Text, IntWritable, Text, IntWritable> {

		public void reduce(Text key, Iterable<IntWritable> values,
				Context context) throws IOException, InterruptedException {
			int sum = 0;
			for (IntWritable val : values) {
				sum += val.get();
			}
			context.write(key, new IntWritable(sum));
		}
	}

	public static void main(String[] args) throws Exception {
		Configuration conf = new Configuration();
		Job job = new Job(conf);
		job.setJarByClass(WordCount.class);
		job.setJobName("wordcount");

		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);

		job.setMapperClass(WordCountMap.class);
		job.setReducerClass(WordCountReduce.class);

		job.setInputFormatClass(TextInputFormat.class);
		job.setOutputFormatClass(TextOutputFormat.class);

		FileInputFormat.addInputPath(job, new Path(args[0]));
		FileOutputFormat.setOutputPath(job, new Path(args[1]));

		job.waitForCompletion(true);
	}
}

java8以前:(spark)

/**
  * Author:Atlas
  * 
  */
public class WordCount { public static void main(String [] args){
        SparkConf conf = new SparkConf()
                .setAppName("WountCountLocal")
                .setMaster("local[*]");
        JavaSparkContext sc = new JavaSparkContext(conf); //输入源,创建初始的RDD.分散到partiting.
        JavaRDD lines = sc.textFile("input/words");
        JavaRDD words = lines.flatMap(new FlatMapFunction() { 
		  public Iterator call(String s) throws Exception {
			return Arrays.asList(s.split(" ")).listIterator();
            }
        });

        JavaPairRDD pairs = words.mapToPair(new PairFunction() {
		  private static final long serialVersionUID = 1L; 
		  public Tuple2 call(String word) throws Exception {
			return new Tuple2(word, 1);
            }
        });
		final JavaPairRDD wordsCount = pairs.reduceByKey(new Function2() {
		  public Integer call(Integer v1, Integer v2) throws Exception {
			return v1+v2;
            }
        }); //action
        wordsCount.foreach(new VoidFunction>() { public void call(Tuple2 wordCount) throws Exception {
                System.out.println(wordCount.1+" - "+wordCount.2);
            }
        });
        sc.close();
    }
}

Scala:(spark)

/**
  * Author:Atlas
  */ 
object WordCount {
  def main(args:Array[String]): Unit ={
	val conf = new SparkConf().setAppName("wordcount").setMaster("local[*]")
	val sc = new SparkContext(conf)
	val lines = sc.textFile("input/words")
	val words = lines.flatMap((line) =>line.split(" "))
	val pairs = words.map(word =>(word,1))
	val wordCounts = pairs.reduceByKey(+).sortByKey()
	wordCounts.foreach(wordcount =>println(wordcount.1+" - "+wordcount.2))
  }
}

java8:(spark)

/** 
  * Author:Atlas
  * 
  */
public class WordCount { public static void main(String [] args){
        SparkConf conf = new SparkConf()
                .setAppName("WountCountLocal")
                .setMaster("local[*]");
        JavaSparkContext sc = new JavaSparkContext(conf); //输入源,创建初始的RDD.分散到partiting.
        JavaRDD lines = sc.textFile("input/words");
        JavaRDD words = lines.flatMap(line -> Arrays.asList(line.split(" ")).listIterator());
        JavaPairRDD counts = words.mapToPair(w -> new Tuple2(w, 1))
                        .reduceByKey((x, y) -> x + y);
        counts.foreach(cn -> System.out.println(cn.1+" "+cn.2));
 } }

scala简化版:(spark)

/**
  * Author:Atlas
  */ 
object WordCount {
  def main(args:Array[String]): Unit ={
	val conf = new SparkConf().setAppName("wordcount").setMaster("local[*]")
	val sc = new SparkContext(conf)
	sc.textFile("input/words")
	  .flatMap((line) =>line.split(" "))
	  .words.map(word =>(word,1))
	  .pairs.reduceByKey(+).sortByKey()
	  .foreach(wordcount =>println(wordcount.1+" - "+wordcount.2))
  }
}

java8简化版:(spark)

/** 
  * Author:Atlas
  * 
  */
public class WordCount {
  public static void main(String [] args){
        SparkConf conf = new SparkConf()
                .setAppName("WountCountLocal")
                .setMaster("local[*]");
        JavaSparkContext sc = new JavaSparkContext(conf); 
        sc.textFile("input/words")
		  .flatMap(line -> Arrays.asList(line.split(" ")).listIterator())
		  .mapToPair(w -> new Tuple2(w, 1))
          .reduceByKey((x, y) -> x + y)
		  .foreach(cn -> System.out.println(cn.1+" "+cn.2));
 } 
}

从最终scala和java版的spark wordCount可以看出用java开发spark效率已经有了很大的提升,当然这个小案例并不能代表什么,近几年作为一个小参照,java三部分集合框架,NIO,多线程每个部分都需要不断地的去深入研究,java版本不断升级也是多部分在这些方面优化,更多java8的特性需要我们在不断的去运用,去探索,。

. - - —— ————THE END——— —— - - .

⚠求而不得,往往不求而得!
⚠此文章为原创作品,转载务必保留本文地址及原作者。

评论

发表评论

validate