Java番外篇2——jdk8新特性

Myth丶恋晨 2023-10-03 16:02 9阅读 0赞

## Java番外篇2——jdk8新特性 ##

### 1、Lambda ###

#### 1.1、无参无返回值 ####

public class Test {
        
        interface Print{
        
            void print();
        }
        public static void main(String[] args) {
        
    //        Print print=new Print() {
        
    //            @Override
    //            public void print() {
        
    //                System.out.println("hello word!");
    //            }
    //        };
            Print print=()-> System.out.println("hello word!");
            print.print();
        }
    }

#### 1.2、一个参数无返回值 ####

public class Test {
        
        interface Print{
        
            void print(String str);
        }
        public static void main(String[] args) {
        
    //        Print print=new Print() {
        
    //            @Override
    //            public void print(String str) {
        
    //                System.out.println("hello word! "+str);
    //            }
    //        };
            Print print=str-> System.out.println("hello word! "+str);
            print.print("ruoye");
        }
    }

#### 1.3、多个参数无返回值 ####

public class Test {
        
        interface Print{
        
            void print(String str,String str1);
        }
        public static void main(String[] args) {
        
    //        Print print=new Print() {
        
    //            @Override
    //            public void print(String str,String str1); {
        
    //                System.out.println("hello word! "+str+str1);
    //            }
    //        };
            Print print=(str,str1)-> System.out.println("hello word! "+str+str1);
            print.print("ruoye","yoya");
        }
    }

#### 1.4、多个参数有返回值(单句) ####

public class Test {
        
        interface Print{
        
            String print(String str,String str1);
        }
        public static void main(String[] args) {
        
            Print print=(str,str1)-> str+str1;
            System.out.println(print.print("ruoye", "yoya"));
        }
    }

#### 1.4、多个参数有返回值(多句) ####

public class Test {
        
        interface Print{
        
            String print(String str,String str1);
        }
        public static void main(String[] args) {
        
            Print print=(str,str1)-> {
        
                System.out.println("hello word! "+str+str1);
                return str+str1;
            };
            System.out.println(print.print("ruoye", "yoya"));
        }
    }

### 2、函数式接口（@FunctionalInterface） ###

*  该注解只能标记在"有且仅有一个抽象方法"的接口上
 *  JDK8接口中可以定义静态方法和默认方法（方法默认实现default），都不算是抽象方法

public class Test {
        
        @FunctionalInterface
        interface Print{
        
            String print(String str,String str1);
        }
        public static void main(String[] args) {
        
            Print print=(str,str1)-> {
        
                System.out.println("hello word! "+str+str1);
                return str+str1;
            };
            System.out.println(print.print("ruoye", "yoya"));
        }
    }

### 3、接口调整 ###

方便接口扩展

jdk8之前接口只能有静态常量和抽象方法

jdk8后接口可以有默认方法和静态方法

public interface Print{
        
        public static void aaa(){
        
            System.out.println("aaa");
        }
        public default void bbb(){
        
            System.out.println("bbb");
        }
        String print(String str,String str1);
    }

### 4、方法引用 ###

### 5、Stream（流水线） ###

*  集合遍历有弊端
 *  筛选
 *  切片
 *  映射
 *  查找
 *  去重
 *  统计
 *  匹配
 *  归约

**特性**

*  Stream只能操作一次
 *  Stream方法返回的是新的流
 *  Stream不调用终结方法，中间的操作不会执行

#### 5.1、Stream的获取 ####

public class Test {
        
        public static void main(String[] args) {
        
            //集合
            List<String> strings = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu");
            Stream<String> stream = strings.stream();
            //数组
            String[] strings1={
        "zhangsan", "lisi", "wangwu", "zhaoliu"};
            Stream<String> stream1 = Stream.of(strings1);
            //map可以通过获取键集合，值集合，从而获得流
        }
    }

#### 5.2、常用方法 ####

<table> 
 <thead> 
  <tr> 
   <th>方法声明</th> 
   <th>功能介绍</th> 
   <th>返回值</th> 
   <th>方法类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>count</td> 
   <td>统计个数</td> 
   <td>long</td> 
   <td>终结</td> 
  </tr> 
  <tr> 
   <td>forEach</td> 
   <td>逐一处理</td> 
   <td>void</td> 
   <td>终结</td> 
  </tr> 
  <tr> 
   <td>filter</td> 
   <td>过滤</td> 
   <td>Stream</td> 
   <td>函数拼接</td> 
  </tr> 
  <tr> 
   <td>limit</td> 
   <td>取用前几个</td> 
   <td>Stream</td> 
   <td>函数拼接</td> 
  </tr> 
  <tr> 
   <td>skip</td> 
   <td>跳过前几个</td> 
   <td>Stream</td> 
   <td>函数拼接</td> 
  </tr> 
  <tr> 
   <td>map</td> 
   <td>映射</td> 
   <td>Stream</td> 
   <td>函数拼接</td> 
  </tr> 
  <tr> 
   <td>concat</td> 
   <td>组合</td> 
   <td>Stream</td> 
   <td>函数拼接</td> 
  </tr> 
 </tbody> 
</table>

#### 5.3、forEach ####

public class Test {
        
        public static void main(String[] args) {
        
            List<String> strings = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu");
            strings.stream()
                    .forEach(System.out::println);
        }
    }

#### 5.4、count ####

public class Test {
        
        public static void main(String[] args) {
        
            List<String> strings = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu");
            System.out.println(strings.stream()
                    .count());
        }
    }

#### 5.5、filter ####

public class Test {
        
        public static void main(String[] args) {
        
            List<String> strings = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu");
            strings.stream()
                    .filter(s -> s.startsWith("z"))
                    .forEach(System.out::println);
        }
    }

#### 5.6、limit ####

public class Test {
        
        public static void main(String[] args) {
        
            List<String> strings = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu");
            strings.stream()
                    .limit(1)
                    .forEach(System.out::println);
        }
    }

#### 5.7、skip ####

public class Test {
        
        public static void main(String[] args) {
        
            List<String> strings = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu");
            strings.stream()
                    .skip(1)
                    .forEach(System.out::println);
        }
    }

#### 5.8、map ####

完成数据转换、处理

public class Test {
        
        public static void main(String[] args) {
        
            List<String> strings = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu");
            strings.stream()
                    .map(s->s+="yoya")
                    .forEach(System.out::println);
        }
    }

#### 5.9、sorted ####

public class Test {
        
        public static void main(String[] args) {
        
            List<String> strings = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu");
            strings.stream()
                    .sorted()
                    .forEach(System.out::println);
        }
    }

#### 5.10、distinct ####

Stream流中的distinct方法对于基本数据类型是可以直接出重的，但是对于自定义类型，需要重写hashCode和equals方法来移除重复元素

public class Test {
        
        public static void main(String[] args) {
        
            List<String> strings = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu","zhangsan");
            strings.stream()
                    .distinct()
                    .forEach(System.out::println);
        }
    }

#### 5.11、match ####

public class Test {
        
        public static void main(String[] args) {
        
            List<String> strings = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu","zhangsan");
            System.out.println(strings.stream()
                    .anyMatch(s -> s.startsWith("z")));
        }
    }

#### 5.12、find ####

findfirst返回第一个元素

findany返回随机一个元素

public class Test {
        
        public static void main(String[] args) {
        
            List<String> strings = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu","zhangsan");
            Optional<String> z = strings.stream()
                    .filter(s -> s.startsWith("z"))
                    .findAny();
            System.out.println(z.get());
        }
    }

#### 5.13、max，min ####

public class Test {
        
        public static void main(String[] args) {
        
            List<String> strings = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu","zhangsan");
            Optional<String> max = strings.stream()
                    .max((s1, s2) -> {
        
                        return s1.compareTo(s2);
                    });
            System.out.println(max.get());
        }
    }

public class Test {
        
        public static void main(String[] args) {
        
            List<String> strings = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu","zhangsan");
            Optional<String> max = strings.stream()
                    .min((s1, s2) -> {
        
                        return s1.compareTo(s2);
                    });
            System.out.println(max.get());
        }
    }

#### 5.14、reduce ####

归约

public class Test {
        
        public static void main(String[] args) {
        
            Integer reduce = Stream.of(1, 2, 3, 4, 5)
                    .reduce(0, (a, b) -> {
        
                        return a + b;
                    });
            System.out.println(reduce);
        }
    }

#### 5.15、mapToInt ####

转为int

public class Test {
        
        public static void main(String[] args) {
        
            Integer[] integers={
        1, 2, 3, 4, 5};
            Stream.of(integers)
                    .mapToInt(Integer::intValue)
                    .forEach(System.out::println);
        }
    }

#### 5.16、concat ####

合并流

public class Test {
        
        public static void main(String[] args) {
        
            Integer[] integers={
        1, 2, 3, 4, 5};
            Integer[] integers1={
        6,7,8,9,10};
            Stream<Integer> concat = Stream.concat(Stream.of(integers), Stream.of(integers1));
            concat
                    .mapToInt(Integer::intValue)
                    .forEach(System.out::println);
        }
    }

#### 5.17、结果收集 ####

public class Test {
        
        public static void main(String[] args) {
        
            Integer[] integers={
        1, 2, 3, 4, 5};
            Integer[] integers1={
        6,7,8,9,10};
            Stream<Integer> concat = Stream.concat(Stream.of(integers), Stream.of(integers1));
            List<Integer> collect = concat
                    .collect(Collectors.toList());
            System.out.println(collect);
    
        }
    }

public class Test {
        
        public static void main(String[] args) {
        
            Integer[] integers={
        1, 2, 3, 4, 5};
            Integer[] integers1={
        6,7,8,9,10};
            Stream<Integer> concat = Stream.concat(Stream.of(integers), Stream.of(integers1));
            List<Integer> collect = concat
                    .collect(Collectors.toCollection(ArrayList::new));
            System.out.println(collect);
    
        }
    }

public class Test {
        public static void main(String[] args) {
            Integer[] integers={1, 2, 3, 4, 5};
            Integer[] integers1={6,7,8,9,10};
            Stream<Integer> concat = Stream.concat(Stream.of(integers), Stream.of(integers1));
            Integer[] integers2 = concat
                    .toArray(Integer[]::new);
            System.out.println(Arrays.toString(integers2));
    
        }
    }

#### 5.19、聚合 ####

#### 5.20、分组 ####

public class Test {
        
        public static void main(String[] args) {
        
            Person person0 = new Person(1, "zhangsan", true);
            Person person1 = new Person(2, "lisi", true);
            Person person2 = new Person(3, "zhangsan", false);
            Person person3 = new Person(4, "lisi", true);
            Person person4 = new Person(5, "zhangsan", true);
    //        Stream<Person> person = Stream.of(person0, person1, person2, person3, person4);
    //        Map<String, List<Person>> collect = person
    //                .collect(Collectors.groupingBy(person5 -> person5.getName()));
    //        System.out.println(collect);
    
    //        Stream<Person> person = Stream.of(person0, person1, person2, person3, person4);
    //        Map<String, List<Person>> collect = person
    //                .collect(Collectors.groupingBy(person5 -> person5.isGender()?"男":"女"));
    //        System.out.println(collect);
    
            Stream<Person> person = Stream.of(person0, person1, person2, person3, person4);
            Map<String, Map<String, List<Person>>> collect = person
                    .collect(Collectors.groupingBy(person5 -> person5.getName(), Collectors.groupingBy(person5 -> person5.isGender() ? "男" : "女")));
            System.out.println(collect);
    
        }
    }

#### 5.21、分区 ####

#### 5.22、joining ####

public class Test {
        
        public static void main(String[] args) {
        
            Person person0 = new Person(1, "zhangsan", true);
            Person person1 = new Person(2, "lisi", true);
            Person person2 = new Person(3, "zhangsan", false);
            Person person3 = new Person(4, "lisi", true);
            Person person4 = new Person(5, "zhangsan", true);
    
    //        Stream<Person> person = Stream.of(person0, person1, person2, person3, person4);
    //        String collect = person
    //                .map(person5 -> person5.getName())
    //                .collect(Collectors.joining());
    //        System.out.println(collect);
    //
    //        Stream<Person> person = Stream.of(person0, person1, person2, person3, person4);
    //        String collect = person
    //                .map(person5 -> person5.getName())
    //                .collect(Collectors.joining("_"));
    //        System.out.println(collect);
    
            Stream<Person> person = Stream.of(person0, person1, person2, person3, person4);
            String collect = person
                    .map(person5 -> person5.getName())
                    .collect(Collectors.joining("_","###","$$$"));
            System.out.println(collect);
    
        }
    }

#### 5.23、并行流 ####

并行流出现问题可尝试使用同步代码块

### 6、日期 ###

*  设计不合理，在java.util和java.sql的包中都有日期类，java.util.Date同时包含日期和时间的，而 java.sql.Date仅仅包含日期，此外用于格式化和解析的类在java.text包下
 *  非线程安全，java.util.Date是非线程安全的，所有的日期类都是可变的，这是java日期类最大的问 题之一
 *  时区处理麻烦，日期类并不提供国际化，没有时区支持

JDK 8中增加了一套全新的日期时间API，这套API设计合理，是线程安全（每次都返回新对象）的，新的日期及时间API位于java.time包

*  LocalDate ：表示日期，包含年月日，格式为 2019-10-16
 *  LocalTime ：表示时间，包含时分秒，格式为 16:38:54.158549300
 *  LocalDateTime ：表示日期时间，包含年月日，时分秒，格式为 2018-09-06T15:33:56.750
 *  DateTimeFormatter ：日期时间格式化类
 *  Instant：时间戳，表示一个特定的时间瞬间
 *  Duration：用于计算2个时间(LocalTime，时分秒)的距离
 *  Period：用于计算2个日期(LocalDate，年月日)的距离
 *  ZonedDateTime ：包含时区的时间

#### 6.1、LocalDate ####

public class Test {
        
        public static void main(String[] args) {
        
            //指定日期创建
            LocalDate localDate=LocalDate.of(2020,10,19);
            System.out.println(localDate);
            //当前日期创建
            System.out.println(LocalDate.now());
            //更改日期
            LocalDate localDate1 = localDate.withMonth(11);
            System.out.println(localDate1);
            //日期增减（plus，minus）
            LocalDate localDate2 = localDate1.plusDays(1);
            System.out.println(localDate2);
            //日期比较
            System.out.println(localDate.isAfter(localDate1));
            System.out.println(localDate.isBefore(localDate1));
        }
    }

#### 6.2、LocalTime ####

public class Test {
        
        public static void main(String[] args) {
        
            //指定时间创建
            LocalTime localTime=LocalTime.of(10,19,0,123);
            System.out.println(localTime);
            //当前时间创建
            System.out.println(LocalTime.now());
            //时间更改
            LocalTime localTime1 = localTime.withHour(11);
            System.out.println(localTime1);
            //时间增减（plus，minus）
            LocalTime localTime2 = localTime1.plusHours(1);
            System.out.println(localTime2);
            //时间比较同上
        }
    }

#### 6.3、LocalDateTime ####

public class Test {
        
        public static void main(String[] args) {
        
            LocalDate now = LocalDate.now();
            LocalTime now1 = LocalTime.now();
            LocalDateTime now2 = LocalDateTime.now();
            System.out.println(LocalDateTime.of(now,now1));
            System.out.println(now2);
            //同样有设置、增减、比较
        }
    }

#### 6.4、DateTimeFormatter ####

日期时间格式化与解析

public class Test {
        
        public static void main(String[] args) {
        
            LocalDateTime now = LocalDateTime.now();
            DateTimeFormatter dateTimeFormatter=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            System.out.println(dateTimeFormatter.format(now));
            String str="2021-07-16 11:03:00";
            LocalDateTime parse = LocalDateTime.parse(str, dateTimeFormatter);
            System.out.println(parse);
        }
    }

#### 6.5、Instant ####

public class Test {
        public static void main(String[] args) {
            Instant instant=Instant.now();
            System.out.println(instant.getNano());
        }
    }

#### 6.6、Duration、Period ####

Duration：时间差

Period：日期差

public class Test {
        
        public static void main(String[] args) {
        
            Duration duration = Duration.between(LocalTime.now(), LocalTime.of(12, 0, 0, 0));
            System.out.println(duration.toHours());
            System.out.println(duration.toMinutes());
            System.out.println(duration.toMillis());
        }
    }

public class Test {
        
        public static void main(String[] args) {
        
            Period period = Period.between(LocalDate.now(), LocalDate.of(2022, 5, 2));
            System.out.println(period.getDays());
            System.out.println(period.getMonths());
            System.out.println(period.getYears());
        }
    }

#### 6.7、时区 ####

public class Test {
        
        public static void main(String[] args) {
        
            //所有时区
            for (String availableZoneId : ZoneId.getAvailableZoneIds()) {
        
                System.out.println(availableZoneId);
            }
            //获取标准时间
            ZonedDateTime zonedDateTime=ZonedDateTime.now(Clock.systemUTC());
            System.out.println(zonedDateTime);
            //获取默认时区时间
            ZonedDateTime zonedDateTime1=ZonedDateTime.now();
            System.out.println(zonedDateTime1);
            //获取指定时区世家
            ZonedDateTime zonedDateTime2=ZonedDateTime.now(ZoneId.of("America/Cuiaba"));
            System.out.println(zonedDateTime2);
        }
    }

### 7、@Repeatable ###

允许重复注解

### 8、@Target属性 ###

ElementType.TYPE\_PARAMETER：允许注解写在声明语句中

ElementType.TYPE\_USE：任何定义的地方都可以用