＜Java＞lambda表达式及使用parallelStream().filter()过滤数据

1、lambda表达式特征

 * 1、可选类型声明：不需要声明参数类型，编译器可以统一识别参数值
 * 2、可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号   x -> x*2  接收一个参数，并且返回其2倍的数值
 * 3、可选的大括号：如果主体包含了一个语句，就不需要使用大括号
 * 4、可选的返回关键字：如果主体只有一个表达式返回值，那么编译器会自动返回值，大括号需要指明表达式返回了一个数值
 *
 * 1、不需要参数，返回值为5
 * () -> 5
 *
 * 2、接收一个参数（数字类型），返回其2倍的值
 * x -> x*2
 *
 * 3、接收两个参数（数字类型），返回两者的差值
 * (x,y) -> x-y
 *
 * 4、接收两个int型的数据，并返回两者的和
 * (int x,int y) -> x+y
 *
 * 5、接受一个String对象，并在控制台打印，不返回任何值（可以看作是返回void）
 * (String s) -> System.out.print(s)

lambda简单使用实例：

public class Java8Test {

    interface MathOperation{
        int operation(int a,int b);
    }

    private int operate(int a, int b, MathOperation mathOperation){
        return mathOperation.operation(a, b);
    }

    interface GreetingService{
        void sayMessage(String message);
    }

    public static void main(String[] args) {

        Java8Test tester=new Java8Test();

        //类型声明
        MathOperation addition=(int a,int b) -> a+b;

        //不声明类型
        MathOperation subOper=(a,b) -> a-b;

        //大括号中的返回语句
        MathOperation mult=(a,b) -> {return a*b;};

        //没有大括号及返回语句
        MathOperation div=(a,b) -> a/b;

        System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
        System.out.println("10 - 5 = " + tester.operate(10, 5, subOper));
        System.out.println("10 x 5 = " + tester.operate(10, 5, mult));
        System.out.println("10 / 5 = " + tester.operate(10, 5, div));

        //不用括号
        GreetingService service1=message -> System.out.println(message);

        //使用大括号
        GreetingService service2=message -> {
            System.out.println(message);
        };

        service1.sayMessage("Runoob");
        service2.sayMessage("Google");

    }

}

运行结果：

10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Runoob
Google

2、遍历集合

public static void main(String[] args) {

    String[] arr= {"Rafael Nadal", "Novak Djokovic",
            "Stanislas Wawrinka",
            "David Ferrer","Roger Federer",
            "Andy Murray","Tomas Berdych",
            "Juan Martin Del Potro"};
    List<String> playerList= Arrays.asList(arr);

    playerList.forEach(player -> System.out.println(player+"; "));
}

运行结果：

Rafael Nadal; 
Novak Djokovic; 
Stanislas Wawrinka; 
David Ferrer; 
Roger Federer; 
Andy Murray; 
Tomas Berdych; 
Juan Martin Del Potro; 

playerList.forEach(player -> System.out.println(player+"; "));

这里的player就类似

for(String player:playerList){
	System.out.println(player+"; ");
}

在lambda表达式中可以不声明类型，编译器可以统一识别参数值

3、对数据进行过滤

    public static void main(String[] args) {
        List<Integer> list= Arrays.asList(1,2,3,4,5,6,7,8,9,10);

        //过滤掉奇数，并将过滤后得到的数据添加到新的集合中
        List<Integer> newList1=list.parallelStream().filter(i -> i%2==0).collect(Collectors.toList());
        newList1.forEach(i -> System.out.print(i+" "));
        System.out.println("\n=================================");

        //过滤掉奇数，并且对过滤后的数据进行加100的操作，然后再添加到新的集合中
        List<Integer> newList2=list.parallelStream().filter(i -> i%2==0).map(i -> i+100).collect(Collectors.toList());
        newList2.forEach(i -> System.out.print(i+" "));
        System.out.println("\n==================================");

        //统计大于3的元素的个数,返回值是long类型的
        long count=list.parallelStream().filter(i -> i>3).count();
        System.out.println("大于3的元素个数为："+count);
    }

运行结果：

2 4 6 8 10 
=================================
102 104 106 108 110 
==================================
大于3的元素个数为：7