基础进阶-Java8新特性

最新推荐文章于 2022-08-08 13:44:19 发布

原创最新推荐文章于 2022-08-08 13:44:19 发布 · 185 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

Java 专栏收录该内容

9 篇文章

订阅专栏

本文深入探讨了Java8的重要新特性，包括Lambda表达式、函数式接口、Stream API等内容。详细解析了Lambda表达式的概念、使用特点及语法格式，并通过具体示例展示了如何简化代码。此外，还介绍了Java8内置的四大函数式接口及其应用场景。

Java8新特性

1 、Lambda表达式

1.1 什么是Lambda

Lambda 是一个匿名函数，我们可以把 Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “->” ，该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为两个部分：左侧：指定了 Lambda 表达式需要的所有参数，右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能

lambda使用特点

（1）lambda表达式主要简化接口的部分代码的，接口里面必须只能有一个普通方法
（2）把只有一个普通方法的接口，称为函数式接口，在函数式接口上面有一个标志，在接口上面有注解 @FunctionalInterface，函数式接口可以有default和static方法
（3）自定义函数式接口

其实本质上，Lambda表达式是用于实现【函数式接口】的“抽象方法”

Lambda表达式语法格式

(形参列表) -> {Lambda体}

第一步：复制小括号
第二步：写死右箭头
第三步：落地大括号

感受Lambda表达式

  public static void main(String[] args) {
        //普通创建线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        },"abc").start();

        //lambda表达式简化
//        第一步：复制小括号
//        第二步：写死右箭头
//        第三步：落地大括号
        new Thread(() ->{ System.out.println(Thread.currentThread().getName()); },"abc").start();
    }

函数式接口

lambda表达式，必须是函数式接口，必须只有一个方法

如果接口只有一个方法java默认它为函数式接口。

为了正确使用Lambda表达式，需要给接口加个注解：@FunctionalInterface

如有两个方法，立刻报错

函数式接口可以有其他类型的方法：default static

示例代码：

public class Demo2 {

    public static void main(String[] args) {
        //实现Foo接口add方法
        Foo foo = (int a,int b) -> {
            System.out.println("lambda test...");
            return a+b;
        };

        //调用
        int add = foo.add(2, 3);
        System.out.println(add);

        int div = foo.div(4, 2);
        int sub = Foo.sub(3, 1);
        System.out.println(div);
        System.out.println(sub);
    }
}

//创建函数式接口
@FunctionalInterface
interface Foo {
    //两个数相加
    public int add(int a,int b);

    //其他类型的方法
    default int div(int x,int y) {
        return x/y;
    }

    public static int sub(int x,int y) {
        return x-y;
    }
}

1.2 函数式接口

lambda表达式其实就是实现SAM接口的语法糖，所谓SAM接口就是Single Abstract Method，即该接口中只有一个抽象方法需要实现，当然该接口可以包含其他非抽象方法。

其实只要满足“SAM”特征的接口都可以称为函数式接口，都可以使用Lambda表达式，但是如果要更明确一点，最好在声明接口时，加上@FunctionalInterface。一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。

之前学过的SAM接口中，标记了@FunctionalInterface的函数式接口的有：Runnable，Comparator，FileFilter。

Java8在java.util.function新增了很多函数式接口：主要分为四大类，消费型、供给型、判断型、功能型。基本可以满足我们的开发需求。当然我们自己也可以定义自己的函数式接口。

1、自定义函数式接口

只要确保接口中有且仅有一个抽象方法即可：

修饰符 interface 接口名称 {
    public abstract 返回值类型 方法名称(可选参数信息);
    // 其他非抽象方法内容
}

接口当中抽象方法的 public abstract 是可以省略的

例如：声明一个计算器Calculator接口，内含抽象方法calc可以对两个int数字进行计算，并返回结果：

public interface Calculator {
    int calc(int a, int b);
}

2、Java内置核心四大函数式接口

在这里插入图片描述

（1）消费型接口

消费型接口的抽象方法特点：有形参，但是返回值类型是void

接口名	抽象方法	描述
Consumer	void accept(T t)	接收一个对象用于完成功能
BiConsumer<T,U>	void accept(T t, U u)	接收两个对象用于完成功能
DoubleConsumer	void accept(double value)	接收一个double值
IntConsumer	void accept(int value)	接收一个int值
LongConsumer	void accept(long value)	接收一个long值
ObjDoubleConsumer	void accept(T t, double value)	接收一个对象和一个double值
ObjIntConsumer	void accept(T t, int value)	接收一个对象和一个int值
ObjLongConsumer	void accept(T t, long value)	接收一个对象和一个long值

在这里插入代码片

（2）供给型接口

这类接口的抽象方法特点：无参，也无返回值

接口名	抽象方法	描述
Supplier	T get()	返回一个对象
BooleanSupplier	boolean getAsBoolean()	返回一个boolean值
DoubleSupplier	double getAsDouble()	返回一个double值
IntSupplier	int getAsInt()	返回一个int值
LongSupplier	long getAsLong()	返回一个long值

（3）断定型接口

这里接口的抽象方法特点：有参，但是返回值类型是boolean结果。

接口名	抽象方法	描述
Predicate	boolean test(T t)	接收一个对象
BiPredicate<T,U>	boolean test(T t, U u)	接收两个对象
DoublePredicate	boolean test(double value)	接收一个double值
IntPredicate	boolean test(int value)	接收一个int值
LongPredicate	boolean test(long value)	接收一个long值

（4）函数型（功能型）接口

这类接口的抽象方法特点：既有参数又有返回值

接口名	抽象方法	描述
Function<T,R>	R apply(T t)	接收一个T类型对象，返回一个R类型对象结果
UnaryOperator	T apply(T t)	接收一个T类型对象，返回一个T类型对象结果
DoubleFunction	R apply(double value)	接收一个double值，返回一个R类型对象
IntFunction	R apply(int value)	接收一个int值，返回一个R类型对象
LongFunction	R apply(long value)	接收一个long值，返回一个R类型对象
ToDoubleFunction	double applyAsDouble(T value)	接收一个T类型对象，返回一个double
ToIntFunction	int applyAsInt(T value)	接收一个T类型对象，返回一个int
ToLongFunction	long applyAsLong(T value)	接收一个T类型对象，返回一个long
DoubleToIntFunction	int applyAsInt(double value)	接收一个double值，返回一个int结果
DoubleToLongFunction	long applyAsLong(double value)	接收一个double值，返回一个long结果
IntToDoubleFunction	double applyAsDouble(int value)	接收一个int值，返回一个double结果
IntToLongFunction	long applyAsLong(int value)	接收一个int值，返回一个long结果
LongToDoubleFunction	double applyAsDouble(long value)	接收一个long值，返回一个double结果
LongToIntFunction	int applyAsInt(long value)	接收一个long值，返回一个int结果
DoubleUnaryOperator	double applyAsDouble(double operand)	接收一个double值，返回一个double
IntUnaryOperator	int applyAsInt(int operand)	接收一个int值，返回一个int结果
LongUnaryOperator	long applyAsLong(long operand)	接收一个long值，返回一个long结果

BiFunction<T,U,R>	R apply(T t, U u)	接收一个T类型和一个U类型对象，返回一个R类型对象结果
BinaryOperator	T apply(T t, T u)	接收两个T类型对象，返回一个T类型对象结果
ToDoubleBiFunction<T,U>	double applyAsDouble(T t, U u)	接收一个T类型和一个U类型对象，返回一个double
ToIntBiFunction<T,U>	int applyAsInt(T t, U u)	接收一个T类型和一个U类型对象，返回一个int
ToLongBiFunction<T,U>	long applyAsLong(T t, U u)	接收一个T类型和一个U类型对象，返回一个long
DoubleBinaryOperator	double applyAsDouble(double left, double right)	接收两个double值，返回一个double结果
IntBinaryOperator	int applyAsInt(int left, int right)	接收两个int值，返回一个int结果
LongBinaryOperator	long applyAsLong(long left, long right)	接收两个long值，返回一个long结果

1.3 Lambda表达式练习

练习1：消费型接口

代码示例：Consumer接口

在JDK1.8中Collection集合接口的父接口Iterable接口中增加了一个默认方法：

public default void forEach(Consumer<? super T> action)遍历Collection集合的每个元素，执行“xxx消费型”操作。

在JDK1.8中Map集合接口中增加了一个默认方法：

public default void forEach(BiConsumer<? super K,? super V> action)遍历Map集合的每对映射关系，执行“xxx消费型”操作。

案例：

（1）创建一个Collection系列的集合，添加内容，调用forEach方法遍历查看

（2）创建一个Map系列的集合，添加一些(key,value)键值对，调用forEach方法遍历查看

/**
 * 演示函数式接口
 */
public class Demo4 {
    //消费型
    @Test
    public void test01() {
        Consumer<String> consumer = (t) -> {
            System.out.println(t);
        };
        consumer.accept("mary");
    }

    @Test
    public void test02() {
       //创建list集合，向里放数据，把list集合遍历
        List<String> list = Arrays.asList("java","c","python","c++","VB","C#");
        list.forEach( s-> { System.out.println(s); });
    }

    @Test
    public void test03() {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "java");
        map.put(2, "c");
        map.put(3, "python");
        map.put(4, "c++");
        map.put(5, "VB");
        map.put(6, "C#");
        map.forEach( (k,v)-> { System.out.println(k+"::"+v); });
    }
}

练习2：供给型接口

代码示例：Supplier接口

在JDK1.8中增加了StreamAPI，java.util.stream.Stream是一个数据流。这个类型有一个静态方法：

public static <T> Stream<T> generate(Supplier<T> s)可以创建Stream的对象。而又包含一个forEach方法可以遍历流中的元素：public void forEach(Consumer<? super T> action)。。

//供给型接口
@Test
public void test04() {
    Supplier<String> supplier = () -> {
        return "atguigu";
    };
    String value = supplier.get();
    System.out.println(value);
}

练习3：功能型接口

代码示例：Funtion<T,R>接口

在JDK1.8时Map接口增加了很多方法，例如：

public default void replaceAll(BiFunction<? super K,? super V,? extends V> function)按照function指定的操作替换map中的value。

public default void forEach(BiConsumer<? super K,? super V> action)遍历Map集合的每对映射关系，执行“xxx消费型”操作。

//函数型接口
@Test
public void test05() {
    Function<String,String> function = (t) -> {
        System.out.println(t);
        return "atguigu";
    };
    String value = function.apply("lucymary");
    System.out.println(value);
}

案例：

（1）声明一个Employee员工类型，包含编号、姓名、薪资。

（2）添加n个员工对象到一个HashMap<Integer,Employee>集合中，其中员工编号为key，员工对象为value。

（3）调用Map的forEach遍历集合

（4）调用Map的replaceAll方法，将其中薪资低于10000元的，薪资设置为10000。

（5）再次调用Map的forEach遍历集合查看结果

Employee类：

public class Demo5 {

    public static void main(String[] args) {
        //创建map集合，放数据 key 编号  value对象
        Map<Integer,Employee> map = new HashMap<>();
        map.put(1,new Employee(1,"lucy",8000));
        map.put(2, new Employee(2, "李四", 9000));
        map.put(3, new Employee(3, "王五", 10000));

        //遍历map集合
        map.forEach((k,v)-> {
            System.out.println("key:"+k+"  value:"+v);
        });
        
        //把map工资，如果工资小于10000，替换为10000
        map.replaceAll((k,v)->{
            //从v对象获取工资值，判断如果小于10000
            if(v.getSalary()<10000) {
                v.setSalary(10000);
            }
            return v;
        });
        map.forEach((k,v) -> System.out.println(k+"="+v));
    }
}

class Employee{
    private int id;
    private String name;
    private double salary;
    public Employee(int id, String name, double salary) {
        super();
        this.id = id;
        this.name = name;
        this.salary = salary;
    }
    public Employee() {
        super();
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    @Override
    public String toString() {
        return "Employee [id=" + id + ", name=" + name + ", salary=" + salary + "]";
    }
}

练习4：判断型接口

代码示例：Predicate接口

JDK1.8时，Collecton接口增加了一下方法，其中一个如下：

public default boolean removeIf(Predicate<? super E> filter) 用于删除集合中满足filter指定的条件判断的。

public default void forEach(Consumer<? super T> action)遍历Collection集合的每个元素，执行“xxx消费型”操作。

案例：

（1）添加一些字符串到一个Collection集合中

（2）调用forEach遍历集合

（3）调用removeIf方法，删除其中字符串的长度<5的

（4）再次调用forEach遍历集合

//断定型接口
@Test
public void test01() {
    ArrayList<String> list = new ArrayList<>();
    list.add("hello");
    list.add("java");
    list.add("atguigu");
    list.add("ok");
    list.add("yes");

    //遍历list集合
    list.forEach(str->{ System.out.println(str); });
    System.out.println();
    //如果字符串长度小于5，删除这个字符串
    list.removeIf(str->str.length()<5);

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

1.4 方法引用与构造器引用

Lambda表达式是可以简化函数式接口的变量与形参赋值的语法。而方法引用和构造器引用是为了简化Lambda表达式的。当Lambda表达式满足一些特殊的情况时，还可以再简化：

（1）Lambda体只有一句语句，并且是通过调用一个对象的/类现有的方法来完成的

例如：System.out对象，调用println()方法来完成Lambda体

Math类，调用random()静态方法来完成Lambda体

（2）并且Lambda表达式的形参正好是给该方法的实参

例如：t->System.out.println(t)

() -> Math.random() 都是无参

方法引用

方法引用的语法格式：

（1）实例对象名::实例方法

（2）类名::静态方法

（3）类名::实例方法

说明：

::称为方法引用操作符（两个:中间不能有空格，而且必须英文状态下半角输入）
Lambda表达式的形参列表，全部在Lambda体中使用上了，要么是作为调用方法的对象，要么是作为方法的实参。
在整个Lambda体中没有额外的数据。

    @Test
    public void test0(){
        String[] arr = {"Hello","java","chai"};
        System.out.println(Arrays.toString(arr));
//		Arrays.sort(arr, (s1,s2) -> s1.compareToIgnoreCase(s2));
        
        //用方法引用简化
        Arrays.sort(arr, String::compareToIgnoreCase);
        System.out.println(Arrays.toString(arr));
    }

    @Test
    public void test1(){
        String[] arr = {"Hello","java","chai"};
		Arrays.sort(arr, (s1,s2) -> s1.compareToIgnoreCase(s2));
        List<Integer> list = Arrays.asList(1,3,4,8,9);

        //lam表达式
        //list.forEach(t -> System.out.println(t));

        //用方法再简化
        list.forEach(System.out::println);
    }

构造器引用

（1）当Lambda表达式是创建一个对象，并且满足Lambda表达式形参，正好是给创建这个对象的构造器的实参列表。

（2）当Lambda表达式是创建一个数组对象，并且满足Lambda表达式形参，正好是给创建这个数组对象的长度

构造器引用的语法格式：

类名::new
数组类型名::new

示例代码：

public class TestMethodReference {
	@Test
	public void test5(){
//		Supplier<String> s = () -> new String();//通过供给型接口，提供一个空字符串对象
		
		//构造器引用
		Supplier<String> s = String::new;//通过供给型接口，提供一个空字符串对象
	}
}

2、 StreamAPI

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

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，负责存储数据，Stream流讲的是计算，负责处理数据！”

注意：

①Stream 自己不会存储元素。

②Stream 不会改变源对象。每次处理都会返回一个持有结果的新Stream。

③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream 的操作三个步骤：

1- 创建 Stream：通过一个数据源（如：集合、数组），获取一个流

2- 中间操作：中间操作是个操作链，对数据源的数据进行n次处理，但是在终结操作前，并不会真正执行。

3- 终止操作：一旦执行终止操作，就执行中间操作链，最终产生结果并结束Stream。

2.1 创建Stream

1、创建 Stream方式一：通过集合

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

public default Stream stream() : 返回一个顺序流
public default Stream parallelStream() : 返回一个并行流

2、创建 Stream方式二：通过数组

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

public static Stream stream(T[] array): 返回一个流

重载形式，能够处理对应基本类型的数组：

public static IntStream stream(int[] array)：返回一个整型数据流
public static LongStream stream(long[] array)：返回一个长整型数据流
public static DoubleStream stream(double[] array)：返回一个浮点型数据流

3、创建 Stream方式三：通过Stream的of()

可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。

public static Stream of(T… values) : 返回一个顺序流

4、创建 Stream方式四：创建无限流

可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。

public static Stream iterate(final T seed, final UnaryOperator f):返回一个无限流
public static Stream generate(Supplier s) ：返回一个无限流

**
 * 创建Stream流
 */
public class StreamDemo1 {
    public static void main(String[] args) {
        //1 通过集合创建
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        Stream<Integer> stream1 = list.stream();

        //2 通过数组
        int[] arr = {1,2,3,4,5};
        IntStream stream2 = Arrays.stream(arr);

        //3 Stream里面of方法
        Stream<Integer> stream3 = Stream.of(1,2,3,4,5);

        //4 创建无限流
        Stream<Double> stream4 = Stream.generate(Math::random);
        Stream<Integer> stream5 = Stream.iterate(1, num -> num+=2);
    }
}

2.2 中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

方法	描述
filter(Predicate p)	接收 Lambda ，从流中排除某些元素
distinct()	筛选，通过流所生成元素的equals() 去除重复元素
limit(long maxSize)	截断流，使其元素不超过给定数量
skip(long n)	跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
peek(Consumer action)	接收Lambda，对流中的每个数据执行Lambda体操作
sorted()	产生一个新流，其中按自然顺序排序
sorted(Comparator com)	产生一个新流，其中按比较器顺序排序
map(Function f)	接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。
mapToInt(ToIntFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream。
mapToLong(ToLongFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream。
flatMap(Function f)	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

//中间操作 filter
    @Test
    public void test01() {
        //创建Stream流
        Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
        //中间操作
        stream = stream.filter(t -> t % 2 == 0);
        //终止操作，输出
        stream.forEach(System.out::println);
    }

    @Test
    public void test02(){
        Stream.of(1,2,3,4,5,6)
                .filter(t -> t%2==0)
                .forEach(System.out::println);
    }

    @Test
    public void test03(){
        Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
                .distinct()
                .forEach(System.out::println);
    }

    @Test
    public void test06(){
        Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
                .skip(5)
                .forEach(System.out::println);
    }

    @Test
    public void test05(){
        Stream.of(1,2,2,3,3,4,4,5,2,3,4,5,6,7)
                .distinct()  //(1,2,3,4,5,6,7)
                .filter(t -> t%2!=0) //(1,3,5,7)
                .limit(3)
                .forEach(System.out::println);
    }


    @Test
    public void test04(){
        Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
                .limit(4)
                .forEach(System.out::println);
    }

    @Test
    public void test11(){
        String[] arr = {"hello","world","java"};
        Arrays.stream(arr)
                .map(t->t.toUpperCase())
                .forEach(System.out::println);
    }
}

17.2.3 终结操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void。流进行了终止操作后，不能再次使用。

方法	描述
boolean allMatch(Predicate p)	检查是否匹配所有元素
boolean anyMatch(Predicate p)	检查是否至少匹配一个元素
boolean noneMatch(Predicate p)	检查是否没有匹配所有元素
Optional findFirst()	返回第一个元素
Optional findAny()	返回当前流中的任意元素
long count()	返回流中元素总数
Optional max(Comparator c)	返回流中最大值
Optional min(Comparator c)	返回流中最小值
void forEach(Consumer c)	迭代
T reduce(T iden, BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回 T
U reduce(BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回 Optional
R collect(Collector c)	将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、Map)。另外， Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例。

public class StreamDemo2 {

    @Test
    public void test14(){
        List<Integer> list = Stream.of(1,2,4,5,7,8)
                .filter(t -> t%2==0)
                .collect(Collectors.toList());

        System.out.println(list);
    }


    @Test
    public void test13(){
        Optional<Integer> max = Stream.of(1,2,4,5,7,8)
                .reduce((t1,t2) -> t1>t2?t1:t2);//BinaryOperator接口   T apply(T t1, T t2)
        System.out.println(max);
    }

    @Test
    public void test12(){
        Integer reduce = Stream.of(1,2,4,5,7,8)
                .reduce(0, (t1,t2) -> t1+t2);//BinaryOperator接口   T apply(T t1, T t2)
        System.out.println(reduce);
    }

    @Test
    public void test11(){
        Optional<Integer> max = Stream.of(1,2,4,5,7,8)
                .max((t1,t2) -> Integer.compare(t1, t2));
        System.out.println(max.get());
    }

    @Test
    public void test10(){
        Optional<Integer> opt = Stream.of(1,2,4,5,7,8)
                .filter(t -> t%3==0)
                .findFirst();
        System.out.println(opt.get());
    }

    @Test
    public void test09(){
        Optional<Integer> opt = Stream.of(1,2,3,4,5,7,9)
                .filter(t -> t%3==0)
                .findFirst();
        System.out.println(opt.get());
    }

    @Test
    public void test08(){
        Optional<Integer> opt = Stream.of(1,3,5,7,9).findFirst();
        System.out.println(opt.get());
    }

    @Test
    public void test04(){
        boolean result = Stream.of(1,3,4,7,9)
                .anyMatch(t -> t%2==0);
        System.out.println(result);
    }


    @Test
    public void test03(){
        boolean result = Stream.of(1,3,5,7,9)
                .allMatch(t -> t%2!=0);
        System.out.println(result);
    }

    @Test
    public void test02(){
        long count = Stream.of(1,2,3,4,5)
                .count();
        System.out.println("count = " + count);
    }
}