<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
  • 1
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值