当前位置： 代码迷 >> 综合 >> JavaSE基础系列之Java新特性
  详细解决方案

JavaSE基础系列之Java新特性

热度：36   发布时间：2024-03-07 14:46:16.0

 

一.Java8新特性

1.Java8主要增加了函数式接口

① 函数式接口:指只包含一个抽象方法的接口，如:java.lang.Runnable,java.util.Comparator.

提供@FunctionalInterface注解来定义函数式接口，若定义的接口不符合函数式的规范便会报错。

增加了java.util.function包，该包包含了常用的函数式接口，具体如下：

接口名称

方法声明

功能介绍

Consumer

void accept(T t)

根据指定的参数执行操作

Supplier

T get()

得到一个返回值

Function<T,R>

Rapply(T t)

根据指定的参数执行操作并返回

Predicate

boolean test(T t)

判断指定的参数是否满足条件

②匿名内部类

// 匿名内部类的语法格式： 父类/接口类型  引用变量名 = new 父类/接口类型(){ 方法的重写 };

//Runnable使用匿名内部类语法

        Runnable runnable = new Runnable() {

            @Override

            public void run() {

                System.out.println("我是既没有参数又没有返回值的方法！");

            }

        };

        runnable.run(); // 我是既没有参数又没有返回值的方法！

//2.Consumer使用匿名内部类语法

    Consumer consumer = new Consumer() {

            @Override

            public void accept(Object o) {

                System.out.println(o + "有参但没有返回值的方法就是我！");

            }

        };

       consumer.accept("友情提示："); // 友情提示：有参但没有返回值的方法就是我！

//Supplier使用匿名内部类语法

 

Supplier supplier = new Supplier() {

            @Override

            public Object get() {

                return "无参有返回值！";

            }

        };

        System.out.println(supplier.get()); // 无参有返回值

//Function使用匿名内部类语法

 

    Function function = new Function() {

            @Override

            public Object apply(Object o) {

                return o;

            }

        };

        System.out.println(function.apply("有参有返回值的方法")); // 有参有返回值的方法

//Predicate使用匿名内部类语法

     Predicate predicate = new Predicate() {

            @Override

            public boolean test(Object o) {

                return false;

            }

        };

        System.out.println(predicate.test("hello")); // false

③Lambda表达式

    Lambda 表达式是实例化函数式接口的重要方式，使用 Lambda 表达式可以使代码变的更加简洁 紧凑。 lambda表达式：参数列表、箭头符号->和方法体组成，而方法体中可以是表达式，也可以是语句 块。 语法格式：(参数列表) -> { 方法体; } - 其中()、参数类型、{} 以及return关键字 可以省略。

  代码例子: 

  // 使用lambda表达式实现函数式接口对象的创建: (参数列表)->{ 方法体;}

 //Runnable使用Lambda表达式语法

  Runnable runnable1 = () -> System.out.println("我是既没有参数又没有返回值的方法！");

        runnable1.run();

//Consumer使用lambda表达式语法

Consumer consumer1 = o -> System.out.println(o + "有参但没有返回值的方法就是我！");

        consumer1.accept("哈哈哈哈!");

//Supplier使用Lambda表达式语法

 

   Supplier supplier1 = () -> "无参有返回值！";

        System.out.println(supplier1.get());

//Function使用lambda表达式语法

  // return 和 {} 都可以省略

        Function function1 = o -> o;

        System.out.println(function1.apply("有参有返回值的方法"));

//Comparator使用Lambda表达式语法

     Comparator comparator1 = (o1, o2) -> 0;

     System.out.println(comparator1.compare(10, 20));

//Predicate使用lambda表达式语法

Predicate predicate1 = o -> false;

        System.out.println(predicate1.test("hello"));

 

 

④方法引用实现函数式接口

    方法引用主要指通过方法的名字来指向一个方法而不需要为方法引用提供方法体，该方法的调用交 给函数式接口执行。

方法引用使用一对冒号 :: 将类或对象与方法名进行连接，通常使用方式如下：

对象的非静态方法引用 ObjectName :: MethodName

 类的静态方法引用 ClassName :: StaticMethodName

的非静态方法引用 ClassName :: MethodName

构造器的引用 ClassName :: new

数组的引用 TypeName[] :: new

方法引用是在特定场景下lambda表达式的一种简化表示，可以进一步简化代码的编写使代码更加 紧凑简洁，从而减少冗余代码。

代码例子如下:

//方法引用实现函数式接口的方式之一

        // 1.使用匿名内部类的方式通过函数式接口Runnable中的方法实现对Person类中show方法的调用

        Person person = new Person("lisi",18);

        Runnable runnable = new Runnable() {

            @Override

            public void run() {

                person.show();

            }

        };

        runnable.run();          System.out.println("-----------------------------------------------");

        // 2.使用lambda表达式的方式实现Person类中show方法的调用

        Runnable runnable1 = () -> person.show();

        runnable1.run();        System.out.println("----------------------------------------------");

        // 3.使用方法引用的方式实现Person类中show方法的调用

        Runnable runnable2 = person::show;

        runnable2.run();

 

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

        // 4.使用匿名内部类的方式通过函数式接口Consumer中的方法来实现Person类中setName方法的调用

        Consumer<String> consumer = new Consumer<String>() {

            @Override

            public void accept(String s) {

                person.setName(s);

            }

        };

        consumer.accept("guanyu");

        System.out.println("person = " + person); // guanyu 30

 

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

        // 5.使用lambda表达式的方式实现Person类中setName方法的调用

        Consumer<String> consumer1 = s -> person.setName(s);

        consumer1.accept("liubei");

        System.out.println("person = " + person); // liubei 30

 

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

        // 6.使用方法引用的方式实现Person类中setName方法的调用

        Consumer<String> consumer2 = person::setName;

        consumer2.accept("zhangfei");

        System.out.println("person = " + person); // zhangfei 30

 

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

        // 7.使用匿名内部类的方式通过函数式接口Supplier中的方法来实现Person类中getName方法的调用

        Supplier<String> supplier = new Supplier<String>() {

            @Override

            public String get() {

                return person.getName();

            }

        };

        System.out.println(supplier.get()); // zhangfei

 

        Supplier<String> supplier1 = () -> person.getName();

        System.out.println(supplier1.get()); // zhangfei

 

        Supplier<String> supplier2 = person::getName;

        System.out.println(supplier2.get()); // zhangfei

 

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

        // 8.使用匿名内部类的方式通过函数式接口Function中的方法实现Integer类中parseInt方法的调用

        Function<String, Integer> function = new Function<String, Integer>() {

            @Override

            public Integer apply(String s) {

                return Integer.parseInt(s);

            }

        };

        System.out.println(function.apply("12345")); // 12345

 

        Function<String, Integer> function1 = s -> Integer.parseInt(s);

        System.out.println(function1.apply("12345")); // 12345

 

        Function<String, Integer> function2 = Integer::parseInt;

        System.out.println(function2.apply("12345")); // 12345

 

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

        // 9.使用匿名内部类的方式通过函数式接口Comparator中的方法实现Integer类中compare方法的调用

        Comparator<Integer> comparator = new Comparator<Integer>() {

            @Override

            public int compare(Integer o1, Integer o2) {

                return Integer.compare(o1, o2);

            }

        };

        System.out.println(comparator.compare(10, 20));  // -1

 

        Comparator<Integer> comparator1 = (o1, o2) -> Integer.compare(o1, o2);

        System.out.println(comparator1.compare(10, 20)); // -1

 

        Comparator<Integer> comparator2 = Integer::compare;

        System.out.println(comparator2.compare(10, 20)); // -1

 

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

        // 10.使用匿名内部类的方式通过类名来调用非静态方法（特殊）

        // 其中一个参数对象作为调用对象来调用方法时，可以使用上述方式   更抽象

        Comparator<Integer> comparator3 = new Comparator<Integer>() {

            @Override

            public int compare(Integer o1, Integer o2) {

                return o1.compareTo(o2);

            }

        };

        System.out.println(comparator3.compare(10, 20)); // -1

 

        Comparator<Integer> comparator4 = (o1, o2) -> o1.compareTo(o2);

        System.out.println(comparator4.compare(10, 20)); // -1

 

        Comparator<Integer> comparator5 = Integer::compareTo;

        System.out.println(comparator5.compare(10, 20)); // -1        System.out.println("--------------------------------------------");

        // 11.使用匿名内部类的方式通过Supplier函数式接口创建Person类型的对象并返回

        Supplier<Person> supplier3 = new Supplier<Person>() {

            @Override

            public Person get() {

                return new Person();

            }

        };

        System.out.println(supplier3.get()); // null 0

 

        Supplier<Person> supplier4 = () -> new Person();

        System.out.println(supplier4.get()); // null 0

 

        Supplier<Person> supplier5 = Person::new;

        System.out.println(supplier5.get()); // null 0

 

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

        // 12.使用匿名内部类的方式通过BiFunction函数式接口采用有参方式创建Person类型的对象并返回

        BiFunction<String, Integer, Person> biFunction = new BiFunction<String, Integer, Person>() {

            @Override

            public Person apply(String s, Integer integer) {

                return new Person(s, integer);

            }

        };

        System.out.println(biFunction.apply("zhangfei", 30)); // zhangfei 30

 

        BiFunction<String, Integer, Person> biFunction1 = (s, integer) -> new Person(s, integer);

        System.out.println(biFunction1.apply("zhangfei", 30)); // zhangfei 30

 

        BiFunction<String, Integer, Person> biFunction2 = Person::new;

        System.out.println(biFunction2.apply("zhangfei", 30)); // zhangfei 30

 

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

        // 12.使用匿名内部类的方式通过Function函数式接口创建指定数量的Person类型的对象数组并返回

        Function<Integer, Person[]> function3 = new Function<Integer, Person[]>() {

            @Override

            public Person[] apply(Integer integer) {

                return new Person[integer];

            }

        };

        Person[] pArr = function3.apply(3);

        System.out.println(Arrays.toString(pArr));

        Function<Integer, Person[]> function4 = integer -> new Person[integer];

        System.out.println(Arrays.toString(function4.apply(4)));

        Function<Integer, Person[]> function5 = Person[]::new;

        System.out.println(Arrays.toString(function5.apply(5)));

2.Java8 增加了Stream接口

基本概念

java.util.stream.Stream接口是对集合功能的增强，可以对集合元素进行复杂的查找、过滤、筛选 等操作。 Stream接口借助于Lambda 表达式极大的提高编程效率和程序可读性，同时它提供串行和并行两 种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势。

使用步骤

创建Stream，通过一个数据源来获取一个流。 转换Stream，每次转换返回一个新的Stream  对象。 对Stream进行聚合操作并产生结果。

创建方式

方式一：通过调用集合的默认方法来获取流，如：default Stream stream()

方式二：通过数组工具类中的静态方法来获取流，如：static IntStream stream(int[] array)

方式三：通过Stream接口的静态方法来获取流，如：static Stream of(T... values)

方式四：通过Stream接口的静态方法来获取流，static Stream generate(Supplier s)

代码例子:

 

        // 1.准备一个List集合并放入Person类型的对象后打印

        List<Person> list = new LinkedList<>();

        list.add(new Person("zhansan", 19));

        list.add(new Person("lisi", 13));

        list.add(new Person("wangmazi", 45));

        list.add(new Person("lihu", 33));

        list.add(new Person("liming", 24));

        list.add(new Person("liliya", 64));

        for (Person tp: list) {

            System.out.println(tp);

        }        System.out.println("-------------------------------------------");

        // 2.将List集合中所有成年人过滤出来并放入另外一个集合中打印

        List<Person> list1 = new LinkedList<>();

        for (Person tp : list) {

            if (tp.getAge() >= 18) {

                list1.add(tp);

            }

        }

        for (Person tp : list1) {

            System.out.println(tp);

        }        System.out.println("---------------------------------------------");

        // 3.使用Stream接口实现上述功能

        list.stream().filter(new Predicate<Person>() {

            @Override

            public boolean test(Person person) {

                return person.getAge() >= 18;

            }

        }).forEach(new Consumer<Person>() {

            @Override

            public void accept(Person person) {

                System.out.println(person);

            }

        });        System.out.println("--------------------------------------------");

        // 4.使用lambda表达式对上述代码进行优化

        //list.stream().filter(person -> person.getAge() >= 18).forEach(person -> System.out.println(person));

        list.stream().filter(person -> person.getAge() >= 18).forEach(System.out::println);        System.out.println("-----------------------------------------------");

        // 5.实现对集合中元素通过流跳过个元素后再取个元素后打印

        list.stream().skip(2).limit(3).forEach(System.out::println);        System.out.println("---------------------------------------------");

        // 6.实现集合中所有元素中的年龄获取出来并打印

        list.stream().map(new Function<Person, Integer>() {

            @Override

            public Integer apply(Person person) {

                return person.getAge();

            }

        }).forEach(System.out::println);

 

        //list.stream().map(person -> person.getAge()).forEach(System.out::println);

        list.stream().map(Person::getAge).forEach(System.out::println);        System.out.println("---------------------------------------------");

        // 7.实现集合中所有元素的自然排序并打印

        list.stream().sorted().forEach(System.out::println);        System.out.println("----------------------------------------------");

        // 8.判断集合中是否没有元素的年龄是大于岁的

        boolean b1 = list.stream().noneMatch(new Predicate<Person>() {

            @Override

            public boolean test(Person person) {

                return person.getAge() > 45;

            }

        });

        System.out.println("b1 = " + b1); // true

 

        b1 = list1.stream().noneMatch(person -> person.getAge() > 45);

        System.out.println("b1 = " + b1); // true        System.out.println("---------------------------------------------");

        // 9.按照指定的比较器规则获取集合所有元素中的最大值

        Optional<Person> max = list.stream().max(new Comparator<Person>() {

            @Override

            public int compare(Person o1, Person o2) {

                return o1.getAge() - o2.getAge();

            }

        });

        System.out.println("按照年龄排序后的最大值是：" + max);

 

        max = list.stream().max((o1, o2) -> o1.getAge() - o2.getAge());

        System.out.println("按照年龄排序后的最大值是：" + max);        System.out.println("--------------------------------------------");

        // 10.实现将集合中所有元素的年龄映射出来并进行累加后打印

        Optional<Integer> reduce =          list.stream().map(Person::getAge).reduce(new BinaryOperator<Integer>() {

            @Override

            public Integer apply(Integer integer, Integer integer2) {

                return integer + integer2;

            }

        });

        System.out.println("最终所有年龄的累加和是：" + reduce); // 172

 

        //reduce = list.stream().map(Person::getAge).reduce(((integer, integer2) -> integer + integer2));

        reduce = list.stream().map(Person::getAge).reduce((Integer::sum));

        System.out.println("最终所有年龄的累加和是：" + reduce); // 172

 

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

        // 11.实现将集合中所有元素的姓名映射出来并收集到集合中打印

        list.stream().map(Person::getName).collect(Collectors.toList()).forEach(System.out::println);

 

2.Java8引进Optional类

   基本概念 java.util.Optional类可以理解为一个简单的容器，其值可能是null或者不是null，代表一个值存在 或不存在。 该类的引入很好的解决空指针异常，不用显式进行空值检测。

  用法如下

  

 

        // Java8中使用Optional类实现空值的处理

        // 1.将数据str1装到Optional对象代表的容器中

        String str1 = null;

        Optional<String> optional = Optional.ofNullable(str1);

        // 2.建立映射关系  使用字符串的长度与字符串建立映射关系

        Optional<Integer> integer = optional.map(String::length);

        // 3.若字符串为空则打印，否则打印字符串的数值

        System.out.println("integer = " + integer); // Optional.empty

        System.out.println(integer.orElse(0)); // 0

2.Java9新特性

    ①Java9发布于2017年9月发布，带来了很多新特性，其中最主要的变化是模块化系统。 模块就是代码和数据的封装体，模块的代码被组织成多个包，每个包中包含Java类和接口，模块的 数据则包括资源文件和其他静态信息。

    ②钻石操作符的使用升级:Java9中允许在匿名内部类的使用中使用钻石操作符。

    ③集合工厂法: Java9的List、Set和Map集合中增加了静态工厂方法of实现不可变实例的创建。 不可变体现在无法添加、修改和删除它们的元素。 不允许添加null元素对象。

 实际意义

保证线程安全在并发程序中既保证线程安全性，也大大增强了并发时的效率。 被不可信的类库使用时会很安全。 如果一个对象不需要支持修改操作，将会节省空间和时间的开销。 可以当作一个常量来对待，并且这个对象在以后也不会被改变。

  代码理解:    

       // 创建List类型的不可变实例

        List<Integer> list = List.of(1, 2, 3, 4, 5);

        //list.add(6); // 编译ok，运行发生UnsupportedOperationException不支持此操作的异常

        System.out.println(list); // [1, 2, 3, 4, 5]

 

        Set<Integer> set = Set.of(6, 7, 8);

        //set.add(null);// 编译ok，运行发生UnsupportedOperationException不支持此操作的异常

 

        Map<Integer, String> map = Map.of(1, "one", 2, "two");

        //map.put(3, "three");// 编译ok，运行发生UnsupportedOperationException不支持此操作的异常

 

   ④InputStream的增强: InputStream类中提供了transferTo方法实现将数据直接传输到OutputStream中。

代码示例:

 public static void main(String[] args) {

        InputStream inputStream = null;

        OutputStream outputStream = null;

        try {

            inputStream = new FileInputStream("d:/a.txt");

            outputStream = new FileOutputStream("d:/b.txt");

            inputStream.transferTo(outputStream); // 实现数据的复制，底层是read和write方法的调用

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            if (null != outputStream) {

                try {

                    outputStream.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

            if (null != inputStream) {

                try {

                    inputStream.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }

    }

 

 

3.Java10新特性

    Java10于2018年3月发布，改进的关键点包括一个本地类型推断、一个垃圾回收的增强。 方法声明 功能介绍 boolean isBlank() 判断字符串是否为空或只包含空白代码点 Optional map(Function mapper) 根据参数指定规则的结果来得到Optional类 型的对象 T orElse(T other) 若该值存在就返回，否则返回other的数 值。 Java10计划只是一个短期版本，因此公开更新将在六个月内结束，9月份发布的Java11将是Java的 长期支持（LTS）版本，LTS版本的发布每三年发布一次。

4.Java11新特性

   Java11于2018年9月正式发布，这是 Java 大版本周期变化 后的第一个长期支持版本，非常值得关注。

简化编译运行操作: 在Java11中可以使用java命令一次性进行编译和运行操作。 执行源文件中的第一个类必须包含主方法。 不可以使用其它源文件中自定义的类。

String新增了一些方法如下:

方法声明

功能介绍

Boolean isBlank()

判断字符串是否为空或只包含空白代码点

Optianal map(Function<? super T,?extends U>mapper)

根据参数指定规则的结果来得到Optional类型的对象

T orElse(T other)

若该只存在就返回，否则则返回other的数值

 

  相关解决方案

代码迷 - 您身边的软件异常，代码异常，编程异常助手（发现，解决，分享）
Copyright © 2009-2013 DAIMAMI.COM. All rights reserved.