jdk1.8特性

墨蓝 2022-06-05 01:43 174阅读 0赞

#  #

# jdk1.8特性 #

### 1.接口的默认方法 ###

*  java8允许给一个给接口添加一个非抽象方法，只需要使用default关键字即可--这个特征又叫扩展方法
    
    #  #
    
        interface MMath{
            double sum(double n1,double n2);
        
            default double sqrt(int n){
                return Math.sqrt(n)
            }
        }
 *  接口可以写静态方法，不用加default
    
    #  #
    
        interface MMath{
            double sum(double n1,double n2);
        
            static double sqrt(int n){
                return Math.sqrt(n)
            }
        }

### 2.Lambda表达式 ###

*  老版本排列字符串
    
    #  #
    
        List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return b.compareTo(a);
            }
        });
 *  lambda表达式排列字符串
    
     *  编译器可以自动推导出参数的类型，所以可以不用再写一次类型
        
        #  #
        
            Collections.sort(names, (String a, String b) -> {
                return b.compareTo(a);
            });
        
        #  #
        
            Collections.sort(names, (String a, String b) -> b.compareTo(a));
        
        #  #
        
            Collections.sort(names, (a, b) -> b.compareTo(a));

### 3.函数式接口 ###

*  “函数式接口”是指仅仅只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。因为 默认方法 不算抽象方法，所以你也可以给你的函数式接口添加默认方法。
 *  可以将lambda表达式当作任意只包含一个抽象方法的接口类型，确保你的接口一定达到这个要求，你只需要给你的接口添加 @FunctionalInterface 注解，编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的。
 *  例子
    
    #  #
    
        @FunctionalInterface
        interface Converter<F, T> {
            T convert(F from);
        }
        Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
        Integer converted = converter.convert("123");
        System.out.println(converted);    // 123
        
        //注意如果@FunctionalInterface如果没有指定，上面的代码也是对的。

### 4.方法与构造函数调用 ###

*  3中的方法还可以用静态方法调用--Java 8 允许你使用 :: 关键字来传递方法或者构造函数引用
    
    #  #
    
        Converter<String, Integer> converter = Integer::valueOf;
        Integer converted = converter.convert("123");
        System.out.println(converted);   // 123
    
    #  #
    
        converter = something::startsWith;
        String converted = converter.convert("Java");
        System.out.println(converted);    // "J"
 *  构造函数
    
    #  #
    
        class Person {
            String firstName;
            String lastName;
            Person() {}
            Person(String firstName, String lastName) {
                this.firstName = firstName;
                this.lastName = lastName;
            }
        }
    
    #  #
    
        interface PersonFactory<P extends Person> {
            P create(String firstName, String lastName);
        }
    
    #  #
    
        PersonFactory<Person> personFactory = Person::new;
        Person person = personFactory.create("Peter", "Parker");

### 5.lambda作用域 ###

*  在lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似。你可以直接访问标记了final的外层局部变量，或者实例的字段以及静态变量。

### 6.访问局部变量 ###

*  可以直接在lambda表达式中访问外层的局部变量
    
    #  #
    
        final int num = 1;
        Converter<Integer, String> stringConverter =
                (from) -> String.valueOf(from + num);
        stringConverter.convert(2);     // 3
        
        //但是和匿名对象不同的是，这里的变量num可以不用声明为final，该代码同样正确：
        int num = 1;
        Converter<Integer, String> stringConverter =
                (from) -> String.valueOf(from + num);
        stringConverter.convert(2);     // 3
        
        //不过这里的num必须不可被后面的代码修改（即隐性的具有final的语义），例如下面的就无法编译
        int num = 1;
        Converter<Integer, String> stringConverter =
                (from) -> String.valueOf(from + num);
        num = 3;
        
        //在lambda表达式中试图修改num同样是不允许的。

### 7.访问对象字段与静态变量 ###

*  和本地变量不同的是，lambda内部对于实例的字段以及静态变量是即可读又可写。该行为和匿名对象是一致的
    
    #  #
    
        class Lambda4 {
            static int outerStaticNum;
            int outerNum;
            void testScopes() {
                Converter<Integer, String> stringConverter1 = (from) -> {
                    outerNum = 23;
                    return String.valueOf(from);
                };
                Converter<Integer, String> stringConverter2 = (from) -> {
                    outerStaticNum = 72;
                    return String.valueOf(from);
                };
            }
        }

### 8.访问接口的默认方法 ###

*  还记得1的MMath例子么，接口MMath定义了一个默认方法sqrt可以直接被MMath的实例包括匿名对象访问到，但是在lambda表达式中这个是不行的。Lambda表达式中是无法访问到默认方法的，以下代码将无法编译：
    
    #  #
    
        Formula formula = (a) -> sqrt( a * 100);
        //Built-in Functional Interfaces
 *  JDK 1.8 API包含了很多内建的函数式接口，在老Java中常用到的比如Comparator或者Runnable接口，这些接口都增加了@FunctionalInterface注解以便能用在lambda上。Java 8 API同样还提供了很多全新的函数式接口来让工作更加方便，有一些接口是来自Google Guava库里的，即便你对这些很熟悉了，还是有必要看看这些是如何扩展到lambda上使用的。
    
     *  Predicate接口:Predicate 接口只有一个参数，返回boolean类型。该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非
        
        #  #
        
            Predicate<String> predicate = (s) -> s.length() > 0;
            predicate.test("foo");              // true
            predicate.negate().test("foo");     // false
            Predicate<Boolean> nonNull = Objects::nonNull;
            Predicate<Boolean> isNull = Objects::isNull;
            Predicate<String> isEmpty = String::isEmpty;
            Predicate<String> isNotEmpty = isEmpty.negate();
     *  Function 接口：Function 接口有一个参数并且返回一个结果，并附带了一些可以和其他函数组合的默认方法（compose, andThen
        
        #  #
        
            Function<String, Integer> toInteger = Integer::valueOf;
            Function<String, String> backToString = toInteger.andThen(String::valueOf);
            backToString.apply("123");     // "123"
     *  Supplier 接口:Supplier 接口返回一个任意范型的值，和Function接口不同的是该接口没有任何参数
        
        #  #
        
            Supplier<Person> personSupplier = Person::new;
            personSupplier.get();   // new Person
     *  Consumer 接口：Consumer 接口表示执行在单个参数上的操作
        
        #  #
        
            Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
            greeter.accept(new Person("Luke", "Skywalker"));
     *  Comparator 接口:Comparator 是老Java中的经典接口， Java 8在此之上添加了多种默认方法
        
        #  #
        
            Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
            Person p1 = new Person("John", "Doe");
            Person p2 = new Person("Alice", "Wonderland");
            comparator.compare(p1, p2);             // > 0
            comparator.reversed().compare(p1, p2);  // < 0
     *  Optional 接口:Optional 不是函数是接口，这是个用来防止NullPointerException异常的辅助类型，这个接口能干什么：Optional 被定义为一个简单的容器，其值可能是null或者不是null。在Java 8之前一般某个函数应该返回非空对象但是偶尔却可能返回了null，而在Java 8中，不推荐你返回null而是返回Optional。
        
        #  #
        
            Optional<String> optional = Optional.of("bam");
            optional.isPresent();           // true
            optional.get();                 // "bam"
            optional.orElse("fallback");    // "bam"
            optional.ifPresent((s) -> System.out.println(s.charAt(0)));     // "b"
     *  Stream 接口：java.util.Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样你就可以将多个操作依次串起来。Stream 的创建需要指定一个数据源，比如 java.util.Collection的子类，List或者Set， Map不支持。Stream的操作可以串行执行或者并行执行。
        
        #  #
        
            List<String> stringCollection = new ArrayList<>();
            stringCollection.add("ddd2");
            stringCollection.add("aaa2");
            stringCollection.add("bbb1");
            stringCollection.add("aaa1");
            stringCollection.add("bbb3");
            stringCollection.add("ccc");
            stringCollection.add("bbb2");
            stringCollection.add("ddd1");
            
            //Filter 过滤
            stringCollection
                .stream()
                .filter((s) -> s.startsWith("a"))
                .forEach(System.out::println);
            // "aaa2", "aaa1"
            
            //Sort 排序
            stringCollection
                .stream()
                .sorted()
                .filter((s) -> s.startsWith("a"))
                .forEach(System.out::println);
            // "aaa1", "aaa2"           
            
            //需要注意的是，排序只创建了一个排列好后的Stream，而不会影响原有的数据源，排序之后原数据stringCollection是不会被修改的
            System.out.println(stringCollection);
            // ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1
            
            //Map 映射
            stringCollection
                .stream()
                .map(String::toUpperCase)
                .sorted((a, b) -> b.compareTo(a))
                .forEach(System.out::println);
            // "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"
            
            //Match 匹配
            boolean anyStartsWithA = 
                stringCollection
                    .stream()
                    .anyMatch((s) -> s.startsWith("a"));
            System.out.println(anyStartsWithA);      // true
            boolean allStartsWithA = 
                stringCollection
                    .stream()
                    .allMatch((s) -> s.startsWith("a"));
            System.out.println(allStartsWithA);      // false
            boolean noneStartsWithZ = 
                stringCollection
                    .stream()
                    .noneMatch((s) -> s.startsWith("z"));
            System.out.println(noneStartsWithZ);      // true
            
            //Count计数
            long startsWithB = 
                stringCollection
                    .stream()
                    .filter((s) -> s.startsWith("b"))
                    .count();
            System.out.println(startsWithB);    // 3
            
            //Reduce 规约
            Optional<String> reduced =
                stringCollection
                    .stream()
                    .sorted()
                    .reduce((s1, s2) -> s1 + "#" + s2);
            reduced.ifPresent(System.out::println);
            // "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2"
            
            //并行Streams
            int max = 1000000;
            List<String> values = new ArrayList<>(max);
            for (int i = 0; i < max; i++) {
                UUID uuid = UUID.randomUUID();
                values.add(uuid.toString());
            }
            
            //串行耗时
            long t0 = System.nanoTime();
            long count = values.stream().sorted().count();
            System.out.println(count);
            long t1 = System.nanoTime();
            long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
            System.out.println(String.format("sequential sort took: %d ms", millis));
            
            //并行耗时
            long t0 = System.nanoTime();
            long count = values.parallelStream().sorted().count();
            System.out.println(count);
            long t1 = System.nanoTime();
            long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
            System.out.println(String.format("parallel sort took: %d ms", millis));
     *  Map:前面提到过，Map类型不支持stream，不过Map提供了一些新的有用的方法来处理一些日常任务。
        
        #  #
        
            Map<Integer, String> map = new HashMap<>();
            for (int i = 0; i < 10; i++) {
                map.putIfAbsent(i, "val" + i);
            }
            
            map.computeIfPresent(3, (num, val) -> val + num);
            map.get(3);             // val33
            map.computeIfPresent(9, (num, val) -> null);
            map.containsKey(9);     // false
            map.computeIfAbsent(23, num -> "val" + num);
            map.containsKey(23);    // true
            map.computeIfAbsent(3, num -> "bam");
            map.get(3);             // val33
            
            map.remove(3, "val3");
            map.get(3);             // val33
            map.remove(3, "val33");
            map.get(3);             // null
            
            map.getOrDefault(42, "not found");  // not found
            
            map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
            map.get(9);             // val9
            map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
            map.get(9);             // val9concat

### 9.Date API ###

*  Clock 时钟:Clock类提供了访问当前日期和时间的方法，Clock是时区敏感的，可以用来取代 System.currentTimeMillis() 来获取当前的微秒数。某一个特定的时间点也可以使用Instant类来表示，Instant类也可以用来创建老的java.util.Date对象。 复制代码 代码如下:
    
    #  #
    
        Clock clock = Clock.systemDefaultZone();
        long millis = clock.millis();
        Instant instant = clock.instant();
        Date legacyDate = Date.from(instant);   // legacy java.util.Date
 *  Timezones 时区:在新API中时区使用ZoneId来表示。时区可以很方便的使用静态方法of来获取到。 时区定义了到UTS时间的时间差，在Instant时间点对象到本地日期对象之间转换的时候是极其重要的。
    
    #  #
    
        System.out.println(ZoneId.getAvailableZoneIds());
        // prints all available timezone ids
        ZoneId zone1 = ZoneId.of("Europe/Berlin");
        ZoneId zone2 = ZoneId.of("Brazil/East");
        System.out.println(zone1.getRules());
        System.out.println(zone2.getRules());
        // ZoneRules[currentStandardOffset=+01:00]
        // ZoneRules[currentStandardOffset=-03:00]
 *  LocalTime 本地时间:LocalTime 定义了一个没有时区信息的时间，例如 晚上10点，或者 17:30:15。下面的例子使用前面代码创建的时区创建了两个本地时间。之后比较时间并以小时和分钟为单位计算两个时间的时间差：
    
    #  #
    
        LocalTime now1 = LocalTime.now(zone1);
        LocalTime now2 = LocalTime.now(zone2);
        System.out.println(now1.isBefore(now2));  // false
        long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
        long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);
        System.out.println(hoursBetween);       // -3
        System.out.println(minutesBetween);     // -239
 *  LocalTime 提供了多种工厂方法来简化对象的创建，包括解析时间字符串。
    
    #  #
    
        LocalTime late = LocalTime.of(23, 59, 59);
        System.out.println(late);       // 23:59:59
        DateTimeFormatter germanFormatter =
            DateTimeFormatter
                .ofLocalizedTime(FormatStyle.SHORT)
                .withLocale(Locale.GERMAN);
        LocalTime leetTime = LocalTime.parse("13:37", germanFormatter);
        System.out.println(leetTime);   // 13:37
 *  LocalDate 本地日期:LocalDate 表示了一个确切的日期，比如 2014-03-11。该对象值是不可变的，用起来和LocalTime基本一致。下面的例子展示了如何给Date对象加减天/月/年。另外要注意的是这些对象是不可变的，操作返回的总是一个新实例。
    
    #  #
    
        LocalDate today = LocalDate.now();
        LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
        LocalDate yesterday = tomorrow.minusDays(2);
        LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
        DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();
        
        System.out.println(dayOfWeek);    // FRIDAY
 *  从字符串解析一个LocalDate类型和解析LocalTime一样简单：
    
    #  #
    
        DateTimeFormatter germanFormatter =
            DateTimeFormatter
                .ofLocalizedDate(FormatStyle.MEDIUM)
                .withLocale(Locale.GERMAN);
        LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
        System.out.println(xmas);   // 2014-12-24
 *  LocalDateTime 本地日期时间:LocalDateTime 同时表示了时间和日期，相当于前两节内容合并到一个对象上了。LocalDateTime和LocalTime还有LocalDate一样，都是不可变的。LocalDateTime提供了一些能访问具体字段的方法。
    
    #  #
    
        LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);
        DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
        System.out.println(dayOfWeek);      // WEDNESDAY
        Month month = sylvester.getMonth();
        System.out.println(month);          // DECEMBER
        long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
        System.out.println(minuteOfDay);    // 1439
 *  只要附加上时区信息，就可以将其转换为一个时间点Instant对象，Instant时间点对象可以很容易的转换为老式的java.util.Date。
    
    #  #
    
        Instant instant = sylvester
                .atZone(ZoneId.systemDefault())
                .toInstant();
        Date legacyDate = Date.from(instant);
        System.out.println(legacyDate);     // Wed Dec 31 23:59:59 CET 2014
 *  格式化LocalDateTime和格式化时间和日期一样的，除了使用预定义好的格式外，我们也可以自己定义格式：
    
    #  #
    
        DateTimeFormatter formatter =
                DateTimeFormatter
                    .ofPattern("MMM dd, yyyy - HH:mm");
            LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter);
            String string = formatter.format(parsed);
            System.out.println(string);     // Nov 03, 2014 - 07:13
 *  和java.text.NumberFormat不一样的是新版的DateTimeFormatter是不可变的，所以它是线程安全的。

### 10.Annotation 注解 ###

*  在Java 8中支持多重注解了，先看个例子来理解一下是什么意思。 首先定义一个包装类Hints注解用来放置一组具体的Hint注解：
    
    #  #
    
        @interface Hints {
            Hint[] value();
        }
        @Repeatable(Hints.class)
        @interface Hint {
            String value();
        }
 *  Java 8允许我们把同一个类型的注解使用多次，只需要给该注解标注一下@Repeatable即可。 例 1: 使用包装类当容器来存多个注解（老方法）
    
    #  #
    
        @Hints({@Hint("hint1"), @Hint("hint2")})
        class Person {}
 *  例 2：使用多重注解（新方法）
    
    #  #
    
        @Hint("hint1")
        @Hint("hint2")
        class Person {}
 *  第二个例子里java编译器会隐性的帮你定义好@Hints注解，了解这一点有助于你用反射来获取这些信息：
    
    #  #
    
        Hint hint = Person.class.getAnnotation(Hint.class);
        System.out.println(hint);                   // null
        Hints hints1 = Person.class.getAnnotation(Hints.class);
        System.out.println(hints1.value().length);  // 2
        Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);
        System.out.println(hints2.length);          // 2
 *  即便我们没有在Person类上定义@Hints注解，我们还是可以通过 getAnnotation(Hints.class) 来获取 @Hints注解，更加方便的方法是使用 getAnnotationsByType 可以直接获取到所有的@Hint注解。另外Java 8的注解还增加到两种新的target上了：
    
    #  #
    
        @Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
        @interface MyAnnotation {}