JDK8新特性之Lambda表达式

Lambda表达式主要是替换了原有匿名内部类的写法，也就是简化了匿名内部类的写法。lambda语法结构：

(参数1,参数2...)->{重写方法的内容，不定义方法名}

先看一个使用匿名内部类定义一个新线程的方法：

    @Test
    public void test1(){
        new Thread(new Runnable() {

            @Override
            public void run() {
                for(int x=0;x<100;x++){
                    System.out.println("run..."+x);
                }
            }
        }).start();

        for(int x=0;x<100;x++){
            System.out.println("main..."+x);
        }
    }

使用lambda表达式则可以简化匿名内部类的写法：

    @Test
    public void test2(){
        new Thread(()->{
            for(int i=0;i<100;i++){
                System.out.println("run..."+i);
            }
        }).start();
        for(int i=0;i<100;i++){
            System.out.println("main..."+i);
        }
    }

好吧，代码是不是极大的简化了？

再来看看一个例子,传统方法过滤一个文件夹中的文件是这样的：

    @Test
    public void test3(){
        File file = new File("F:\\test");
        File[] fs = file.listFiles(new FileFilter() {

            @Override
            public boolean accept(File pathname) {
                //获取所有的xml文件
                return pathname.getName().endsWith(".xml");
            }
        });
        for(File f:fs){
            System.out.println(f.getName());
        }
    }

使用了lambda表达式之后怎样过滤文件呢？

    @Test
    public void test4(){
        File file = new File("F:\\test");
        //注意这里pathname前面的String不写
        File[] fs = file.listFiles((pathname)->{
            return pathname.getName().endsWith(".xml");
        });
        for(File f:fs){
            System.out.println(f.getName());
        }
    }

lambda表达式，既然是一种表达式，它就不是内部类，这样编译过后不会产生内部类，它只是内部类的另一种实现方式。

再看看给Set集合排序的例子：

传统方式是这样的：

    @Test
    public void test5() {
        Set<String> set = new TreeSet<String>(new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length() == 0 ? o1.compareTo(o2)
                        : o1.length() - o2.length();
            }
        });
        set.add("ac");
        set.add("acfa");
        set.add("acfadfada");
        set.add("ac5423543534524");
        System.out.println(set);
    }

使用了lambda表达式之后呢？

    @Test
    public void test6() {
        //注意这里的参数名可以自定义
        Set<String> set = new TreeSet<String>((s1,o2)->{
            return s1.length() - o2.length() == 0 ? s1.compareTo(o2)
                    : s1.length() - o2.length();
        });
        set.add("ac");
        set.add("acfa");
        set.add("acfadfada");
        set.add("ac5423543534524");
        System.out.println(set);
    }

lambda局限性：

1.如果接口有多个方法需要实现，就只能通过匿名内部类来实现，而不可以使用lambda表达式。

2.要使用lambda表达式的地方参数本身就是固定的，只有一个，例如new Thread()，要么没有参数，要么只能是new Runnable().