1207人阅读
JAVA（26）
网上关于java lambda的例子很多，但是这些五花八门的例子很不常见不常用，最后导致初学者望而却步，其实我们抓住lambda的本质之后，会发现lambda还是很好理解的。毕竟，java8设计lambda的初衷是给开发者提供便利，而不是制造障碍。
lambda表达式本质是匿名方法，下面是一些lambda表达式：
(int x, int y) -& x + y
(String s) -& { System.out.println(s); }
第一个lambda表达式接收x和y这两个整形参数并返回它们的和；
第二个lambda表达式不接收参数，返回整数42；
第三个lambda表达式接收一个字符串并把它打印到控制台，不返回值。
lambda表达式的语法由参数列表、箭头符号-&和函数体组成。函数体既可以是一个表达式，也可以是一个语句块：
表达式：表达式会被执行然后返回执行结果。
语句块：语句块中的语句会被依次执行，就像方法中的语句一样。
return语句会把控制权交给匿名方法的调用者
break和continue只能在循环中使用
如果函数体有返回值，那么函数体内部的每一条路径都必须返回值
java8的安装
工欲善其器必先利其器，首先安装JDK8。过程省略，大家应该都可以自己搞定。但是有一点这里强调一下（Windows系统）：目前我们工作的版本一般是java 6或者java 7，所以很多人安装java8基本都是学习为主。这样就在自己的机器上会存在多版本的JDK。而且大家一般是希望在命令行中执行java命令是基于老版本的jdk。但是在安装完jdk8并且没有设置path的情况下，你如果在命令行中输入：java -version，屏幕上会显示是jdk 8。这是因为jdk8安装的时候，会默认在C:/Windows/System32中增加java.exe，这个调用的优先级比path设置要高。所以即使path里指定是老版本的jdk，但是执行java命令显示的依然是新版本的jdk。这里我们要做的就是删除C:/Windows/System32中的java.exe文件（不要手抖！）。
下面转自：
Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。
Lambda表达式还增强了集合库。 Java SE 8添加了2个对集合数据进行批量操作的包:&java.util.function&包以及java.util.stream&包。
流(stream)就如同迭代器(iterator),但附加了许多额外的功能。 总的来说,lambda表达式和 stream 是自Java语言添加泛型(Generics)和注解(annotation)以来最大的变化。 在本文中,我们将从简单到复杂的示例中见认识lambda表达式和stream的强悍。
如果还没有安装Java 8,那么你应该先安装才能使用lambda和stream(译者建议在虚拟机中安装,测试使用)。
像NetBeans 和IntelliJ IDEA 一类的工具和IDE就支持Java 8特性,包括lambda表达式,可重复的注解,紧凑的概要文件和其他特性。
下面是Java SE 8和NetBeans IDE 8的下载链接:
: 从Oracle下载Java 8,也可以和NetBeans IDE一起下载
从NetBeans官网下载NetBeans IDE
Lambda表达式的语法
(parameters) -& expression
(parameters) -&{ }
下面是Java lambda表达式的简单例子:
基本的Lambda例子
现在,我们已经知道什么是lambda表达式,让我们先从一些基本的例子开始。 在本节中,我们将看到lambda表达式如何影响我们编码的方式。 假设有一个玩家List ,程序员可以使用 for 语句 (&for 循环&)来遍历,在Java SE 8中可以转换为另一种形式:
正如您看到的,lambda表达式可以将我们的代码缩减到一行。 另一个例子是在图形用户界面程序中,匿名类可以使用lambda表达式来代替。 同样,在实现Runnable接口时也可以这样使用:
下面是使用lambdas 来实现 Runnable接口 的示例:
Runnable 的 lambda表达式,使用块格式,将五行代码转换成单行语句。 接下来,在下一节中我们将使用lambdas对集合进行排序。
使用Lambdas排序集合
在Java中,Comparator 类被用来排序集合。 在下面的例子中,我们将根据球员的 name, surname, name 长度 以及最后一个字母。 和前面的示例一样,先使用匿名内部类来排序,然后再使用lambda表达式精简我们的代码。
在第一个例子中,我们将根据name来排序list。 使用旧的方式,代码如下所示:
使用lambdas,可以通过下面的代码实现同样的功能:
其他的排序如下所示。 和上面的示例一样,代码分别通过匿名内部类和一些lambda表达式来实现Comparator :
就是这样,简洁又直观。 在下一节中我们将探索更多lambdas的能力,并将其与 stream 结合起来使用。
使用Lambdas和Streams
Stream是对集合的包装,通常和lambda一起使用。 使用lambdas可以支持许多操作,如 map, filter, limit, sorted, count, min, max, sum, collect 等等。 同样,Stream使用懒运算,他们并不会真正地读取所有数据,遇到像getFirst()&这样的方法就会结束链式语法。
在接下来的例子中,我们将探索lambdas和streams 能做什么。 我们创建了一个Person类并使用这个类来添加一些数据到list中,将用于进一步流操作。 Person 只是一个简单的POJO类:
接下来,我们将创建两个list,都用来存放Person对象:
现在我们使用forEach方法来迭代输出上述列表:
我们同样使用forEach方法,增加程序员的工资5%:
另一个有用的方法是过滤器filter() ,让我们显示月薪超过1400美元的PHP程序员:
我们也可以定义过滤器,然后重用它们来执行其他操作:
使用limit方法,可以限制结果集的个数:
排序呢? 我们在stream中能处理吗? 答案是肯定的。 在下面的例子中,我们将根据名字和薪水排序Java程序员,放到一个list中,然后显示列表:
如果我们只对最低和最高的薪水感兴趣,比排序后选择第一个/最后一个 更快的是min和max方法:
上面的例子中我们已经看到 collect 方法是如何工作的。 结合 map 方法,我们可以使用 collect 方法来将我们的结果集放到一个字符串,一个 Set 或一个TreeSet中:
Streams 还可以是并行的(parallel)。 示例如下:
我们可以使用summaryStatistics方法获得stream 中元素的各种汇总数据。 接下来,我们可以访问这些方法,比如getMax, getMin, getSum或getAverage:
OK,就这样,希望你喜欢它!
在本文中,我们学会了使用lambda表达式的不同方式,从基本的示例,到使用lambdas和streams的复杂示例。 此外,我们还学习了如何使用lambda表达式与Comparator 类来对Java集合进行排序。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：51985次
积分：1584
积分：1584
排名：第19483名
原创：83篇
转载：51篇
评论：17条
文章：21篇
阅读：10863
(1)(1)(8)(23)(45)(13)(21)(12)(1)　　前几天电脑上的JDK自动更新到1.8，这两天了解了一下JDK1.8的一些新特性。下面就来浅谈一下我所了解的。
　　我们都知道，Java是不能多继承的，但是可以多实现。它与C++不同，C++是可以多继承的。尽管Java可以实现多个接口，但是接口中只能有抽象方法，不能有具体的实现。但是在JDK1.8中，接口里新增了默认方法。可以对默认方法进行具体的实现，但是这个方法必须是default。看下面这段代码：
1 interface AA{
public int add(int a,int b);
//申明方法
default void sing(String name){
//默认方法
System.out.println("The song name is " + name);
8 public class CC implements AA{
public static void main(String[] args){
AA aa = new AA(){
//匿名内部类
public int add(int a,int b){
return (a + b);
aa.sing("The Bird And The Bee");
//方法调用
System.out.println(aa.add(5,3));
　　在接口AA中，我们有两个方法，并且有一个默认方法。在main函数中，我们对AA中的add方法进行实现，之后调用AA中的两个方法，这段代码是正确的。现在来想一个问题，既然现在接口中可以有方法的实现，而且接口又是可以多继承的，那么如果两个接口中有同样的方法签名的两个方法，那么在实现这两个接口的实现类中，会有冲突吗？
　　接口C继承了接口A和B，而在A，B中有相同方法签名的函数。注：函数的方法签名包括：函数名，参数个数，参数类型以及顺序，不包括返回值。代码如下：
1 interface A1{
default int add(int a,int b){
return (a + b);
default void say(){
System.out.println("Hello,I am A1");
10 interface B1{
default int subtraction(int a,int b){
return (a - b);
default void say(){
System.out.println("Hello,I am B1");
19 interface C1 extends A1,B1{}
　　上面这段代码在编译时候会出现错误。
　　之后我们稍稍修改一下我们的接口C1，让它覆盖父接口的say()方法。并完善我们代码：
1 interface A1{
default int add(int a,int b){
return (a + b);
default void say(){
System.out.println("Hello,I am A1");
10 interface B1{
default int subtraction(int a,int b){
return (a - b);
default void say(){
System.out.println("Hello,I am B1");
19 interface C1 extends A1,B1{
default void say(){
//B1.super.say();
指定调用父接口中的say()
System.out.println("Hello,I am C1");
//有自己的实现
27 public class Test implements C1{
public static void main(String[] args){
Test t = new Test();
System.out.println(t.add(3,5));
System.out.println(t.subtraction(5,2));
　　我们使用覆盖父类的方式来避免上面错出现的冲突。在覆盖方法中，我们可以有自己的实现，也可以指定实现某个父接口中的方法。好，解决了这个问题，我们来继续思考另外一个问题，如果一个子类继承一个基类并实现了一个接口，并且不幸的事，基类中有一个方法是接口中的默认方法，此时又会出现冲突吗？
　　代码如下：
1 interface A1{
default int add(int a,int b){
System.out.println("add() in interface A1 ---& ");
return (a + b);
default void say(){
System.out.println("Hello,I am interface A1");
11 class A2{
public int add(int a,int b){
System.out.print("add() in class A2 ---& ");
return (a + b);
public void say(){
System.out.println("Hello,I am class A2");
21 public class Test extends A2 implements A1{
public static void main(String[] args){
Test t = new Test();
System.out.println(t.add(3,5));
　　运行结果如下：
　　从结果可以看出，当基类和接口中的默认方法具有相同方法签名的函数时，子类优先继承基类中的函数实现，而不是父接口中的默认方法。如果父类没有相同的方法签名，子类才会继承接口中的默认方法。说了这么多关于默认方法，想一想JDK1.8为什么要新增加这一特性呢？由于Collection库需要为批处理操作添加新的方法，如forEach()，stream()等，但是不能修改现有的Collection接口&&如果那样做的话所有的实现类都要进行修改，包括很多客户自制的实现类。拿forEach()方法来说，以前我们遍历一个集合的时候，都是自己写遍历操作的代码，相信下面这段代码我们都是很熟悉的：
1 import java.util.*;
3 public class Newlist{
public static void main(String[] args){
List&String& strList = new ArrayList&String&();
strList.add("123");
strList.add("234");
strList.add("345");
strList.add("456");
strList.add("567");
for(String list : strList){
System.out.println(list);
　　但是现在不必要这么麻烦了，我们可以直接使用现成的方法进行遍历。使用下面这行代码，代替上面的for循环，即可。
list.forEach(o-&{System.out.println(o);});
　　forEach()方法在List接口中就是一个默认方法，所以所有实现了这个接口，继承这接口的类或接口都具有这个方法，这就是新增默认方法的原因。
　　这行代码又引出了一个新特性--&lambda表达式。lambda表达式就是一个匿名函数，主要用于替换以前广泛使用的内部匿名类，各种回调，比如事件响应器、传入Thread类的Runnable等。Java8有一个短期目标和一个长期目标。短期目标是：配合&集合类批处理操作&的内部迭代和并行处理（上面将已经讲到）；长期目标是将Java向函数式编程语言这个方向引导（并不是要完全变成一门函数式编程语言，只是让它有更多的函数式编程语言的特性，关于函数式编程语言和命令式编程语言请参看这篇博客），也正是由于这个原因，Oracle并没有简单地使用内部类去实现&表达式，而是使用了一种更动态、更灵活、易于将来扩展和改变的策略（invokedynamic）。下面举个简单例子了解lambda表达式：
1 interface A{
//函数接口
public int add(int a,int b);
boolean equals(Object obj);
default void say(){
System.out.println("Hello,I am A");
8 public class Lambda implements A{
public static void main(String[] args){
/* A a = new A(){
匿名内部类实现add()
public int add(int a,int b){
return (a+b);
A a = (x,y)-&{return (x+y);};
System.out.println(a.add(5,3));
　　在上面的main中我们使用了lambda表示式对接口A中add()方法进行了实现，上面注释是我们不使用表达式而是使用匿名内部类去实现接口中的非默认方法。可以看出，&表达式是由(参数)、-&、{}三部分构成的。左边是接口定义方法的参数，可以省略参数类型，并且只有当方法仅唯一参数时，小括号才能省略，没有参数应该写成()。表达式右边是代码块，也就是我们平时书写函数体中的内容。请注意：能够使用&表达式的目标类型必须是函数接口，函数接口的定义是：一个接口，如果只有一个显式声明的抽象方法，那么它就是一个函数接口。一般用@FunctionalInterface标注出来（也可以不标）。说的简单一点就是在一个接口中只有一个显示申明的函数。在上面的例子中，我们的接口A就是函数接口，因为只有一个显示申明的add()。你可能疑惑，那equals方法呢？equals方法是Object的，所有的接口都会声明Object的public方法&&它是隐式的。下面举一个线程的例子：
1 public class Lambda{
public static void main(String[] args){
Thread tt = new Thread(new Runnable(){
//一般做法
public void run(){
for(int i=0;i&100;i++){
System.out.println("normal function!");
Thread tt = new Thread(()-&{
//使用lambda表示式
for(int i=0;i&100;i++){
System.out.println("lambda expression!");
tt.start();
　　JDK1.8有很多新特性，我列出的只是很小一部分，作为Java语言忠实的粉丝，感觉学习Java越来越有趣。
　　参考博客：
阅读(...) 评论()<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
您的访问请求被拒绝 403 Forbidden - ITeye技术社区
您的访问请求被拒绝
亲爱的会员，您的IP地址所在网段被ITeye拒绝服务，这可能是以下两种情况导致：
一、您所在的网段内有网络爬虫大量抓取ITeye网页，为保证其他人流畅的访问ITeye，该网段被ITeye拒绝
二、您通过某个代理服务器访问ITeye网站，该代理服务器被网络爬虫利用，大量抓取ITeye网页
请您点击按钮解除封锁&11445人阅读
java（116）
更多ppt内容请查看：
本文是我学习了解了jdk7和jdk8的一些新特性的一些资料，有兴趣的大家可以浏览下下面的内容。
官方文档：/technetwork/java/javase/jdk7-relnotes-418459.html
在jdk7的新特性方面主要有下面几方面的增强：
1.jdk7语法上
1.1二进制变量的表示,支持将整数类型用二进制来表示，用0b开头。
// 所有整数 int， short，long，byte都可以用二进制表示
// An 8-bit 'byte' value:
byte aByte = (byte) 0b;
// A 16-bit 'short' value:
short aShort = (short) 0b0101;
// Some 32-bit 'int' values:
intanInt1 = 0b;
intanInt2 = 0b101;
intanInt3 = 0B101; // The B can be upper or lower case.
// A 64-bit 'long' value. Note the &L& suffix:
long aLong = 0b0101L;
// 二进制在数组等的使用
final int[] phases = { 0bbbb,
Switch语句支持string类型
public static String getTypeOfDayWithSwitchStatement(String dayOfWeekArg) {
String typeOfD
switch (dayOfWeekArg) {
case &Monday&:
typeOfDay = &Start of work week&;
case &Tuesday&:
case &Wednesday&:
case &Thursday&:
typeOfDay = &Midweek&;
case &Friday&:
typeOfDay = &End of work week&;
case &Saturday&:
case &Sunday&:
typeOfDay = &Weekend&;
throw new IllegalArgumentException(&Invalid day of the week: & + dayOfWeekArg);
return typeOfD
1.3 Try-with-resource语句
注意：实现java.lang.AutoCloseable接口的资源都可以放到try中，跟final里面的关闭资源类似； 按照声明逆序关闭资源 ;Try块抛出的异常通过Throwable.getSuppressed获取
try (java.util.zip.ZipFile zf = new java.util.zip.ZipFile(zipFileName);
java.io.BufferedWriter writer = java.nio.file.Files
.newBufferedWriter(outputFilePath, charset)) {
// Enumerate each entry
for (java.util.Enumeration entries = zf.entries(); entries
.hasMoreElements();) {
// Get the entry name and write it to the output file
String newLine = System.getProperty(&line.separator&);
String zipEntryName = ((java.util.zip.ZipEntry) entries
.nextElement()).getName() + newL
writer.write(zipEntryName, 0, zipEntryName.length());
1.4 Catch多个异常 说明：Catch异常类型为final； 生成Bytecode 会比多个catch小； Rethrow时保持异常类型
public static void main(String[] args) throws Exception {
testthrows();
} catch (IOException | SQLException ex) {
public static void testthrows() throws IOException, SQLException {
1.5 数字类型的下划线表示 更友好的表示方式，不过要注意下划线添加的一些标准，可以参考下面的示例
long creditCardNumber = 12_3456L;
long socialSecurityNumber = 999_99_9999L;
float pi = 3.14_15F;
long hexBytes = 0xFF_EC_DE_5E;
long hexWords = 0xCAFE_BABE;
long maxLong = 0x7fff_ffff_ffff_ffffL;
byte nybbles = 0b;
long bytes = 0b00_;
//float pi1 = 3_.1415F;
// I cannot put underscores adjacent to a decimal point
//float pi2 = 3._1415F;
// I cannot put underscores adjacent to a decimal point
//long socialSecurityNumber1= 999_99_9999_L;
// I cannot put underscores prior to an L suffix
//int x1 = _52;
// This is an identifier, not a numeric literal
int x2 = 5_2;
// OK (decimal literal)
//int x3 = 52_;
// I cannot put underscores at the end of a literal
int x4 = 5_______2;
// OK (decimal literal)
//int x5 = 0_x52;
// I cannot put underscores in the 0x radix prefix
//int x6 = 0x_52;
// I cannot put underscores at the beginning of a number
int x7 = 0x5_2;
// OK (hexadecimal literal)
//int x8 = 0x52_;
// I cannot put underscores at the end of a number
int x9 = 0_52;
// OK (octal literal)
int x10 = 05_2;
// OK (octal literal)
//int x11 = 052_;
// I cannot put underscores at the end of a number
1.6 泛型实例的创建可以通过类型推断来简化 可以去掉后面new部分的泛型类型，只用&&就可以了。
//使用泛型前
List strList = new ArrayList();
List&String& strList4 = new ArrayList&String&();
List&Map&String, List&String&&& strList5 =
new ArrayList&Map&String, List&String&&&();
//编译器使用尖括号 (&&) 推断类型
List&String& strList0 = new ArrayList&String&();
List&Map&String, List&String&&& strList1 =
new ArrayList&Map&String, List&String&&&();
List&String& strList2 = new ArrayList&&();
List&Map&String, List&String&&& strList3 = new ArrayList&&();
List&String& list = new ArrayList&&();
list.add(&A&);
// The following statement should fail since addAll expects
// Collection&? extends String&
//list.addAll(new ArrayList&&());
1.7在可变参数方法中传递非具体化参数,改进编译警告和错误
Heap pollution 指一个变量被指向另外一个不是相同类型的变量。例如
List l = new ArrayList&Number&();
List&String& ls =
// unchecked warning
l.add(0, new Integer(42)); // another unchecked warning
String s = ls.get(0);
// ClassCastException is thrown
public static &T& void addToList (List&T& listArg, T... elements) {
for (T x : elements) {
listArg.add(x);
你会得到一个warning
warning: [varargs] Possible heap pollution from parameterized vararg type
要消除警告，可以有三种方式
1.加 annotation @SafeVarargs
2.加 annotation @SuppressWarnings({&unchecked&, &varargs&})
3.使用编译器参数 –Xlint:
1.8 信息更丰富的回溯追踪 就是上面try中try语句和里面的语句同时抛出异常时，异常栈的信息
java.io.IOException
at Suppress.write(Suppress.java:19)
at Suppress.main(Suppress.java:8)
Suppressed:
java.io.IOException
at Suppress.close(Suppress.java:24)
at Suppress.main(Suppress.java:9)
Suppressed:
java.io.IOException
Suppress.close(Suppress.java:24)
Suppress.main(Suppress.java:9)
2. NIO2的一些新特性
1.java.nio.file 和java.nio.file.attribute包 支持更详细属性，比如权限，所有者
symbolic and hard links支持
3. Path访问文件系统，Files支持各种文件操作
4.高效的访问metadata信息
5.递归查找文件树，文件扩展搜索
6.文件系统修改通知机制
7.File类操作API兼容
8.文件随机访问增强 mapping a region,locl a region,绝对位置读取
9. AIO Reactor（基于事件）和Proactor
下面列一些示例：
2.1IO and New IO 监听文件系统变化通知
通过FileSystems.getDefault().newWatchService()获取watchService，然后将需要监听的path目录注册到这个watchservice中，对于这个目录的文件修改，新增，删除等实践可以配置，然后就自动能监听到响应的事件。
private WatchS
public TestWatcherService(Path path) throws IOException {
watcher = FileSystems.getDefault().newWatchService();
path.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
public void handleEvents() throws InterruptedException {
while (true) {
WatchKey key = watcher.take();
for (WatchEvent&?& event : key.pollEvents()) {
WatchEvent.Kind kind = event.kind();
if (kind == OVERFLOW) {// 事件可能lost or discarded
WatchEvent&Path& e = (WatchEvent&Path&)
Path fileName = e.context();
System.out.printf(&Event %s has happened,which fileName is %s%n&,kind.name(), fileName);
if (!key.reset()) {
2.2 IO and New IO遍历文件树 ，通过继承SimpleFileVisitor类，实现事件遍历目录树的操作，然后通过Files.walkFileTree(listDir, opts, Integer.MAX_VALUE, walk);这个API来遍历目录树
private void workFilePath() {
Path listDir = Paths.get(&/tmp&); // define the starting file
ListTree walk = new ListTree();
…Files.walkFileTree(listDir, walk);…
// 遍历的时候跟踪链接
EnumSet opts = EnumSet.of(FileVisitOption.FOLLOW_LINKS);
Files.walkFileTree(listDir, opts, Integer.MAX_VALUE, walk);
} catch (IOException e) {
System.err.println(e);
class ListTree extends SimpleFileVisitor&Path& {// NIO2 递归遍历文件目录的接口
public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
System.out.println(&Visited directory: & + dir.toString());
return FileVisitResult.CONTINUE;
public FileVisitResult visitFileFailed(Path file, IOException exc) {
System.out.println(exc);
return FileVisitResult.CONTINUE;
2.3 AIO异步IO 文件和网络 异步IO在java
NIO2实现了，都是用AsynchronousFileChannel，AsynchronousSocketChanne等实现，关于同步阻塞IO，同步非阻塞IO，异步阻塞IO和异步非阻塞IO在ppt的这页上下面备注有说明，有兴趣的可以深入了解下。Java NIO2中就实现了操作系统的异步非阻塞IO。
// 使用AsynchronousFileChannel.open(path, withOptions(),
// taskExecutor))这个API对异步文件IO的处理
public static void asyFileChannel2() {
final int THREADS = 5;
ExecutorService taskExecutor = Executors.newFixedThreadPool(THREADS);
String encoding = System.getProperty(&file.encoding&);
List&Future&ByteBuffer&& list = new ArrayList&&();
int sheeps = 0;
Path path = Paths.get(&/tmp&,
&store.txt&);
try (AsynchronousFileChannel asynchronousFileChannel = AsynchronousFileChannel
.open(path, withOptions(), taskExecutor)) {
for (int i = 0; i & 50; i++) {
Callable&ByteBuffer& worker = new Callable&ByteBuffer&() {
public ByteBuffer call() throws Exception {
ByteBuffer buffer = ByteBuffer
.allocateDirect(ThreadLocalRandom.current()
.nextInt(100, 200));
asynchronousFileChannel.read(buffer, ThreadLocalRandom
3. JDBC 4.1
3.1.可以使用try-with-resources自动关闭Connection, ResultSet, 和 Statement资源对象
3.2. RowSet 1.1：引入RowSetFactory接口和RowSetProvider类，可以创建JDBC driver支持的各种 row sets，这里的rowset实现其实就是将sql语句上的一些操作转为方法的操作，封装了一些功能。
3.3. JDBC-ODBC驱动会在jdk8中删除
try (Statement stmt = con.createStatement()) {
RowSetFactory aFactory = RowSetProvider.newFactory();
CachedRowSet crs = aFactory.createCachedRowSet();
RowSetFactory rsf = RowSetProvider.newFactory(&com.sun.rowset.RowSetFactoryImpl&, null);
WebRowSet wrs = rsf.createWebRowSet();
createCachedRowSet
createFilteredRowSet
createJdbcRowSet
createJoinRowSet
createWebRowSet
4. 并发工具增强
4.1.fork-join
最大的增强，充分利用多核特性，将大问题分解成各个子问题，由多个cpu可以同时解决多个子问题，最后合并结果，继承RecursiveTask，实现compute方法，然后调用fork计算，最后用join合并结果。
class Fibonacci extends RecursiveTask&Integer& {
Fibonacci(int n) {
private int compute(int small) {
final int[] results = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };
return results[small];
public Integer compute() {
if (n &= 10) {
return compute(n);
Fibonacci f1 = new Fibonacci(n - 1);
Fibonacci f2 = new Fibonacci(n - 2);
System.out.println(&fork new thread for & + (n - 1));
f1.fork();
System.out.println(&fork new thread for & + (n - 2));
f2.fork();
return f1.join() + f2.join();
4.2.ThreadLocalRandon 并发下随机数生成类，保证并发下的随机数生成的线程安全，实际上就是使用threadlocal
final int MAX = 100000;
ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
long start = System.nanoTime();
for (int i = 0; i & MAX; i++) {
threadLocalRandom.nextDouble();
long end = System.nanoTime() -
System.out.println(&use time1 : & + end);
long start2 = System.nanoTime();
for (int i = 0; i & MAX; i++) {
Math.random();
long end2 = System.nanoTime() - start2;
System.out.println(&use time2 : & + end2);
4.3. phaser 类似cyclebarrier和countdownlatch，不过可以动态添加资源减少资源
void runTasks(List&Runnable& tasks) {
final Phaser phaser = new Phaser(1); // &1& to register self
// create and start threads
for (final Runnable task : tasks) {
phaser.register();
new Thread() {
public void run() {
phaser.arriveAndAwaitAdvance(); // await all creation
task.run();
}.start();
// allow threads to start and deregister self
phaser.arriveAndDeregister();
5. Networking增强
新增URLClassLoader close方法，可以及时关闭资源，后续重新加载class文件时不会导致资源被占用或者无法释放问题
URLClassLoader.newInstance(new URL[]{}).close();
新增Sockets Direct Protocol
绕过操作系统的数据拷贝，将数据从一台机器的内存数据通过网络直接传输到另外一台机器的内存中
6. Multithreaded Custom Class Loaders
解决并发下加载class可能导致的死锁问题，这个是jdk1.6的一些新版本就解决了，jdk7也做了一些优化。有兴趣可以仔细从官方文档详细了解
Class Hierarchy:
class A extends B
class C extends D
ClassLoader Delegation Hierarchy:
Custom Classloader CL1:
directly loads class A
delegates to custom ClassLoader CL2 for class B
Custom Classloader CL2:
directly loads class C
delegates to custom ClassLoader CL1 for class D
Use CL1 to load class A (locks CL1)
defineClass A triggers
loadClass B (try to lock CL2)
Use CL2 to load class C (locks CL2)
defineClass C triggers
loadClass D (try to lock CL1)
Synchronization in the ClassLoader class wa
Use CL1 to load class A (locks CL1+A)
defineClass A triggers
loadClass B (locks CL2+B)
Use CL2 to load class C (locks CL2+C)
defineClass C triggers
loadClass D (locks CL1+D)
7. Security 增强
7.1.提供几种 ECC-based algorithms (ECDSA/ECDH) Elliptic Curve Cryptography (ECC)
7.2.禁用CertPath Algorithm Disabling
7.3. JSSE (SSL/TLS)的一些增强
8. Internationalization 增强 增加了对一些编码的支持和增加了一些显示方面的编码设置等
1. New Scripts and Characters from Unicode 6.0.0
2. Extensible Support for ISO 4217 Currency Codes
Currency类添加：
getAvailableCurrencies
getNumericCode
getDisplayName
getDisplayName(Locale)
3. Category Locale Support
getDefault(Locale.Category)FORMAT
4. Locale Class Supports BCP47 and UTR35
UNICODE_LOCALE_EXTENSION
PRIVATE_USE_EXTENSION
Locale.Builder
getExtensionKeys()
getExtension(char)
getUnicodeLocaleType(String
5. New NumericShaper Methods
NumericShaper.Range
getShaper(NumericShaper.Range)
getContextualShaper(Set&NumericShaper.Range&)……
9.jvm方面的一些特性增强，下面这些特性有些在jdk6中已经存在，这里做了一些优化和增强。
1.Jvm支持非java的语言 invokedynamic 指令
2. Garbage-First Collector 适合server端，多处理器下大内存，将heap分成大小相等的多个区域，mark阶段检测每个区域的存活对象，compress阶段将存活对象最小的先做回收，这样会腾出很多空闲区域，这样并发回收其他区域就能减少停止时间，提高吞吐量。
3. HotSpot性能增强
Tiered Compilation
-XX:+UseTieredCompilation 多层编译，对于经常调用的代码会直接编译程本地代码，提高效率
Compressed Oops
压缩对象指针，减少空间使用
Zero-Based Compressed Ordinary Object Pointers (oops) 进一步优化零基压缩对象指针，进一步压缩空间
4. Escape Analysis
逃逸分析，对于只是在一个方法使用的一些变量，可以直接将对象分配到栈上，方法执行完自动释放内存，而不用通过栈的对象引用引用堆中的对象，那么对于对象的回收可能不是那么及时。
5. NUMA Collector Enhancements
NUMA(Non Uniform Memory Access),NUMA在多种计算机系统中都得到实现,简而言之,就是将内存分段访问,类似于硬盘的RAID,Oracle中的分簇
10. Java 2D Enhancements
1. XRender-Based Rendering Pipeline -Dsun.java2d.xrender=True
2. Support for OpenType/CFF Fonts GraphicsEnvironment.getAvailableFontFamilyNames
3. TextLayout Support for Tibetan Script
4. Support for Linux Fonts
11. Swing Enhancements
2. Nimbus Look & Feel
3. Heavyweight and Lightweight Components
4. Shaped and Translucent Windows
5. Hue-Saturation-Luminance (HSL) Color Selection in JColorChooser Class
12. Jdk8 lambda表达式 最大的新增的特性，不过在很多动态语言中都已经原生支持。
原来这么写：
btn.setOnAction(new EventHandler&ActionEvent&() {
public void handle(ActionEvent event) {
System.out.println(&Hello World!&);
jdk8直接可以这么写：
btn.setOnAction(
event -& System.out.println(&Hello World!&)
更多示例：
public class Utils {
public static int compareByLength(String in, String out){
return in.length() - out.length();
public class MyClass {
public void doSomething() {
String[] args = new String[] {&microsoft&,&apple&,&linux&,&oracle&}
Arrays.sort(args, Utils::compareByLength);
13.jdk8的一些其他特性，当然jdk8的增强功能还有很多，大家可以参考http://openjdk.java.net/projects/jdk8/
用Metaspace代替PermGen
动态扩展，可以设置最大值，限制于本地内存的大小
Parallel array sorting 新APIArrays#parallelSort.
New Date & Time API
Clock clock = Clock.systemUTC(); //return the current time based on your system clock and set to UTC.
Clock clock = Clock.systemDefaultZone(); //return time based on system clock zone
long time = clock.millis(); //time in milliseconds from January 1st, 1970
更多内容可以看看附件ppt，示例代码可以参考：/zhwj184/jdk7-8demo
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：857273次
积分：11419
积分：11419
排名：第929名
原创：263篇
转载：11篇
评论：136条
(1)(1)(2)(2)(2)(1)(1)(2)(1)(36)(13)(11)(7)(1)(10)(12)(14)(1)(11)(14)(9)(41)(20)(1)(1)(2)(1)(6)(2)(10)(15)(4)(8)(10)(7)