java8的新特性怎么使用

这篇文章主要介绍"java8的新特性怎么使用"，在日常操作中，相信很多人在java8的新特性怎么使用问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答"java8的新特性怎么使用"的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

1）Lambda表达式        概念：java8中增加了一个新的语法--Lambda表达式，并且引入了一个新的操作符(Lambda操作符)： ->                 Lambda操作符 -> ：                  -> 将Lambda表达式分为两个部分：                        左侧：指定了Lambda表达式需要的参数，参数的数据类型可以由编译器的"类型推断"机制推断得出，故可以省略。                        右侧：指定了Lambda表达式的方法体，即Lambda表达式要执行的功能。                语法格式：                                格式一：无参数，无返回值                                () -> System.out.println("Hello Lambda!");                格式二：有一个参数，并且无返回值                                (x) -> System.out.println(x)                格式三：若只有一个参数，小括号可以省略不写                                x -> System.out.println(x)                格式四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句                                (x, y) -> {                                        System.out.println("函数式接口");                                        return Integer.compare(x, y);                                };                格式五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写                                (x, y) -> Integer.compare(x, y);                格式六：Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即"类型推断"                                (Integer x, Integer y) -> Integer.compare(x, y);                                                                                       2）函数式接口        概念：只有一个抽象方法(默认方法与静态方法除外)的接口，称为函数式接口！                补充：java8中，接口里可以有default方法(默认方法)和static方法(静态方法)，实现类默认会继承defaul方法和static方法。                声明一个函数式接口：                        @FunctionalInterface                public interface FirstInterface {                        void run();                }                说明：                1)可以通过Lambda表达式来创建函数式接口的对象。                2)可以在函数式接口上使用@FunctionalInterface注解，这样我们就可以根据该注解来判断这个接口是否是一个函数式接口。                3)Java8内置的四个核心函数式接口                                函数式接口                           参数类型    返回类型    抽象方法                    用途                        消费型接口：Consumer                 T               void            void accept(T t)      对类型为T的对象执行某一操作。                        供给型接口：Supplier                 无               T                       T get()                            返回类型为T的对象。                        函数型接口：Function         T               R                       R apply(T t)          对类型为T的对象执行某一操作，并返回R类型的结果。                        断言型接口：Predicate                T               boolean         boolean test(T t)     确定类型为T的对象是否满足某约束，并返回boolean值。                                                eg：                                // 对String类型的对象执行Lambda表达式(x -> System.out.println(x))的方法体。                                Consumer strConsumer = x -> System.out.println(x);            // 创建一个Consumer(消费型接口)的对象                                strConsumer.accept("Consumer的accept方法！");                                     // 执行                                                        FirstInterface firstObj = () -> System.out.println("Hello Lambda!");                                firstObj.run();                                3）方法引用        方法引用：                说明：                        1)若Lambda方法体中的功能，已经有方法提供了实现，则可以使用方法引用。                        2)使用操作符 :: 将方法名和对象或类的名字分隔开来。                                        格式：                  对象名 :: 实例方法名                  类名   :: 静态方法名                  类名   :: 实例方法名                eg：                        Comparator com1 = (x, y) -> Integer.compare(x, y);                        Comparator com2 = Integer::compare;                构造器引用                格式： 类名 :: new                eg：                        Supplier sup1 = () -> new Student();                        Supplier sup2 = Student::new;                        数组引用                格式： type[] :: new                eg：                        Function fun1 = (args) -> new String[args];                        Function fun2 = String[]::new;                        4）Stream API概念：Stream用于操作集合、数组等元素序列。Stream API 的操作步骤        1)创建Stream                        创建Stream的方式：                        1>通过Collection中的 stream() 或 parallelStream() 来创建一个Stream                                eg：                                        List list = new ArrayList<>();                                        Stream stream = list.stream();                                        //获取一个顺序流                                        Stream parallelStream = list.parallelStream();        //获取一个并行流                                                        2>通过Arrays中的stream(T[] array)创建一个Stream                        3>通过Stream中的                                of(T... values)                                                                    创建一个Stream                                generate(Supplier s)                                                      创建一个无限Stream                                iterate(final T seed, final UnaryOperator f)  创建一个无限Stream                                        2)Stream的中间操作                        Stream filter(Predicate predicate)        从流中排除某些元素                Stream limit(long n);                                                        将流截断，只保留流中的前n个元素                Stream skip(long n);                                                         将流中的前n个元素剔除掉                Stream distinct();                                                                将流中的元素进行去重操作。根据元素的hashCode()方法和equals()方法来确定唯一性。                                Stream sorted();                                                                  将流中的元素进行自然排序                Stream sorted(Comparator comparator); 将流中的元素按照指定的规则排序                                 Stream map(Function mapper);                                                   1>说明：将流中的元素进行处理后，用新生成的元素代替原来的元素。注：新元素的类型与旧元素的类型可能不一样。                        2>参数：一个函数式接口，用传入的函数来生成新的元素。                        3>举例：Stream stream = strList.stream().map(String::toUpperCase);                                 Stream flatMap(Function> mapper);                                        说明：将流中的每个值都换成另一个流，然后把所有流连接成一个流。                                                 R collect(Collector collector);                                             1>说明：将流转换为其它形式，将流中的元素进行分组、拼接等。                        2>举例：List list = strList.stream().map(String::toUpperCase).collect(Collectors.toList());                3)Stream的终端操作                        void forEach(Consumer action);     遍历流中的所有元素                                boolean allMatch(Predicate predicate);     检查所有的元素是否都匹配                                anyMatch                                                                        检查是否有元素匹配                                noneMatch                                                                       检查是否有元素不匹配                                Optional findFirst();                                                     返回第一个元素                Optional findAny();                                                               返回流中任意一个元素                                long count();                                                                              返回流中元素的总数                Optional max(Comparator comparator);      返回流中最大的元素                Optional min(Comparator comparator);      返回流中最小的元素                        说明：                1>只有调用终端操作后，所有的中间操作才会去执行，若没有调用终端操作，那么所有的中间操作都将不会执行，这种模式叫做"惰性求值"。                2>流只能使用一次，即只能调用一次终端操作。

到此，关于"java8的新特性怎么使用"的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注网站，小编会继续努力为大家带来更多实用的文章！