【Java】工作中常用的一些lambda表达式

工作中常用的一些lambda表达式

  • lambda表达式
    • 常用方法
      • foreach
      • Collect
      • Filter
      • map
      • distinct
      • sorted
      • findFirst
      • Reduce
      • Peek
    • 如果链式调用中集合已经为空
    • 函数式接口
    • Optional
    • 其他知识点

lambda表达式

常用方法

foreach

相当于for循环遍历

public void testForEach(){
        List<String> list = new ArrayList<String>() {{
            add("1");
            add("2");
            add("3");
        }};

        list.forEach(s-> System.out.println(s));
    }

Collect

将操作后的对象转换为新的对象

public static void testCollect(){
        List<String> list = new ArrayList<String>() {{
            add("1");
            add("2");
            add("2");
        }};

        //转换为新的list
        List newList = list.stream().map(s -> Integer.valueOf(s)).collect(Collectors.toList());
        // 此处泛型会被抹掉 输出class java.util.ArrayList
        System.out.println(newList.getClass());
    }

Filter

满足filter表达式的内容会被留下来,不满足的会被过滤掉。

public static void testFilter() {
        List<String> list = new ArrayList<String>() {{
            add("1");
            add("2");
            add("3");
        }};

        List<String> newList = list.stream()
            // 过滤掉我们希望留下来的值
            // 表示我们希望字符串是 1 能留下来
            // 其他的过滤掉
            .filter(str -> "1".equals(str))
            .collect(Collectors.toList());
        newList.forEach(s -> System.out.println(s));
    }

map

map 方法可以让我们进行一些流的转化,比如原来流中的元素是 A,通过 map 操作,可以使返回的流中的元素是 B

public void testMap() {
        List<String> list = new ArrayList<String>() {{
            add("1");
            add("2");
            add("3");
        }};
        //通过 map 方法list中元素转化成 小写
        List<String> strLowerList = list.stream()
                .map(str -> str.toLowerCase())
                .collect(Collectors.toList());
    }

distinct

去重

public void testDistinct(){
        List<String> list = new ArrayList<String>() {{
            add("1");
            add("2");
            add("2");
        }};
        list.stream()
                .map(s -> Integer.valueOf(s))
                .distinct()
                .collect(Collectors.toList());
    }

sorted

排序,可以在sorted里面自定义排序规则

public void testSorted(){
        List<String> list = new ArrayList<String>() {{
            add("1");
            add("2");
            add("3");
        }};
        list.stream()
                .map(s -> Integer.valueOf(s))
                // 等同于 .sorted(Comparator.naturalOrder()) 自然排序
                .sorted()
                .collect(Collectors.toList());

        // 自定义排序器
        list.stream()
                .map(s -> Integer.valueOf(s))
                // 反自然排序
                .sorted(Comparator.reverseOrder())
                .collect(Collectors.toList());
    }

findFirst

findFirst 表示匹配到第一个满足条件的值就返回

public void testFindFirst(){
        List<String> list = new ArrayList<String>() {{
            add("1");
            add("2");
            add("2");
        }};
        
        list.stream()
                .filter(s->"2".equals(s))
                .findFirst()
                .get();
        
        // 防止空指针
        list.stream()
                .filter(s->"2".equals(s))
                .findFirst()
                // orElse 表示如果 findFirst 返回 null 的话,就返回 orElse 里的内容
                .orElse("3");

        Optional<String> str= list.stream()
                .filter(s->"2".equals(s))
                .findFirst();
        // isPresent 为 true 的话,表示 value != null
        if(str.isPresent()){
            return;
        }
    }

Reduce

reduce 方法允许我们在循环里面叠加计算值

public void testReduce(){
        List<String> list = new ArrayList<String>() {{
            add("1");
            add("2");
            add("3");
        }};
        
        list.stream()
                .map(s -> Integer.valueOf(s))
                // s1 和 s2 表示循环中的前后两个数
                .reduce((s1,s2) -> s1+s2)
                .orElse(0);

        list.stream()
                .map(s -> Integer.valueOf(s))
                // 第一个参数表示基数,会从 100 开始加
                .reduce(100,(s1,s2) -> s1+s2);
    }

Peek

在 peek 方法里面做任意没有返回值的事情,比如打印日志

public void testPeek(){
        List<String> list = new ArrayList<String>() {{
            add("1");
            add("2");
            add("3");
        }};
        list.stream().map(s -> Integer.valueOf(s))
                .peek(s -> System.out.println(s))
                .collect(Collectors.toList());
    }

如果链式调用中集合已经为空

如果链式调用中集合内容已经为空,此时最后结果不会报错,只是返回结果为空集合。

public static void testEmptyCollection() {
        List<String> testList = new ArrayList<>();
        testList.add("1");
        testList.add("2");
        testList.add("3");
        testList.add("4");
        Map<String, String> collect = testList.stream().filter(u -> "0".equals(u)).collect(Collectors.toMap(key -> key, value -> ""));
        System.out.println(collect);
    }

// {}

函数式接口

函数式接口 参数类型 返回类型 方法名 描述
Supplier T get 产生一个类型为T的数据
Consumer T void accept 消费一个类型为T的数据
BiConsumer T,U void accept 消费类型为T和类型为U的数据
Function T R apply 把参数类型为T的数据经过函数处理转换成类型为R的数据
BiFunction T,U R apply 把参数类型为T和U的数据经过函数处理转换成类型为R的数据
UnaryOperator T T apply 对类型T进行了一元操作,仍返回类型T
BinaryOperator T,T T apply 对类型T进行了二元操作,仍返回类型T
Predicate T void test 对类型T进行函数处理,返回布尔值
BiPredicate T,U void test 对类型T和U进行函数处理,返回布尔值

Optional

Optional.ofNullable() 创建一个Optional,传入的值可以是null或不是null。

【Java】工作中常用的一些lambda表达式_第1张图片

of() 方法,返回一个Optional对象。
【Java】工作中常用的一些lambda表达式_第2张图片

empty() 方法:返回一个空的Optional方法

【Java】工作中常用的一些lambda表达式_第3张图片
isPresent() 方法:判断是否有值

在这里插入图片描述

isPresent() 方法:如果有值就执行入参的lambda函数。

【Java】工作中常用的一些lambda表达式_第4张图片

get() 方法:获取Optional的值,如果为空则抛出异常。

【Java】工作中常用的一些lambda表达式_第5张图片

orElse() 方法:没有值时会返回指定的值。

【Java】工作中常用的一些lambda表达式_第6张图片

orElseGet() 方法:

【Java】工作中常用的一些lambda表达式_第7张图片

filter() 方法:用于过滤Optional中的值,若Optional中有值,且值满足过滤函数,则返回此Optional,否则返回空Optional.

map() 方法:用于转换值,若Optional有值,执行map中的lambda函数转换值。

Order order = getOrderById(orderId);
String userCode = Optional.ofNullable(order)
    .map(Order::getUser)
    .map(User::getUserCode)
    .map(String::toUpperCase)
    .orElse("")

其他知识点

  1. 如果lambda表达式已经有实现的方法了,则可以用方法引用进行简化。语法为:
  • 对象::实例方法
  • 类::静态方法
  • 类::实例方法
  1. 在Java的匿名内部类中,如果要引用外部变量,变量是需要声明为final的,虽然Lambda表达式的自由变量不用强制声明成final,但同样也是不允许修改的。原因

  2. lambda表达式原理

你可能感兴趣的:(学习时候记录的笔记,java)