JAVA8新特性学习笔记

迈不过友情╰ 2022-05-16 03:42 207阅读 0赞

用JAVA8也好久了，在这里记录几个比较常见也是自己常用的新特性，与大家进行分享。

*  Lambda表达式
 *  Stream API
 *  Date API
 *  Optional API
 *  接口的默认方法和静态方法

#### Lambda表达式 ####

它允许我们将函数当成参数传递给某个方法，或者把代码本身当作数据处理。最简单的Lambda表达式可由`逗号分隔的参数列表`、`->`符号和语句块组成。

*  Lambda语法如下

(parameters) -> expression
    或
    (parameters) -> {statements;}

*  使用Lambda的好处
    
     *  不需要声明参数类型，由编译器统一识别参数值。
     *  当参数为一个的时候，不需要定义圆括号，但多个参数的时候需要定义圆括号。
     *  如果函数主体只有一个语句，就不用使用大括号。
     *  如果函数主体只有一个返回值可以不指定返回类型，由编译器自动识别。
 *  举个栗子

public static void mian(String[] args) {
        // 传统编程，不使用Lambda
        List<String> list = Arrays.asList("a", "b", "c");
        for (String i : list) {
          System.out.println("-----不使用Lambda");
          System.out.println("i is : " + i);
        }
    
        // 使用Lambda(1)
        System.out.println("-----使用Lambda(1)");
        list.forEach(k -> System.out.println("k is : " + k));
    
        // 使用Lambda(2)
        list.forEach(k -> {
          System.out.println("-----使用Lambda(2)");
          System.out.println("k is : " + k);
        });
    
        // 使用Lambda(3),不写返回值类型，默认由编译器识别
        System.out.println("-----使用Lambda(3)");
        list.sort((e1, e2) -> e1.compareTo(e2));
    
        // 使用Lambda(4)
        System.out.println("-----使用Lambda(4)");
        list.sort((e1, e2) -> {
          int result = e1.compareTo(e2);
          return result;
        });
      }

#### Stream API ####

新增的Stream API（java.util.stream）将生成环境的函数式编程引入了Java库中。可以通过将List、Set、Array等对象转换成流进行操作。

*  流操作分为两种：
    
     *  中间操作：会返回一个全新的流对象，不会影响最初的流。
     *  最终操作：会将流进行转换或者操作，返回非流对象。
 *  中间操作
    
     *  `java Stream<T> distinct()` 去除流中重复的对象，并返回一个流。
    
        public static void main(String[] args) {
        	List<String> list = Arrays.asList("abc", "abc", "bc", "efg", "abcd", "", "jkl");
        	System.out.println("去重前：" + list);
        	System.out.println("去重后：" + list.stream().distinct().collect(Collectors.joining(",")));
        }
    
     *  `java Stream<T> skip(long n)` 跳过Stream中的前n个对象，将其他对象返回一个Stream。如果n超过了Stream中对象的个数，则会返回一个空的Stream。
    
        public static void main(String[] args) {
        	List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        	System.out.println("skip:");
        	numbers.stream().skip(2).forEach(System.out::println);
        }
    
     *  `java Stream<T> limit(long maxSize)` 截取Stream的前maxSize个对象，并形成一个新Stream。
    
        public static void main(String[] args) {
        	List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        	System.out.println("limit:");
        	numbers.stream().limit(4).forEach(System.out::println);
        }
    
     *  `java Stream<T> filter(Predicate<? super T> predicate)` 根据给定的predicate来过滤对象，返回满足条件的对象构成的Stream。
    
        public static void main(String[] args) {
        	List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
        	System.out.println("filter:");
            numbers.stream().filter(i -> i % 2 == 0).distinct().forEach(System.out::println);
        }
    
     *  `Stream<R> map(Function<? super T, ? extends R> mapper)` 通过给定的mapper，将T类型的流转换为R类型的Stream。
    
        public static void main(String[] args) {
        	List<String> str = Arrays.asList("a", "b", "c", "d");
        	System.out.println("map:");
        	str.stream().map(String::toUpperCase).collect(Collectors.toList()).forEach(System.out::println);
        }
    
     *  `java Stream<T> sorted(); Stream<T> sorted(Comparator<? super T> comparator)` sorted方法可以对Stream进行排序。排序的对象必须实现Comparable，如果没实现会抛出ClassCastException；不提供comparator时，则会调用compareTo方法。
    
        public static void main(String[] args) {
        	List<Integer> list = Arrays.asList(6, 5, 4, 3, 2, 1);
        	System.out.println("倒序：" + list);
        	System.out.println("sorted:");
        	list.stream().sorted().forEach(System.out::println);
        }
 *  最终操作
    
     *  `Optional<T> min(Comparator<? super T> comparator)`&  
        `Optional<T> max(Comparator<? super T> comparator)`
        
         *  根据给定的comparator返回Stream中的max或min。
     *  `long count()`
        
         *  返回Stream中对象的个数。
     *  `<R, A> R collect(Collector<? super T, A, R> collector)`
        
         *  根据给定的collector对Stream中的元素进行操作，返回复杂数据结构的对象。用于将Stream中的对象转换成我们想要的结构，如list、map、set等。  
            前例中就使用collect(Collectors.toList())将Stream中的对象转换成List。
     *  `Object[] toArray()`
        
         *  将Stream中的对象返回成一个Object数组。
     *  `void forEach(Consumer<? super T> action)`
        
         *  顾名思义，对Stream中每个元素进行action操作，但forEach是一个最终操作，一般在结束时查看对象使用。

#### Date API ####

*  Java8在java.time包下提供了很多新的API。以下为两个比较重要的API。
    
     *  Local(本地) − 简化了日期时间的处理，没有时区的问题。
     *  Zoned(时区) − 通过制定的时区处理日期时间。
 *  在Java8之前在处理时间这部分，通常使用`java.util.Date`和`java.text.SimpleDateFormat`

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    	Date d = new Date();
    	String time = sdf.format(d);
    	System.out.println("time is : " + time);

*  Java8本地化日期时间API（copy自网上）：

import java.time.LocalDate;
    import java.time.LocalTime;
    import java.time.LocalDateTime;
    import java.time.Month;
     
    public class Java8Tester {
       public static void main(String args[]){
          Java8Tester java8tester = new Java8Tester();
          java8tester.testLocalDateTime();
       }
        
       public void testLocalDateTime(){
        
          // 获取当前的日期时间
          LocalDateTime currentTime = LocalDateTime.now();
          System.out.println("当前时间: " + currentTime);
            
          LocalDate date1 = currentTime.toLocalDate();
          System.out.println("date1: " + date1);
            
          Month month = currentTime.getMonth();
          int day = currentTime.getDayOfMonth();
          int seconds = currentTime.getSecond();
            
          System.out.println("月: " + month +", 日: " + day +", 秒: " + seconds);
            
          LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
          System.out.println("date2: " + date2);
            
          // 12 december 2014
          LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
          System.out.println("date3: " + date3);
            
          // 22 小时 15 分钟
          LocalTime date4 = LocalTime.of(22, 15);
          System.out.println("date4: " + date4);
            
          // 解析字符串
          LocalTime date5 = LocalTime.parse("20:15:30");
          System.out.println("date5: " + date5);
       }
    }

*  Java8使用时区的日期时间API（copy自网上）：

import java.time.ZoneId;
     
    public class Java8Tester {
       public static void main(String args[]){
          Java8Tester java8tester = new Java8Tester();
          java8tester.testZonedDateTime();
       }
        
       public void testZonedDateTime(){
        
          // 获取当前时间日期
          ZonedDateTime date1 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");
          System.out.println("date1: " + date1);
            
          ZoneId id = ZoneId.of("Europe/Paris");
          System.out.println("ZoneId: " + id);
            
          ZoneId currentZone = ZoneId.systemDefault();
          System.out.println("当期时区: " + currentZone);
       }
    }

#### Optional API ####

*  首先，Optional 类的引入很好的解决空指针异常。Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
 *  Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

import java.util.Optional;
     
    public class Java8Tester {
       public static void main(String args[]){
       
          Java8Tester java8Tester = new Java8Tester();
          Integer value1 = null;
          Integer value2 = new Integer(10);
            
          // Optional.ofNullable - 允许传递为 null 参数
          Optional<Integer> a = Optional.ofNullable(value1);
            
          // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
          Optional<Integer> b = Optional.of(value2);
          System.out.println(java8Tester.sum(a,b));
       }
        
       public Integer sum(Optional<Integer> a, Optional<Integer> b){
        
          // Optional.isPresent - 判断值是否存在
            
          System.out.println("第一个参数值存在: " + a.isPresent());
          System.out.println("第二个参数值存在: " + b.isPresent());
            
          // Optional.orElse - 如果值存在，返回它，否则返回默认值
          Integer value1 = a.orElse(new Integer(0));
            
          //Optional.get - 获取值，值需要存在
          Integer value2 = b.get();
          return value1 + value2;
       }
    }

#### 接口的默认方法和静态方法 ####

这个我平时用的比较少，就简单介绍一下用法。

public interface test {
       default void print(){
          System.out.println("默认方法");
       }
       
       static void staticVoid(){
          System.out.println("静态方法");
       }
    }

最后附上Collectors类的静态工厂方法。

<table> 
 <thead> 
  <tr> 
   <th> 工厂方法</th> 
   <th> 返回类型</th> 
   <th> 作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td> toList</td> 
   <td> <code>List&lt;T&gt;</code></td> 
   <td> 把流中所有项目收集到一个 List</td> 
  </tr> 
  <tr> 
   <td> toSet</td> 
   <td> <code>Set&lt;T&gt;</code></td> 
   <td> 把流中所有项目收集到一个 Set，删除重复项</td> 
  </tr> 
  <tr> 
   <td> toCollection</td> 
   <td> <code>Collection&lt;T&gt;</code></td> 
   <td> 把流中所有项目收集到给定的供应源创建的集合<code>menuStream.collect(toCollection(), ArrayList::new)</code></td> 
  </tr> 
  <tr> 
   <td> counting</td> 
   <td> Long</td> 
   <td> 计算流中元素的个数</td> 
  </tr> 
  <tr> 
   <td> sumInt</td> 
   <td> Integer</td> 
   <td> 对流中项目的一个整数属性求和</td> 
  </tr> 
  <tr> 
   <td> averagingInt</td> 
   <td> Double</td> 
   <td> 计算流中项目 Integer 属性的平均值</td> 
  </tr> 
  <tr> 
   <td> summarizingInt</td> 
   <td> IntSummaryStatistics</td> 
   <td> 收集关于流中项目 Integer 属性的统计值，例如最大、最小、 总和与平均值</td> 
  </tr> 
  <tr> 
   <td> joining</td> 
   <td> String</td> 
   <td> 连接对流中每个项目调用 toString 方法所生成的字符串<code>collect(joining(", "))</code></td> 
  </tr> 
  <tr> 
   <td> maxBy</td> 
   <td> <code>Optional&lt;T&gt;</code></td> 
   <td> 一个包裹了流中按照给定比较器选出的最大元素的 Optional， 或如果流为空则为 Optional.empty()</td> 
  </tr> 
  <tr> 
   <td> minBy</td> 
   <td> <code>Optional&lt;T&gt;</code></td> 
   <td> 一个包裹了流中按照给定比较器选出的最小元素的 Optional， 或如果流为空则为 Optional.empty()</td> 
  </tr> 
  <tr> 
   <td> reducing</td> 
   <td> 归约操作产生的类型</td> 
   <td> 从一个作为累加器的初始值开始，利用 BinaryOperator 与流 中的元素逐个结合，从而将流归约为单个值<code>累加int totalCalories = menuStream.collect(reducing(0, Dish::getCalories, Integer::sum));</code></td> 
  </tr> 
  <tr> 
   <td> collectingAndThen</td> 
   <td> 转换函数返回的类型</td> 
   <td> 包裹另一个收集器，对其结果应用转换函数<code>int howManyDishes = menuStream.collect(collectingAndThen(toList(), List::size))</code></td> 
  </tr> 
  <tr> 
   <td> groupingBy</td> 
   <td> <code>Map&lt;K, List&lt;T&gt;&gt;</code></td> 
   <td> 根据项目的一个属性的值对流中的项目作问组，并将属性值作 为结果 Map 的键</td> 
  </tr> 
  <tr> 
   <td> partitioningBy</td> 
   <td> <code>Map&lt;Boolean,List&lt;T&gt;&gt;</code></td> 
   <td> 根据对流中每个项目应用谓词的结果来对项目进行分区</td> 
  </tr> 
 </tbody> 
</table>