lambda常见使用方法

前言

之前在携程实习，遇到了lambda表达式，最近逛b站，刚好看到了。顺手整理一下。参考链接文章来源地址https://www.toymoban.com/news/detail-445843.html

介绍

• lambda是一种提高生产力的一种书写代码的方式。
• 代码中有很多的箭头，箭头左边是参数。例如，遍历的时候，每一个item，然后右边是要进行的操作。
• 代码中用到了很多的“::”其实就是调用这个方法，然后形参跟我传递进来的一样，所以直接不写形参了。例如s -> s.length()可以直接修改为String::length。

遍历

• 需求：打印list中的内容

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

public class 遍历 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "orange");
        // 传统方式
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        // lambda-非简写
        list.forEach(l -> System.out.println(l));

        // lambda-简写
        // 如果要调用一个方法，并且方法中只有传递一个参数，而参数就是list的item，那么可以不用写传递的参数了
        list.forEach(System.out::println);
    }
}

排序

• 需求：对list进行排序

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

public class Num2排序 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("banana", "apple", "orange");
        // 传统方式
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        
        // lambda
        // 这里面o1,o2就是上面重写的compare的两个参数，而后面的就是return的内容，这里会自动进行return
        list.sort((o1, o2) -> o1.compareTo(o2));
    }
}

过滤

• 需求：过滤list中首字母是a的元素

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;

public class Num3过滤 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("banana", "apple", "orange");
        // 传统方式
        List<String> list2 = new LinkedList<>();
        for (String s : list) {
            if (s.startsWith("a")) {
                list2.add(s);
            }
        }

        // lambda
        // 这里需要借助list的stream。并且filter以后，并不是list，需要使用.collect(Collectors.toList())转成list
        List<String> list3 = list.stream().filter(s -> s.startsWith("a")).collect(Collectors.toList());
    }
}

映射

• 统计list中每个元素的长度

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;

public class Num4映射 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("banana", "apple", "orange");
        // 传统方式
        List<Integer> list2 = new LinkedList<>();
        for (String s : list) {
            list2.add(s.length());
        }

        // lambda
        // 与过滤类似，但是这里需要用map。其实map表示我返回的不是之前的元素类型了。之前过滤的时候，返回的还是string，但是这里是要求Integer
        // 并且s -> s.length()可以直接修改为String::length
        List<Integer> list3 = list.stream().map(s -> s.length()).collect(Collectors.toList());
    }
}

归纳

• 需求：对元素进行求和

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

public class Num5归纳 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        // 传统方式
        int sum = 0;
        for (Integer i : list) {
            sum += i;
        }
        System.out.println(sum);

        // lambda
        // 这里依旧需要借助stream，然后使用reduce函数，第一个参数为变量初始值，也就是传统方法中sum的初始值。然后a表示上一次的sum值，b表示当前遍历的值
        // 这里(a, b) -> a + b可以直接使用Integer::sum
        int sum2 = list.stream().reduce(0, (a, b) -> a + b);
        System.out.println(sum2);
    }
}

分组

• 需求：根据元素的长度对元素进行分组

import java.util.*;
import java.util.stream.Collectors;

public class Num6分组 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("banana", "apple", "orange");
        // 传统方式
        Map<Integer, List<String>> groups = new HashMap<>();
        for (String s : list) {
            int length = s.length();
            if (!groups.containsKey(length)) {
                groups.put(length, new LinkedList<>());
            }
            groups.get(length).add(s);
        }

        // lambda
        // 这里用到了Collectors的groupingBy，注意Collectors是stream包中的
        Map<Integer, List<String>> groups2 = list.stream().collect(Collectors.groupingBy(String::length));
    }
}

实现接口

• 需求：实现一个接口

public class Num7接口 {
    public static void main(String[] args) {
        // 传统方式
        MyInterface myInterface = new MyInterface() {
            @Override
            public void doSomething(String s) {
                System.out.println(s);
            }
        };
        myInterface.doSomething("hello world！");

        // lambda
        // 这里可以是(s) -> System.out.println(s)
        MyInterface myInterface2 = System.out::println;
        myInterface2.doSomething("hello world！");
    }
}

interface MyInterface {
    void doSomething(String s);
}

线程

• 需求：创建线程，打印hello world！

    public class Num8线程 {
        public static void main(String[] args) {
            // 传统方式
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello world！");
                }
            });
            thread.start();
    
            // lambda
            // 其实就是实现接口
            Thread thread2 = new Thread(() -> System.out.println("hello World!"));
            thread2.start();
        }
    }

判空

• 需求：将字符串的内容转为大写

import java.util.Optional;

public class Num9判空 {
    public static void main(String[] args) {
        // 传统方式
        String str = "hello world!";
        if (str != null) {
            System.out.println(str.toUpperCase());
        }

        // lambda
        // 这里用到了Optional，然后进行判空，随后使用map进行类型转换，然后如果存在内容的话，就打印
        Optional.ofNullable(str).map(String::toUpperCase).ifPresent(System.out::println);
    }
}

流水线

• 需求：过滤出list中字母为a开头的，并且转成大写，然后继续排序

import java.util.*;
import java.util.stream.Collectors;

public class Num10流水线 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("banana", "apple", "orange");
        // 传统方式
        List<String> list2 = new LinkedList<>();
        for (String s : list) {
            if (s.startsWith("a")) {
                list2.add(s.toUpperCase());
            }
        }
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });

        // lambda
        List<String> list3 =
                list.stream().filter(s -> s.startsWith("a")).map(String::toUpperCase).sorted((o1, o2) -> o1.compareTo(o2)).collect(Collectors.toList());
    }
}

总结

• 如果需要用filter是继续过滤的，如果还需要修改这个元素，则需要使用map进行修改。
• 使用“::”的时候是在括号中的，并且之前的形式是由入参和入参传递到右侧方法的，而且顺序和个数一致。

到了这里，关于lambda常见使用方法的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！