java 添加数据后自动刷新怎么设置 java新增

         Lambda表达式也成为闭包，是java语言层次上的改变，Lambda同意把函数作为一个方法的參数（函数作为參数传递进方法中），或者把代码看成数据。函数式程序猿对这一概念非常熟悉。

在JVM平台上有非常多语言（groovy，scala等等）从一開始就有Lambda，可是程序猿不得不使用匿名类来取代lambda。

看一下jdk7之前实现字符串排序：

package com.panther.dong.java8.lambda;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * Created by panther on 15-8-22.
 */
public class Old {

    public static void main(String[] args) {
        List<String> nameList = Arrays.asList("panther","peter","lucy","jake");
        Collections.sort(nameList, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        System.out.println(nameList);

    }
}

执行结果：

仅仅须要给静态方法传入一个List对象以及一个比較器来按制定顺序排列，通常的方法是创建一个匿名的比較器对象然后将其传递给sort方法。

看一下java8怎么用lambda实现上述功能：

package com.panther.dong.java8.lambda;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * Created by panther on 15-8-22.
 */
public class New {

    public static void main(String[] args) {
        List<String> nameList = Arrays.asList("panther", "peter", "lucy", "jake");
        //第一种写法
        Collections.sort(nameList, (String a, String b) -> {
            return b.compareTo(a);
        });
        //另外一种写法
        Collections.sort(nameList, (a, b) -> {
            return b.compareTo(a);
        });
        //第三种写法
        Collections.sort(nameList, (a, b) -> b.compareTo(a));

        nameList.forEach(e -> System.out.println(e));
    }
}

执行结果：

java编译器能够自己主动推导出參数类型。所以你能够不用再写一次类型！！！！

       看以下lambda的样例：

代码：

package com.panther.dong.java8.lambda;

import java.util.Arrays;
import java.util.List;

/**
 * Created by panther on 15-8-22.
 */
public class LambdaTest {
    public static String separator = ",";

    public static void main(String[] args) {
        //Lambda能够把函数体放到一对花括号里，就像在java中定义普通函数那样
        System.out.println("-----Lambda Test1-----");
        Arrays.asList("a", "b", "c", "d").forEach(e -> {
            System.out.println(e);
        });

        //Lambda能够引用类的成员变量和局部变量(假设变量不是final的话，它会被隐含的转为final。这样效率更高)
        System.out.println("--------Lambda Test2--------");
        Arrays.asList("a", "b", "c", "d").forEach((String e) -> System.out.println(e + LambdaTest.separator));

        System.out.println("--------Lambda Test3---------");
        List<String> resultList = Arrays.asList("a", "c", "b", "d");
        resultList.sort((e1, e2) -> {
            int result = e1.compareTo(e2);
            return result;
        });

        resultList.forEach(e -> {
            System.out.println(e);
        });
    }
}

执行结果：

Lambda表达式介绍完成。！！！

~~~~~

         Lambda表达式也成为闭包，是java语言层次上的改变，Lambda同意把函数作为一个方法的參数（函数作为參数传递进方法中），或者把代码看成数据。函数式程序猿对这一概念非常熟悉。

在JVM平台上有非常多语言（groovy，scala等等）从一開始就有Lambda，可是程序猿不得不使用匿名类来取代lambda。

看一下jdk7之前实现字符串排序：

package com.panther.dong.java8.lambda;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * Created by panther on 15-8-22.
 */
public class Old {

    public static void main(String[] args) {
        List<String> nameList = Arrays.asList("panther","peter","lucy","jake");
        Collections.sort(nameList, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        System.out.println(nameList);

    }
}

执行结果：

仅仅须要给静态方法传入一个List对象以及一个比較器来按制定顺序排列，通常的方法是创建一个匿名的比較器对象然后将其传递给sort方法。

看一下java8怎么用lambda实现上述功能：

package com.panther.dong.java8.lambda;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * Created by panther on 15-8-22.
 */
public class New {

    public static void main(String[] args) {
        List<String> nameList = Arrays.asList("panther", "peter", "lucy", "jake");
        //第一种写法
        Collections.sort(nameList, (String a, String b) -> {
            return b.compareTo(a);
        });
        //另外一种写法
        Collections.sort(nameList, (a, b) -> {
            return b.compareTo(a);
        });
        //第三种写法
        Collections.sort(nameList, (a, b) -> b.compareTo(a));

        nameList.forEach(e -> System.out.println(e));
    }
}

执行结果：

java编译器能够自己主动推导出參数类型。所以你能够不用再写一次类型！！！！

       看以下lambda的样例：

代码：

package com.panther.dong.java8.lambda;

import java.util.Arrays;
import java.util.List;

/**
 * Created by panther on 15-8-22.
 */
public class LambdaTest {
    public static String separator = ",";

    public static void main(String[] args) {
        //Lambda能够把函数体放到一对花括号里，就像在java中定义普通函数那样
        System.out.println("-----Lambda Test1-----");
        Arrays.asList("a", "b", "c", "d").forEach(e -> {
            System.out.println(e);
        });

        //Lambda能够引用类的成员变量和局部变量(假设变量不是final的话，它会被隐含的转为final。这样效率更高)
        System.out.println("--------Lambda Test2--------");
        Arrays.asList("a", "b", "c", "d").forEach((String e) -> System.out.println(e + LambdaTest.separator));

        System.out.println("--------Lambda Test3---------");
        List<String> resultList = Arrays.asList("a", "c", "b", "d");
        resultList.sort((e1, e2) -> {
            int result = e1.compareTo(e2);
            return result;
        });

        resultList.forEach(e -> {
            System.out.println(e);
        });
    }
}

执行结果：

Lambda表达式介绍完成。！！！

~~~~~