看看JDK 8 给我们带来什么

旧方式：

new Thread(new Runnable() {  
         @Override 
         public void run() {  
             for (int i=0; i< 9; i++) {  
                 System.out.println(String.format("Message #%d from inside the thread!", i));  
             }  
         }  
     }).start(); 

新方式:

new Thread(() -> {  
      for (int i=0; i< 9; i++) {  
         System.out.println(String.format("Message #%d from inside the thread!", i));  
      }  
  }).start(); 

即使我还没有写过与java swing,AWT相关的功能，但是我还是可以断定：lambdas肯定会给那些Swing开发者带去很多的便利。

动作监听：

JButton button = new JButton("Click");  
 
// NEW WAY:  
button.addActionListener( (e) -> {  
    System.out.println("The button was clicked!");  
});  
 
// OLD WAY:  
button.addActionListener(new ActionListener() {  
          @Override 
          public void actionPerformed(ActionEvent e) {  
              System.out.println("The button was clicked using old fashion code!");  
          }  
      }); 

什么是SAM？SAM 是单个抽象方法的替代，因此，直接一点，我们可以说SAM==功能性接口。即使在最初的规范里面，只有一个抽象方法的抽象类被认为是SAM类型的，很多人还是发现/猜出了这样定义的原因。

方法/构造方法 引用

lambdas表达式听起来不错？但是不知为何功能接口带有一定的限制性- 那是否意味着我只能用包含单个抽象方法的接口呢？不见得——JDK8提供了一个别名机制，允许类或者对象的方法“调用”。用一个新增的操作符::可以做到。他可以应用到静态方法或者对象方法的调用。同样也可以应用于构造函数。

参考代码：

interface ConstructorReference {  
    T constructor();  
}  
 
interface  MethodReference {  
    void anotherMethod(String input);  
}  
 
public class ConstructorClass {  
    String value;  
 
    public ConstructorClass() {  
        value = "default";  
    }  
 
    public static void method(String input) {  
        System.out.println(input);  
    }  
 
    public void nextMethod(String input) {  
        // operations  
    }  
 
    public static void main(String... args) {  
        // constructor reference  
        ConstructorReference reference = ConstructorClass::new;  
        ConstructorClass cc = reference.constructor();  
 
        // static method reference  
        MethodReference mr = cc::method;  
 
        // object method reference  
        MethodReference mr2 = cc::nextMethod;  
 
        System.out.println(cc.value);  
    }  
} 

在接口中的默认方法

这意味着从版本8，JAVA接口可以含有方法体，所以为了使其简单，JAVA将支持多重继承，摆脱了以前比如头痛的问题。并且，通过为接口方法提供默认的实现，可以保证确保添加一个亲的方法不会在实现类中制造混乱。JDK8已经加入了默认方法到接口中如：java.util.Collection 和 java.util.Iterator，并且通过这个功能，可以提供一个机制去更好地在我们真的需要时使用lambdas。

已经加入的主要接口了：

java.util.stream.Streamable  
java.util.stream.Stream 

改进了集合的互动

在我看来，所有lambda工程的改变都是对语言的极大补充，这将会使本语言与当前标准对齐，使其更简单、更简洁，但是这些改变可能使得本语言有最大的效率影响和最大的酷+哇效应，进而使集合框架将会有彻底的改造。但是，这没有集合2框架的概念，我们现在依然必须去做类型探险处理，但是JAVA将有其他重要方面的改变：从外部到内部的迭代。如此，它提供开发者的机制去过滤和用一个优雅的方式去聚合集合，除此之外，还提高了效率。通过提供lambda表达式，将会在内部被执行，这样，就可以充分利用多核处理器的功能了。

让我们考虑以下场景：

a.假如有一个字符串列表，选择该列表的所有对象然后转换成大写字母。这该如何写呢?

旧方法如下：

//.....  
 List inputList = new LinkedList<>();  
 List upper = new LinkedList<>();  
 // add elements  
 for (String currentValue : inputList) {  
   if (currentValue != null && currentValue.matches("*")) {  
       upper.add(currentValue);  
   }  
 }  
 System.out.println(upper);    

新方法：

//.....  
 inputList.stream().filter(x -> (x != null && x.matches("[A-Z0-9]*"))).into(upper); 

b.假如你想要把所有提取的字符转换成小写字母。用JDK8的方法做将会像如下这样做：

/ .....  
  inputList.stream().filter(x -> (x != null && x.matches("[A-Z0-9]*"))).map(String::toLowerCase).into(upper); 

c. 如何从选定的集合中找出 字符 的 数量：

// .....    
 int sumX = inputList.stream().filter(x -> (x != null && x.matches("[A-Z0-9]*"))).map(String::length).reduce(0, Integer::sum); 

用到的方法：

default Stream stream() // java.util.Collection  
 Stream filter(Predicate predicate) // java.util.stream.Stream  
 IntStream map(IntFunction mapper) //java.util.stream.Stream 

d.如果要从集合中取出每个元素然后打印，该怎样做呢？

//旧方法:  
for (String current : list) {  
  System.out.println(current);  
}  
 //新方法:  
 list.forEach(x -> System.out.println(x)); 

除了以上提到的功能外，JDK8还有其他有趣的新功能，但为了简洁篇幅，在此不做介绍。更多关于JDK8的信息可以在JDK8 [a href="http://jdk8.java.net/lambda/"]的lambda项目或者   JSR 337网页上得到。

总而言之,Java正在不断地改进,我个人喜欢它未来的方向，另外一个喜欢的点就是当类库开发人员开始采用JDK 8的时候。这将肯定会很有趣的一件事。

相关资料

Brian Goetz资源目录：http://cr.openjdk.java.net/~briangoetz/lambda

方法/构造函数参考：http://doanduyhai.wordpress.com/2012/07/14/java-8-lambda-in-details-part-iii-method-and-constructor-referencing