当前位置 : 主页 > 编程语言 > 其它开发 >

java编程之Lambda、Stream、Optional

来源:互联网 收集:自由互联 发布时间:2022-05-30
代码整洁之道 Lambda Lambda 表达式,也可称为闭包,它是推动 Java 8 发布的最重要新特性。 Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。 使用 Lambda 表达式可以使

代码整洁之道

Lambda

Lambda 表达式,也可称为闭包,它是推动 Java 8 发布的最重要新特性。

Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。 -- 摘自runoob

可以理解lambda表达式为方法接口,具体中只有一个方法,当传入这个方法体时候就代表此方法,如下代码所示

// 接口类
@FunctionalInterface
interface Lu {
    void speak(String str);
}

//  通过 -> 指向具体方法 , 多行可以用{} 
Lu lu = str -> System.out.println(str);
lu.speak("abc");


// 或者通过方法指向 class::Method
interface MyComparet<T> {
    Object compare(int x, int y);
}
class NumberComparetor {
    public static int compareMax(int i, int j) {
        return i > j ? i : j;
    }
}
// 将NumberComparetor::compareMax方法指向 MyComparet默认实现方法,就可以直接调用
MyComparet comparet = NumberComparetor::compareMax;
System.out.println(comparet.compare(1, 2));

使用 Lambda 表达式需要注意以下两点:

  1. Lambda 表达式主要用来定义行内执行的方法类型接口,例如,一个简单方法接口。在上面例子中,我们使用各种类型的Lambda表达式来定义MathOperation接口的方法。然后我们定义了sayMessage的执行。
  2. Lambda 表达式免去了使用匿名方法的麻烦,并且给予Java简单但是强大的函数化的编程能力。
Stream流 什么是Stream流

​ Java8中的Stream是对容器对象功能的增强,它专注于对容器对象进行各种非常便利、高效的聚合操作(aggregate operation),或者大批量数据操作 (bulk data operation)。Stream API借助于同样新出现的Lambda表达式,极大的提高编程效率和程序可读性。同时,它提供串行和并行两种模式进行汇聚操作,并发模式能够充分利用多核处理器的优势,使用fork/join并行方式来拆分任务和加速处理过程。通常,编写并行代码很难而且容易出错, 但使用Stream API无需编写一行多线程的代码,就可以很方便地写出高性能的并发程序。所以说,Java8中首次出现的 java.util.stream是一个函数式语言+多核时代综合影响的产物。

流的创建
  1. 集合生成,目前最常用的一种
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 6);
Stream<Integer> stream = integerList.stream();
  1. 数组生成
int[] intArr = {1, 2, 3, 4, 5, 6};
IntStream stream = Arrays.stream(intArr);
  1. 文件生成
Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset());
流的操作

0.数据源对象

// 基础操作对象
List<Integer> list = Arrays.asList(1, 1, 2, 3, 5, 7, 4, 5, 6, 7);
// 集合操作对象  Student类有name和age两个属性
List<Student> studentList = Arrays.asList(new Student("张三",18),
                new Student("李四",19),new Student("王五",8),new Student("孙七",66));

1.filter过滤

List<Integer> collect = list.stream().filter(e -> {
            return e < 5; // 元素必须小于5
        }).collect(Collectors.toList());
collect.forEach(e -> System.out.print(e+"-"));

输出: 1-1-2-3-4-

2.distinct 去重

Stream<Integer> distinct = list.stream().distinct();
distinct.forEach(e -> System.out.print(e+"-"));

输出: 1-2-3-5-7-4-6-

3.limit 返回指定个数

Stream<Integer> limit = list.stream().limit(5);
limit.forEach(e -> System.out.print(e+"-"));
输出:1-1-2-3-5-

4.skip 跳过指定数量

Stream<Integer> skip = list.stream().skip(3);  // 跳过前3位
skip.forEach(e -> System.out.print(e+"-"));
输出: 3-5-7-4-5-6-7-

5.Map 流映射--字段属性筛选

List<String> studentName = studentList.stream().map(Student::getName).collect(Collectors.toList());
        studentName.forEach(e -> System.out.print(e+"-"));

输出:张三-李四-王五-孙七   name组成的集合

6.reduce 元素进行计算,初始为0, 后面是计算方式 可以 sum , max , min ... ...

// sum 累计求和
Integer sumReduce = list.stream().reduce(0, Integer::sum);
System.out.println(sumReduce);

输出:41  

7.max/min 对比 , 返回为option

// 跳过5位后, min 取最小        
Integer min = list.stream().skip(5).min(Integer::compareTo).get();
System.out.println(min);

输出: 4

8.collect 返回集合

// 转Set集合        
Set<Integer> setCollect = list.stream().collect(Collectors.toSet());
setCollect.forEach(e -> System.out.print(e+"-"));

输出: 1-2-3-4-5-6-7-

9.join 数据拼接

String joining = list.stream().map(String::valueOf).collect(Collectors.joining("-"));
System.out.println(joining);
输出:1-1-2-3-5-7-4-5-6-7

10.groupingBy分组

Map<String, List<Student>> stringListMap = 			  studentList.stream().collect(Collectors.groupingBy(Student::getName));
System.out.println(stringListMap);
输出: {孙七=[com.study.lambda.Student@3d8c7aca], 李四=[com.study.lambda.Student@5ebec15], 张三=[com.study.lambda.Student@21bcffb5], 王五=[com.study.lambda.Student@380fb434]}
{李四=19, 孙七=66, 张三=18, 王五=8}

11.toMap,对象集合转Map对象集合

// 字段转换        
Map<String, Integer> nameAgeMap = studentList.stream().collect(Collectors.toMap(Student::getName, Student::getAge));
        System.out.println(nameAgeMap);
输出:{李四=19, 孙七=66, 张三=18, 王五=8}
// 对象转换
Map<String, Student> studentMap = studentList.stream().collect(Collectors.toMap(Student::getName , t->t));
        System.out.println(studentMap);
输出:{李四=com.study.lambda.Student@5ebec15, 孙七=com.study.lambda.Student@3d8c7aca, 张三=com.study.lambda.Student@21bcffb5, 王五=com.study.lambda.Student@380fb434}
// 对象自定义Max
        Student student = studentList.stream().max((a, b) -> a.getAge() > b.getAge() ? 1 : -1).get();
        System.out.println(student);
输出:孙七---66
Optional 概述
  • Optional 是个容器:它可以保存类型T的值,或者仅仅保存null。Optional提供很多有用的方法,这样我们就不用显式进行空值检测。
  • Optional 类的引入很好的解决空指针异常。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。
构建
		// 构建一个Optional对象;方法有:empty( )、of( )、ofNullable( )

		// 定值非空的Optional实例
        Optional<Student> student = Optional.of(new Student("张三", 55));
        // 返回一个空的Optional实例。 此Optional没有值
        Optional<Object> empty = Optional.empty();
        // 返回一个Optional与如果指定值是非当前值null ,否则一个空Optional
        Optional<Student> zs = Optional.ofNullable(new Student("张三", 55));
源码解析
package java.util;

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;

/**
一个可能包含也可能不包含非null值的容器对象。 如果存在值,则isPresent()返回true 。 如果不存在任何值,则该对象被视为空,并且isPresent()返回false 。
提供了其他取决于所包含值是否存在的方法,例如orElse() (如果不存在值,则返回默认值)和ifPresent() (如果存在值,则执行操作)。
这是一个基于值的类; 在Optional实例上使用标识敏感的操作(包括引用等于( == ),标识哈希码或同步)可能会产生不可预测的结果,应避免使用
 */
public final class Optional<T> {
    /**
     * empty()通用实例
     */
    private static final Optional<?> EMPTY = new Optional<>();

    /**
     * 如果不为空,则为该值;否则为false。 如果为null,则表示不存在任何值
     */
    private final T value;

    /**
        构造一个空实例。
        impl注意:
        通常,每个VM仅应存在一个空实例EMPTY 
     */
    private Optional() {
        this.value = null;
    }

    /**
        返回一个空的Optional实例。 此Optional没有值。
        类型参数:<T> –不存在的值的类型
        返回值:一个空的Optional
        api注意:
        尽管这样做可能很诱人,但应通过将==与Optional.empty()返回的实例进行比较来避免测试对象是否为空。 不能保证它是一个单例。 而是使用isPresent() 
     */
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    /**
        使用描述的值构造一个实例。
        参数:值–要描述的非null值
        抛出:NullPointerException如果值为null
     */
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    /**
        返回一个Optional描述给定的非null值。
        参数:value –要描述的值,必须为非null
        类型参数:<T> –值的类型
        返回值:存在值的Optiona
     */
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    /**
        返回一个描述给定值的Optional ,如果不为null ,则返回一个空的Optional 。
        参数:值–描述的可能为null值
        类型参数:<T> –值的类型
        返回值:一个Optional与如果指定值是非当前值null ,否则一个空Optional
     */
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

    /**
        如果存在值,则返回该值,否则抛出NoSuchElementException 。
        返回值:此Optional描述的非null值
        抛出:NoSuchElementException如果不存在任何值
        api注意:此方法的首选替代方法是orElseThrow() 。
     */
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    /**
        如果存在值,则返回true ,否则返回false 。

        返回值:如果存在值,则为true ,否则为false
     */
    public boolean isPresent() {
        return value != null;
    }

    /**
        如果不存在值,则返回true ,否则返回false 。

        返回值:如果不存在值,则为true ,否则为false
     */
    public boolean isEmpty() {
        return value == null;
    }

    /**
        如果存在值,则使用该值执行给定的操作,否则不执行任何操作。
        参数:动作–要执行的动作(如果存在值)
     */
    public void ifPresent(Consumer<? super T> action) {
        if (value != null) {
            action.accept(value);
        }
    }

    /**
        如果存在值,则使用该值执行给定的操作,否则执行给定的基于空的操作。
        参数:动作–要执行的动作(如果存在值)emptyAction –要执行的基于空的操作(如果不存在任何值)
        抛出:NullPointerException如果存在一个值并且给定的操作为null ,或者不存在任何值并且给定的基于空的操作为null 
     	@since 9
     */
    public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
        if (value != null) {
            action.accept(value);
        } else {
            emptyAction.run();
        }
    }

    /**
        如果存在一个值,并且该值与给定的谓词匹配,则返回描述该值的Optional ,否则返回一个空的Optional 。

        参数:谓词–应用于值的谓词(如果存在)
        返回值:一个Optional描述此的值Optional ,如果一个值存在并且该值给定的谓词相匹配,否则一个空Optional
        抛出:NullPointerException如果谓词为null
     */
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent()) {
            return this;
        } else {
            return predicate.test(value) ? this : empty();
        }
    }

    /**
        如果存在值,则返回一个Optional描述(就像by ofNullable ),将给定映射函数应用于该值的结果,否则返回一个空的Optional 。
        如果映射函数返回null结果,则此方法返回空的Optional 
     */
    public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent()) {
            return empty();
        } else {
            return Optional.ofNullable(mapper.apply(value));
        }
    }

    /**
         如果存在一个值,则返回将给定Optional -bearing映射函数应用于该值的结果,否则返回一个空的Optional 。
        此方法类似于map(Function) ,但是映射函数是其结果已经是Optional函数,如果调用该函数,则flatMap不会将其包装在其他Optional 。

        参数:mapper –应用于值的映射函数(如果存在)
        类型参数:<U> –映射函数返回的Optional值的类型
        返回值:施加的结果Optional荷瘤映射函数此的值Optional ,如果一个值存在,否则一个空Optional
        抛出:NullPointerException如果映射函数为null或返回null结果

     */
    public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent()) {
            return empty();
        } else {
            @SuppressWarnings("unchecked")
            Optional<U> r = (Optional<U>) mapper.apply(value);
            return Objects.requireNonNull(r);
        }
    }

    /**
        如果值存在时,返回一个Optional描述的值,否则将返回一个Optional产生通过供给功能。

        参数:供应商–产生要返回的Optional的供应功能
        返回值:返回一个Optional描述此的值Optional ,如果一个值存在,否则Optional所生产的供应功能。
        抛出:NullPointerException如果提供的函数为null或产生null结果
     * @since 9
     */
    public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
        Objects.requireNonNull(supplier);
        if (isPresent()) {
            return this;
        } else {
            @SuppressWarnings("unchecked")
            Optional<T> r = (Optional<T>) supplier.get();
            return Objects.requireNonNull(r);
        }
    }

    /**
        如果存在值,则返回仅包含该值的顺序Stream ,否则返回空Stream 。

        返回值:作为Stream的可选值
     * @since 9
     */
    public Stream<T> stream() {
        if (!isPresent()) {
            return Stream.empty();
        } else {
            return Stream.of(value);
        }
    }

    /**
        如果存在值,则返回该值,否则返回other 。

        参数:其他–要返回的值(如果不存在任何值)。 可以为null 。
        返回值:值(如果存在),否则other
     */
    public T orElse(T other) {
        return value != null ? value : other;
    }

    /**
        如果存在值,则返回该值,否则返回由供应函数产生的结果。

        参数:供应商–产生要返回的值的供应函数
        返回值:值(如果存在),否则提供功能产生的结果
     */
    public T orElseGet(Supplier<? extends T> supplier) {
        return value != null ? value : supplier.get();
    }

    /**
     * If a value is present, returns the value, otherwise throws
     * {@code NoSuchElementException}.
     *
     * @return the non-{@code null} value described by this {@code Optional}
     * @throws NoSuchElementException if no value is present
     * @since 10
     */
    public T orElseThrow() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    /**
        如果存在值,则返回该值,否则抛出由异常提供函数产生的异常。

        参数:exceptionSupplier –产生要抛出的异常的提供函数
        类型参数:<X> –引发的异常类型
        返回值:值(如果存在)
        抛出:X –如果不存在任何值NullPointerException如果不存在任何值并且异常提供函数为null
        api注意:带有空参数列表的对异常构造函数的方法引用可用作提供者
     */
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }
}
API使用
        // 获取,直接调用get,如果value为空就会报 NoSuchElementException 异常
        Student student1 = student.get();
//        Student student2 = emptyStudent.get(); // 报错

        // orElse 可以传入一个默认对象
        Student student3 =emptyStudent.orElse(new Student("error",-99));
        // orElseGet 可以传递 lambda表达式
        Student student2 = emptyStudent.orElseGet(() -> {
            return new Student("error",-99);
        });

        System.out.println(student1);
        System.out.println(student2);
        System.out.println(student3);
参考文档

java中Optional的使用详细解析 https://www.jb51.net/article/209639.htm

JAVA stream流详细教程 https://blog.csdn.net/QiuHaoqian/article/details/120942134

网友评论