[JavaSE]第十五章 Java8新特性

最新推荐文章于 2024-08-08 22:50:50 发布
最新推荐文章于 2024-08-08 22:50:50 发布
阅读量129 收藏
点赞数
分类专栏： JavaSE 文章标签： java java-ee 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47168123/article/details/123057979
版权

15.1 Lambda 表达式

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使 Java 的语言表达能力得到了提升

  • Lambda 表达式的本质：作为接口的实例（只能有一个抽象方法）

15.1.1 Lambda 格式

  • 格式：(o1, o2) -> Integer.compare(o1, o2)
    • ->：lambda 操作符 或 箭头操作符
    • ->左边：lambda 形参列表（其实就是接口中的抽象方法的形参列表）
    • ->右边：lambda 体（其实就是重写的抽象方法的方法体）

15.1.2 Lambda 使用

  • Lambda表达式的使用：（分六种情况介绍）
    • 总结：
      • ->左边：lambda 形参列表的参数类型可以省略（类型推断）；如果 lambda 形参列表只有一个参数，其一对 () 也可以省略
      • ->右边：lambda 体应该使用一对 {} 包裹；如果 lambda 体只有一条执行语句（可能是 return 语句），可以省略这一对 {} 和 return 关键字
    • 匿名实现类表示的都可以用 Lambda 表达式来写
	//语法格式一：无参，无返回值
    @Test
    public void test1() {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱Java");
            }
        };
        r1.run();

        System.out.println("**********************");

        Runnable r2 = () -> System.out.println("我爱Python");
        r2.run();
    }

    //语法格式二：Lambda需要一个参数，但是没有返回值
    @Test
    public void test2() {
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("谎言和誓言的区别是什么？");

        System.out.println("**************************");

        Consumer<String> consumer2 = (String s) -> System.out.println(s);
        consumer2.accept("一个是听的人当真了，一个是说的人当真了");
    }

    //语法格式三：数据类型可以省略，因为可由编译器推断得出，称为 “类型推断”
    @Test
    public void test3() {
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("谎言和誓言的区别是什么？");

        System.out.println("**************************");

        Consumer<String> consumer2 = (s) -> System.out.println(s);
        //Consumer<String> consumer2 = System.out::println;
        consumer2.accept("一个是听的人当真了，一个是说的人当真了");
    }

    @Test
    public void test3_1() {
        ArrayList<String> list = new ArrayList<>();//类型推断

        int[] arr = new int[]{12, 23, 3};
        int[] arr1 = {12, 3, 4};//类型推断
    }

    //语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
    @Test
    public void test4() {
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("谎言和誓言的区别是什么？");

        System.out.println("**************************");

        Consumer<String> consumer2 = s -> System.out.println(s);
        consumer2.accept("一个是听的人当真了，一个是说的人当真了");
    }

    //语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
    @Test
    public void test5() {
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        System.out.println(com1.compare(12, 2));

        System.out.println("***********************");

        Comparator<Integer> com2 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        System.out.println(com2.compare(12, 23));
    }

    //语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
    @Test
    public void test6() {

        Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(com2.compare(12, 23));
    }

15.2 函数式接口

  • 如果一个接口中，只声明一个抽象方法，则此接口就称为函数式接口，可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口

Java内置的函数式结构

其他接口

/*
自定义函数式接口
 */
@FunctionalInterface
public interface MyInterface {

    void method1();

    //void method2();
}

15.3 方法引用与构造器引用

  • 使用情景：当要传递给 Lambda 体的操作，以及有了实现的方法了，可以使用方法引用
  • 方法引用，本质上就是Lambda表达式，而 Lambda 表达式作为函数式接口的实例。所以方法引用，也是函数式接口的实例
  • 使用格式：类(或对象) :: 方法名
  • 具体分为如下三种情况：
    • 情况一：对象 :: 非静态方法
    • 情况二：类 :: 静态方法
    • 情况三：类 :: 非静态方法
  • 方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同（针对于情况一和情况二）

15.3.1 方法引用

// 情况一：对象 :: 实例方法
	//Consumer中的void accept(T t)
	//PrintStream中的void println(T t)
	@Test
	public void test1() {
		Consumer<String> consumer = t -> System.out.println(t);
		consumer.accept("北京");

		System.out.println("*********************");

		PrintStream ps = System.out;
		Consumer<String> consumer1 = System.out::println;
		consumer1.accept("长沙");
	}
	
	//Supplier中的T get()
	//Employee中的String getName()
	@Test
	public void test2() {
		Employee employee = new Employee(1001, "Tom", 23, 30000);
		Supplier<String> sup1 = () -> employee.getName();
		String s = sup1.get();
		System.out.println(s);

		System.out.println("*****************");

		Supplier<String> sup2 = employee::getName;
		System.out.println(sup2.get());
	}

	// 情况二：类 :: 静态方法
	//Comparator中的int compare(T t1,T t2)
	//Integer中的int compare(T t1,T t2)
	@Test
	public void test3() {
		Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
		System.out.println(com1.compare(23, 12));

		System.out.println("************************");

		Comparator<Integer> com2 = Integer::compare;
		System.out.println(com2.compare(23, 23));
	}
	
	//Function中的R apply(T t)
	//Math中的Long round(Double d)
	@Test
	public void test4() {
		//把 Double 转换为 Long
		Function<Double, Long> func1 = d -> Math.round(d);
		System.out.println(func1.apply(23.6));

		System.out.println("**********************");

		Function<Double, Long> func2 = Math::round;
		System.out.println(func2.apply(234.234234));
	}

	// 情况三：类 :: 实例方法 
	// Comparator中的int comapre(T t1,T t2)
	// String中的int t1.compareTo(t2)
	@Test
	public void test5() {
		Comparator<Integer> com1 = (o1, o2) -> o1.compareTo(o2);
		System.out.println(com1.compare(23, 12));

		Comparator<Integer> com2 = Integer::compareTo;
		System.out.println(com2.compare(12, 23));

		Comparator<String> com3 = String::compareTo;
		System.out.println(com3.compare("abc", "abe"));
	}

	//BiPredicate中的boolean test(T t1, T t2);
	//String中的boolean t1.equals(t2)
	@Test
	public void test6() {
		//传入两个参数，比较是否相同
		BiPredicate<String, String> pre1 = (t1, t2) -> t1.equals(t2);
		System.out.println(pre1.test("sdf", "sdf"));

		BiPredicate<String, String> pre2 = String::equals;
		System.out.println(pre2.test("sdF", "sdf"));
	}
	
	// Function中的R apply(T t)
	// Employee中的String getName();
	@Test
	public void test7() {

		Function<Employee, String> fun1 = t -> t.getName();
		System.out.println(fun1.apply(new Employee(101, "Tom", 21, 9000)));

		Function<Employee, String> fun2 = Employee::getName;
		System.out.println(fun2.apply(new Employee(102, "Jerry", 22, 19000)));
	}

15.3.2 构造器引用

和方法引用类似，函数式接口的抽象方法的形参和构造器的形参列表一致
抽象方法的返回值类型即为构造器所属的类的类型

//构造器引用
//Supplier中的T get()
@Test
public void test1(){
    Supplier<Employee> sup1 = new Supplier<Employee>() {
        @Override
        public Employee get() {
            return new Employee();
        }
    };

    Supplier<Employee> sup2 = () -> new Employee();

    Supplier<Employee> sup3 = Employee::new;

    System.out.println(sup1.get());
    System.out.println(sup2.get());
    System.out.println(sup3.get());
}

//Function中的R apply(T t)
@Test
public void test2(){
    Function<Integer, Employee> fun1 = new Function<Integer, Employee>() {
        @Override
        public Employee apply(Integer integer) {
            return new Employee(integer);
        }
    };
    System.out.println(fun1.apply(22));

    Function<Integer, Employee> fun2 = t -> new Employee(t);
    System.out.println(fun2.apply(23));

    Function<Integer, Employee> fun3 = Employee::new;
    System.out.println(fun3.apply(24));
}

//BiFunction中的R apply(T t,U u)
@Test
public void test3(){
    BiFunction<Integer, String, Employee> func1 = new BiFunction<Integer, String, Employee>() {
        @Override
        public Employee apply(Integer integer, String s) {
            return new Employee(integer, s);
        }
    };

    BiFunction<Integer, String, Employee> func2 = (i, s) -> new Employee(i, s);

    BiFunction<Integer, String, Employee> func3 = Employee::new;
    System.out.println(func3.apply(10, "Tom"));
}

15.3.3 数组引用

把数组看作是一个特殊的类，则写法与构造器一致

	//Function中的R apply(T t)
    @Test
    public void test4(){

        Function<Integer, String[]> func1 = new Function<Integer, String[]>() {

            @Override
            public String[] apply(Integer integer) {
                return new String[integer];
            }
        };
        System.out.println(Arrays.toString(func1.apply(3)));

        Function<Integer, String[]> func2 = length -> new String[length];
        System.out.println(Arrays.toString(func2.apply(6)));

        Function<Integer, String[]> func3 = String[]::new;
        System.out.println(Arrays.toString(func3.apply(5)));
	}

15.4 Stream API

Stream API ( java.util.stream) 把真正的函数式编程风格引入到 Java 中。这是目前为止对 Java 类库最好的补充，因为 Stream API 可以极大提供 Java 程序员的生产力，让程序员写出高效率、干净、简洁的代码

Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算

  • 注意
    • Stream 自己不会存储元素。
    • Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream
    • Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
  • 操作步骤
    1. 创建 Stream：创建数据源，获取一个流
    2. 中间操作：一个中间操作链，对数据源的数据进行处理
    3. 终止操作：一旦执行终止操作，就执行中间操作链，并产生结果。之后，不能再被使用

15.4.1 Stream 流的创建

  • 方式一：通过集合创建
    • default Stream<E> stream()：返回一个顺序流
    • default Stream<E> parallelStream()：返回一个并行流
  • 方式二：通过数组创建
    • static <T> Stream<T> stream(T[] array)：返回一个流
  • 方式三：通过 Stream 的 of() 创建
    • public static<T> Stream<T> of(T... values)：返回一个流
  • 方式四：创建无限流
    • public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
    • public static<T> Stream<T> generate(Supplier<T> s)
	//创建 Stream 方式一：通过集合
    @Test
    public void test1() {
        List<Employee> employees = EmployeeData.getEmployees();

        //default Stream<E> stream()：返回一个顺序流
        Stream<Employee> stream = employees.stream();

        //default Stream<E> parallelStream()：返回一个并行流
        Stream<Employee> parallelStream = employees.parallelStream();
    }

    //创建 Stream 方式二：通过数组
    @Test
    public void test2() {
        int[] arr = new int[]{1, 3, 4, 2, 4, 2};

        //调用 Arrays 类的 static <T> Stream<T> stream(T[] array): 返回一个流
        IntStream stream = Arrays.stream(arr);

        Employee e1 = new Employee(1001, "Tom");
        Employee e2 = new Employee(1002, "Jerry");
        Employee[] arr1 = new Employee[]{e1, e2};
        Stream<Employee> stream1 = Arrays.stream(arr1);
    }

    //创建 Stream 方式三：通过 Stream 的 of()
    @Test
    public void test3() {
        //public static<T> Stream<T> of(T... values): 返回一个流
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 5);
    }

    //创建 Stream 方式四：创建无限流
    @Test
    public void test4() {
        //迭代
        //public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //遍历前十个偶数
        Stream.iterate(0, t -> t +2).limit(10).forEach(System.out::println);

        //生成
        //public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }

14.4.2 中间操作

  • 晒选切片

    方法说明
    filter(Predicate p)接收 Lambda ， 从流中排除某些元素
    distinct()筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
    limit(long maxSize)截断流，使其元素不超过给定数量
    skip(long n)跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
    //1.筛选与切片
@Test
public void test1() {
    List<Employee> employees = EmployeeData.getEmployees();

    //filter(Predicate p)：接收 Lambda，从流中排除某些元素
    Stream<Employee> stream = employees.stream();
    stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);

    System.out.println("***************************");

    //limit(long maxSize)：截断流，使其元素不超过给定数量
    Stream<Employee> stream2 = employees.stream();
    Stream<Employee> limit = stream2.limit(5);
    limit.forEach(System.out::println);
    //System.out.println(Arrays.toString(limit.toArray()));

    //skip(long n)：跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
    Stream<Employee> stream3 = employees.stream();
    stream3.skip(3).forEach(System.out::println);

    System.out.println("***************************************");
    employees.add(new Employee(1001, "马化腾", 34, 6000.38));
    employees.add(new Employee(1001, "马化腾", 34, 6000.38));
    employees.add(new Employee(1001, "马化腾", 34, 6000.38));
    employees.add(new Employee(1001, "马化腾", 34, 6000.38));
    employees.forEach(System.out::println);

    System.out.println("*****************************");
    //distinct()：筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
    Stream<Employee> stream4 = employees.stream();
    stream4.distinct().forEach(System.out::println);
}

  • 映射

    方法说明
    map(Function f)接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
    mapToDouble(ToDoubleFunction f)接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream
    mapToInt(ToIntFunction f)接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream
    mapToLong(ToLongFunction f)接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream
    flatMap(Function f)接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
    //映射
@Test
public void test2() {
    //map(Function f)：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
    List<String> list = Arrays.asList("aa", "bb", "cc");
    Stream<String> stream = list.stream().map(String::toUpperCase);
    System.out.println(Arrays.toString(stream.toArray()));

    //练习：获取员工姓名长度大于三的员工
    List<Employee> employees = EmployeeData.getEmployees();
    Stream<String> stream1 = employees.stream().map(Employee::getName);
    Stream<String> stream2 = stream1.filter(name -> name.length() > 3);
    System.out.println(Arrays.toString(stream2.toArray()));

    //练习：
    Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::formStringToStream);
    streamStream.forEach(t -> t.forEach(System.out::print));

    //flatMap(Function f)：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
    Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::formStringToStream);
    System.out.println(Arrays.toString(characterStream.toArray()));

    //mapToDouble(ToDoubleFunction f)：接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream

    //mapToInt(ToIntFunction f)：接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream

    //mapToLong(ToLongFunction f)：接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream
}

//将字符串中的多个字符构成的集合转换为对应的Stream的实例
public static Stream<Character> formStringToStream(String str) {
    ArrayList<Character> list = new ArrayList<>();
    for (Character c: str.toCharArray()) {
        list.add(c);
    }
    return list.stream();
}

  • 排序

    方法说明
    sorted()产生一个新流，其中按自然顺序排序
    sorted(Comparator com)产生一个新流，其中按比较器顺序排序
    //3.排序
@Test
public void test3() {
    //sorted()：自然排序
    List<Integer> list = Arrays.asList(23, 234, 132, 24);
    Stream<Integer> sorted = list.stream().sorted();
    System.out.println(Arrays.toString(sorted.toArray()));

    //sorted(Comparator com)：定制排序
    List<Employee> employees = EmployeeData.getEmployees();
    //employees.stream().sorted(((o1, o2) -> Integer.compare(o2.getAge(), o1.getAge()))).forEach(System.out::println);
    //employees.stream().sorted(Comparator.comparingInt(Employee::getAge)).forEach(System.out::println);

    employees.stream().sorted(new Comparator<Employee>() {
        @Override
        public int compare(Employee o1, Employee o2) {
            if (o1.getAge()==o2.getAge()) {
                return Integer.compare(o2.getId(),o1.getId());
            }
            return -Integer.compare(o1.getAge(), o2.getAge());
        }
    }).forEach(System.out::println);
}

14.4.3 终止操作

  • 流进行了终止操作后，不能再次使用

  • 匹配与查找

    方法说明
    allMatch(Predicate p)检查是否匹配所有元素
    anyMatch**(**Predicate p)检查是否至少匹配一个元素
    noneMatch(Predicate p)检查是否没有匹配所有元素
    findFirst()返回第一个元素
    findAny()返回当前流中的任意元素
    count()返回流中元素总数
    max(Comparator c)返回流中最大值
    min(Comparator c)返回流中最小值
    forEach(Consumer c)内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭）
    //1-匹配与查找
    @Test
    public void test1() {
        List<Employee> employees = EmployeeData.getEmployees();

        //allMatch(Predicate p)：检查是否匹配所有元素
        //练习：是否所有的员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(t -> t.getAge() > 18);
        System.out.println(allMatch);

        //anyMatch(Predicate p)：检查是否至少匹配一个元素
        boolean anyMatch = employees.stream().anyMatch(t -> t.getSalary() > 4000);
        System.out.println(anyMatch);

        //noneMatch(Predicate p)：检查是否没有匹配所有元素
        boolean noneMatch = employees.stream().noneMatch(t -> t.getName().startsWith("雷"));
        System.out.println(noneMatch);

        //findFirst()：返回第一个元素
        Optional<Employee> first = employees.stream().findFirst();
        System.out.println(first);

        //findAny()：返回当前流中的任意元素
        Optional<Employee> any = employees.parallelStream().findAny();
        System.out.println(any);
    }

    @Test
    public void test2() {
        List<Employee> employees = EmployeeData.getEmployees();
        //count()：返回流中元素总数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);

        //max(Comparator c)：返回流中最大值
        //练习：求最高的工资
        Optional<Double> max = employees.stream().map(Employee::getSalary).max(Double::compare);
        System.out.println(max);

        //min(Comparator c)：返回流中最小值
        //练习：求最低工资的员工
        Optional<Employee> min = employees.stream().min(Comparator.comparingDouble(Employee::getSalary));
        System.out.println(min);

        //forEach(Consumer c)：内部迭代(使用 Collection 接口需要用户去做迭代，为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)
        employees.stream().forEach(System.out::println);
        //使用集合的遍历操作
        employees.forEach(System.out::println);
    }

  • 归约

    方法说明
    reduce(T iden, BinaryOperator b)可以将流中元素反复结合起来，得到一个值。返回 T
    reduce(BinaryOperator b)可以将流中元素反复结合起来，得到一个值。返回 Optional
    //2-规约
@Test
public void test3() {
    //reduce(T iden, BinaryOperator b)：可以将流中元素反复结合起来，得到一值。返回 T
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    Integer reduce = list.stream().reduce(0, Integer::sum);
    System.out.println(reduce);

    //reduce(BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
    //练习：计算公司所有员工工资的总和
    List<Employee> employees = EmployeeData.getEmployees();
    Double reduce1 = employees.stream().map(Employee::getSalary).reduce((double) 0, Double::sum);
    System.out.println(reduce1);

    Optional<Double> reduce2 = employees.stream().map(Employee::getSalary).reduce(new BinaryOperator<Double>() {
        @Override
        public Double apply(Double aDouble, Double aDouble2) {
            return aDouble + aDouble2;
        }
    });
    System.out.println(reduce2);
}

  • 收集

    方法说明
    collect(Collector c)将流转换为其他形式。接收一个 Collector 接口的实现，用于给 Stream 中元素做汇总的方法
    //3-收集
@Test
public void test4() {
    //collect(Collector c)：将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
    //练习：查找工资大于六千的员工，结果返回一个List或Set
    List<Employee> employees = EmployeeData.getEmployees();
    List<Employee> collect = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
    collect.forEach(System.out::println);

    System.out.println("************************");

    Set<Employee> collect2 = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
    collect2.forEach(System.out::println);
}

14.4.5 Collectors

方法返回类型作用
toListList<T>把流中元素收集到 List
toSetSet<T>把流中元素收集到 Set
toCollectionCollection<T>把流中元素收集到创建的集合
countingLong计算流中元素的个数
summingIntInteger对流中元素的整数属性求和
averagingIntDouble计算流中元素 Integer 属性的平均值
summarizingIntIntSummaryStatistics收集流中 Integer 属性的统计值。如：平均值
joiningString连接流中每个字符串
maxByOptional<T>根据比较器选择最大值
minByOptional<T>根据比较器选择最小值
reducing归约产生的类型从一个作为累加器的初始值开始，利用 BinaryOperator 与流中元素逐个结合，从而归约成单个值
collectingAndThen转换函数返回的类型包裹另一个收集器，对其结果转换函数
groupingByMap<K, List<T>>根据某属性值对流分组，属性为K，结果为V
partitioningByMap<Boolean, List<T>>根据 true 或 false 进行分区

15.5 Optional 类

Optional<T>类(java.util.Optional) 是一个容器类，它可以保存类型 T 的值，代表这个值存在。或者仅仅保存 null，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常

  • 创建 Optional 类对象的方法：
    • Optional.of(T t)：创建一个 Optional 实例，t 必须非空
    • Optional.empty()：创建一个空的 Optional 实例
    • Optional.ofNullable(T t)：t 可以为 null
  • 判断 Optional 容器中是否包含对象：
    • boolean isPresent()：判断是否包含对象
    • void ifPresent(Consumer<? super T> consumer)：如果有值，就执行Consumer 接口的实现代码，并且该值会作为参数传给它
  • 获取 Optional 容器的对象
    • T get()：如果调用对象包含值，返回该值，否则抛异常
    • T orElse(T other)：如果有值则将其返回，否则返回指定的other对象
    • T orElseGet(Supplier<? extends T> other)：如果有值则将其返回，否则返回由 Supplier 接口实现提供的对象
    • T orElseThrow(Supplier<? extends X> exceptionSupplier)：如果有值则将其返回，否则抛出由 Supplier 接口实现提供的异常
public class OptionalTest {

    @Test
    public void test1() {
        Girl girl = new Girl();
        girl = null;
        //Optional.of(T t)：保证t是非空的
        Optional<Girl> optional = Optional.of(girl);
        System.out.println(optional);
    }

    @Test
    public void test2() {
        Girl girl = new Girl();
        girl = null;
        //ofNullable(T t)：t 可以为 null
        Optional<Girl> optional = Optional.ofNullable(girl);
        System.out.println(optional);

        //orElse(T t)：如果当前的 Optional 内部封装的 t 是非空的，则返回内部的 t
        //如果内部的 t 是空的，则返回 orElse() 方法中的参数 t
        Girl orElse = optional.orElse(new Girl("张三"));
        System.out.println(orElse);
    }

    public String getGirlName(Boy boy) {
        return boy.getGirl().getName();
    }

    //优化 getGirlName()
    public String getGirlName1(Boy boy) {
        if (boy != null) {
            Girl girl = boy.getGirl();
            if (girl != null) {
                return girl.getName();
            }
        }
        return null;
    }

    //使用 Optional类的getGirlName()
    public String getGirlName2(Boy boy) {
        Optional<Boy> boy1 = Optional.ofNullable(boy);
        Boy orElse = boy1.orElse(new Boy(new Girl("李四")));

        Girl girl = orElse.getGirl();

        Optional<Girl> girl1 = Optional.ofNullable(girl);
        Girl girl2 = girl1.orElse(new Girl("无物"));
        return girl2.getName();
    }

    @Test
    public void test3() {
        Boy boy = new Boy();
        String girlName = getGirlName1(boy);
        System.out.println(girlName);
    }

    @Test
    public void test4() {
        Boy boy = new Boy();
        boy = null;
        String girlName = getGirlName2(boy);
        System.out.println(girlName);

        Boy boy2 = new Boy();
        String girlName2 = getGirlName2(boy2);
        System.out.println(girlName2);

        Boy boy3 = new Boy(new Girl("沥沥"));
        String girlName3 = getGirlName2(boy3);
        System.out.println(girlName3);
    }

    @Test
    public void test5() {
        //empty()：创建的 Optional 对象内部的 value=null
        Optional<Object> empty = Optional.empty();
        if (empty.isPresent()) {//Optional封装的数据是否为空
            System.out.println("数据为空");
        }
        System.out.println(empty);
        System.out.println(empty.isPresent());
    }

    @Test
    public void test6() {
        String str = "hello";
        Optional<String> str1 = Optional.of(str);
        System.out.println(str1);
        //get() 通常与 of() 方法搭配使用。用于获取内部封装的数据value
        String s = str1.get();
        System.out.println(s);
    }

    @Test
    public void test7() {
        String str = "北京";
        Optional<String> str1 = Optional.ofNullable(str);
        String s1 = str1.orElse("长沙");
        System.out.println(s1);//北京

        String str2 = null;
        Optional<String> str3 = Optional.ofNullable(str2);
        String s2 = str3.orElse("长沙");
        System.out.println(s2);//长沙
    }
}

public class Boy {

    private Girl girl;

    public Boy() {}

    public Boy(Girl girl) {
        this.girl = girl;
    }

    public Girl getGirl() {
        return girl;
    }

    public void setGirl(Girl girl) {
        this.girl = girl;
    }

    @Override
    public String toString() {
        return "Boy{" +
                "girl=" + girl +
                '}';
    }
}

public class Girl {

    private String name;

    public Girl() {

    }

    public Girl(String name) {
        this.name = name;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Girl{" +
                "name='" + name + '\'' +
                '}';
    }
}
Aunean
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
重学JavaSE 第19章 : Java9新特性、Java10新特性、Java11新特性
Guizy
08-05 554
学习Java9新特性、Java10新特性、Java11新特性
【15章Java 8 新特性】最全Java 8新特性 详解
小鳴人的博客
02-16 8362
【15章Java 8 新特性：重复注解、类型注解、Stream API、函数式接口、Optional类、方法构造器数组引用、接口默认方法、新的日期时间API、Lambda表达式、类型推断、新编译工具、JDK更新】
JavaSE——java8新特性
一个憨憨写的胡言乱语
09-25 190
JavaSE——java8新特性1、Lambda表达式2、函数式（Functional）接口3、方法引用和构造器引用4、强大的Sream API5、Optional类 1、Lambda表达式 lambda的本质：作为接口的实例，只有函数式接口（接口中只声明了一个函数）能用。 无参、无返回值 public static void main(String[] args) { //正常写法 Runnable runnable = new Runnable() { @Over
【Java基础系列教程】第二十四章 JDK8新特性_Lambda表达式、函数式接口、方法引用和构造器引用
波哩个波的博客
03-22 575
一、Lambda 表达式 二、函数式接口 三、方法引用和构造器引用
JavaSE基础 第一章 Java介绍和环境安装
tzy18739738749的博客
08-23 116
JavaSE基础 第一章 Java介绍和环境安装
Java8 - Java17新特性说明
h295928126的博客
07-06 3587
Java8 - Java17新特性说明
Java18新特性
Code Writers
09-01 1209
文章目录 Java 18 新特性1、默认 UTF-8 字符编码2、简单的 Web 服务器3、Javadoc 中支持代码片段3.1、高亮代码片段3.2、正则高亮代码片段3.3、替换代码片段3.4、附：Javadoc 生成方式4、使用方法句柄重新实现反射核心功能5、Vector API（三次孵化）6、互联网地址解析 SPI7、Foreign Function & Memory API (第二次孵化）8、switch 表达式（二次孵化）9、弃用删除相关Java 18 新特性Java 18 在 2022 年
Java8新特性教程 - 终极指南
YunWisdom
01-02 921
转载来源：https://www.javacodegeeks.com/2014/05/java-8-features-tutorial.html   Java 8 新特性教程 - 终极指南   编者按：在这篇文章中，我们提供了一个全面的Java 8功能教程。自从Java 8出现在公众面前已经有一段时间了，所有事情都表明这是一个非常重要的版本。 我们在Java Code Geeks上提供了...
【JavaSe】高级特性篇(十四) Java11的五大新特性
不想当架构师的程序员不是好程序员
08-28 807
JavaSe·高级特性篇(十四) Java11的五大新特性 前言: JDK 11发布 北京时间 2018年9 月 26 日，Oracle 官方宣布 Java 11 正式发 布。这是 Java 大版本周期变化后的第一个长期支持版本，非 常值得关注。从官网即可下载,最新发布的 Java11 将带来 ZGC、Http Client 等重要特性。 JDK 11 将是一个 企业不可忽视的版本。从时间节点...
第五十一节 Java 9 新特性
2301_78772942的博客
05-03 9
第五十一节 Java 9 新特性
C++ - 函数重载
jiaowenjie的专栏
08-06 264
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
枚举工具类
qq_43049583的博客
08-04 485
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 562
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
时光不等人：java每日一练
m0_67187271的博客
08-05 1039
时光悄然流逝，不等人。技术亦不会自来门前，唯有勤奋学习，方能抓住时代的脉搏。
（javaweb）请求响应postman
最新发布
2301_79144798的博客
08-08 261
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
Servlet(2)
xjdkxnhcoskxbco的博客
08-04 784
这个注解可以用来修饰一个Servlet类，可以简化配置，替代Web.xml中 的servlet配置。
Spring事务
c1tenj2的博客
08-07 356
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
java selenium 设置代理，允许在其他环境中使用不同的IP访问
huanghm88的专栏
08-05 477
此代码以Chrome浏览器为例，如果你使用其他浏览器，你需要相应地调整代码。另外，你需要下载适用于你的操作系统的Chrome浏览器驱动，并将路径替换为。在Java Selenium中设置代理可以使用。替换为其他环境中要访问的IP地址。替换为实际的代理IP和端口，并将。
在java java.util.Date 已知逝去时间怎么求年月日
huanghm88的专栏
08-05 326
这样，你就可以得到逝去时间的年月日。需要注意的是，这只是一个简单的方法，不考虑闰年等情况。如果你需要更准确的结果，可以使用其他时间处理库，如Joda-Time或java.time包。
Java核心技术精讲：JavaSE 6新特性解析
"《Java核心技术》是一本专注于Java语言核心知识点的经典教材，主要涵盖了Java标准版（JavaSE 6）的特性。该书由Cay S. Horstmann和Gary Cornell合著，经过多次修订以适应Java语言的发展。第八版新增了对Java SE 6...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值