JAVA8新特性学习笔记

用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类的静态工厂方法。

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