Java8 新特性——新增方法

Optional 类

Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

Optional 类的引入很好的解决空指针异常。

 构建Optional对象

Optional除了构造函数，无法再进行value的set操作，一旦一个Optional对象建立，就不能再改变了。

Optional类的两个构造方法都是private型的，因此不能使用new Optional()的方式来创建Optional对象，Optional类提供了三个静态方法empty()、of(T value)、ofNullable(T value)来创建Optinal对象 

 1、Optional.empty()： 创建一个空的 Optional 实例
 2、Optional.of(T t)：创建一个 Optional 实例，当 t为null时抛出异常（参数非空）      
 3、Optional.ofNullable(T t)：创建一个 Optional 实例，当 t为null时不会抛出异常，而是返回一个空的实例

//1、创建一个空的Optional类的实例
Optional<String> empty = Optional.empty();
System.out.println(new ArrayList<>().stream().findFirst()==Optional.empty());
//输出结果true

//返回特定的非空值Optional。需要一个非null参数；否则，将引发空指针异常。
Optional<String> opt = Optional.of("java");

//返回描述指定值的Optional，如果非空，则返回空值。
Optional<String> opt = Optional.of(null);

获取方法：get()方法

如果此Optional中存在值，则返回该值，否则抛出 NoSuchElementException。

Optional<String> optional1 = Optional.of("java");
if (optional1.isPresent()){ 
  String value = optional1.get();
}

判断方法：

1、isPresent()：判断optional是否为空，如果空则返回false，否则返回true

public boolean isPresent() {
        return value != null;
    }

2、ifPresent(Consumer c)：如果optional不为空，则将optional中的对象传给Comsumer函数

public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

 3、 orElse(T other)：如果optional不为空，则返回optional中的对象；如果为null，则返回 other 这个默认值

public T orElse(T other) {
        return value != null ? value : other;
    }

4、orElseGet(Supplier<T> other)：如果optional不为空，则返回optional中的对象；如果为null，则使用Supplier函数生成默认值other

//如果name有值，则返回name值，否则返回java
String name = Optional.ofNullable(name).orElseGet(() -> "java");

5、orElseThrow(Supplier<X> exception)：如果optional不为空，则返回optional中的对象；如果为null，则抛出Supplier函数生成的异常

public static String getGender(Student student){
  return Optional.ofNullable(student).map(u -> u.getGender()).orElseThrow(() -> new RuntimeException("Unkown"));
}

过滤方法：filter

filter()方法接受参数为Predicate对象，用于对Optional对象进行过滤，如果符合Predicate的条件，返回Optional对象本身，否则返回一个空的Optional对象。 

 List<String> list = Arrays.asList("java", "python", "shell", "C++");
 System.out.println(list.stream().findFirst().filter(StringUtil::isNullOrEmpty));

 映射方法

1、map方法接受一个映射函数参数，返回一个被Optional包装的结果。若结果为空，则返回空Optional。

Optional<String> username = Optional.ofNullable(getUserById(id))
		.map(user -> user.getUsername())
		.map(name -> name.replace('_', ' '));
			
System.out.println("Username is: " + username.orElse("Unknown"));

2、flatMap方法接受一个返回值为Optional的映射函数参数，该返回值亦是flatMap方法的返回值。若结果为空，则返回空Optional。

Optional<String> username = Optional.ofNullable(getUserById(id))
		.flatMap(user -> Optional.of(user.getUsername()))
		.flatMap(name -> Optional.of(name.toLowerCase()));
		
System.out.println("Username is: " + username.orElse("Unknown"));

forEach方法的介绍

Java提供了一个新的forEach() 方法来迭代元素。它在Iterable和Stream接口中定义。这是Iterable接口中定义的默认方法。扩展Iterable接口的集合类可以使用forEach循环来迭代元素。

此方法采用单个参数，该参数是功能接口。因此，您可以将lambda表达式作为参数传递。

public static void main(String[] args) {  
    List<String> list = new ArrayList<>();  
    list.add("aaa");  
    list.add("bbb");  
    list.add("ccc");  
    list.add("ddd");  
 
    list.forEach(System.out::println); 
    
    //list.forEach(str-> System.out.println(str)); 
}  

 

 Collectors类

Collectors类是扩展Object类的final类。它提供归总操作，例如将元素累积到集合中，根据各种标准对元素进行汇总等。

Collectors类的方法

方法	描述
public static <T> Collector<T,?,Double> averagingDouble(ToDoubleFunction<? super T> mapper)	返回一个收集器，该收集器产生应用于输入元素的双值函数的算术平均值。如果不存在任何元素，则结果为0。
public static <T> Collector<T,?,T> reducing(T identity, BinaryOperator<T> op)	返回一个收集器，该收集器使用提供的标识在指定的BinaryOperator下执行其输入元素的缩减。
public static <T> Collector<T,?,Optional<T>> reducing(BinaryOperator<T> op)	返回一个收集器，该收集器在指定的BinaryOperator下执行其输入元素的缩减。结果描述为Optional <T>。
public static <T,U> Collector<T,?,U> reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator<U> op)	返回一个收集器，该收集器在指定的映射函数和BinaryOperator下执行其输入元素的缩减。这是reduce（Object，BinaryOperator）的一般化，它允许在还原之前对元素进行转换。
public static <T,K> Collector<T,?,Map<K,List<T>>> groupingBy(Function<? super T,? extends K> classifier)	返回一个收集器，对类型T的输入元素实施“分组依据”操作，根据分类函数对元素进行分组，然后将结果返回到Map中。
public static <T,K,A,D> Collector<T,?,Map<K,D>> groupingBy(Function<? super T,? extends K> classifier, Collector<? Super T,A,D> downstream)	返回一个收集器，对类型T的输入元素实施级联的“分组依据”操作，根据分类函数对元素进行分组，然后使用指定的下游收集器对与给定键关联的值执行归约操作。
public static <T,K,D,A,M extends Map<K,D>> Collector<T,?,M> groupingBy(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)	返回一个收集器，对类型T的输入元素实施级联的“分组依据”操作，根据分类函数对元素进行分组，然后使用指定的下游收集器对与给定键关联的值执行归约操作。收集器生成的地图是使用提供的工厂功能创建的。
public static <T,K> Collector<T,?,ConcurrentMap<K,List<T>>> groupingByConcurrent(Function<? super T,? extends K> classifier)	返回并发的收集器，对类型T的输入元素实施“分组依据”操作，并根据分类功能对元素进行分组。
public static <T,K,A,D> Collector<T,?,ConcurrentMap<K,D>> groupingByConcurrent(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)	返回并发的收集器，对类型T的输入元素实施级联的“分组依据”操作，根据分类函数对元素进行分组，然后使用指定的下游收集器对与给定键关联的值执行归约操作。
public static <T,K,A,D,M extends ConcurrentMap<K,D>> Collector<T,?,M> groupingByConcurrent(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)	返回并发的收集器，对类型T的输入元素实施级联的“分组依据”操作，根据分类函数对元素进行分组，然后使用指定的下游收集器对与给定键关联的值执行归约操作。收集器生成的ConcurrentMap是使用提供的工厂函数创建的。
public static <T> Collector<T,?,Map<Boolean,List<T>>> partitioningBy(Predicate<? super T> predicate)	返回一个收集器，该收集器根据谓词对输入元素进行分区，并将它们组织成Map <Boolean，List <T >>。不能保证返回的Map的类型，可变性，可序列化性或线程安全性。
public static <T,D,A> Collector<T,?,Map<Boolean,D>> partitioningBy(Predicate<? super T> predicate, Collector<? Super T,A,D> downstream)	返回一个收集器，该收集器根据谓词对输入元素进行分区，根据另一个收集器对每个分区中的值进行归约，然后将它们组织为Map <Boolean，D>，其值是下游归约的结果。
public static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)	返回一个收集器，该收集器将元素累积到一个Map中，其键和值是将提供的映射函数应用于输入元素的结果。
public static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)	返回一个收集器，该收集器将元素累积到一个Map中，其键和值是将提供的映射函数应用于输入元素的结果。
public static <T,K,U,M extends Map<K,U>> Collector<T,?,M> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)	返回一个收集器，该收集器将元素累积到一个Map中，其键和值是将提供的映射函数应用于输入元素的结果。
public static <T,K,U> Collector<T,?,ConcurrentMap<K,U>> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)	返回一个并发的收集器，该收集器将元素累积到ConcurrentMap中，其键和值是将提供的映射函数应用于输入元素的结果。
public static <T,K,U> Collector<T,?,ConcurrentMap<K,U>> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)	返回一个并发的收集器，该收集器将元素累积到ConcurrentMap中，其键和值是将提供的映射函数应用于输入元素的结果。
public static <T,K,U,M extends ConcurrentMap<K,U>> Collector<T,?,M> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)	返回一个并发的收集器，该收集器将元素累积到ConcurrentMap中，其键和值是将提供的映射函数应用于输入元素的结果。
public static <T> Collector<T,?,IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)	返回一个收集器，该收集器将一个产生int的映射函数应用于每个输入元素，并返回结果值的摘要统计信息。
public static <T> Collector<T,?,LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)	返回一个收集器，该收集器将长时间生成的映射函数应用于每个输入元素，并返回结果值的摘要统计信息。
public static <T> Collector<T,?,DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)	返回一个收集器，该收集器将双重生成的映射函数应用于每个输入元素，并返回结果值的摘要统计信息。

 Collectors类案例

public static void main(String[] args) {  
    List<String> list = new ArrayList<>();  
    list.add("aaa");  
    list.add("bbb");  
    list.add("ccc");  
    list.add("ddd");  
 
    //列表形式获取数据：
    System.out.println(list.stream().collect(Collectors.toList()));  
    
    //将数据转换为一组
    System.out.println(list.stream().collect(Collectors.toSet())); 

    //计数元素
    Long count = list.stream().collect(Collectors.counting());  
    System.out.println("Total elements : "+count); 
} 

StringJoiner类

Java在java.util包中添加了一个新的最终类StringJoiner。它用于构造由定界符分隔的字符序列。现在，您可以通过传递诸如comma（，），hyphen（-）等分隔符来创建字符串。还可以将前缀和后缀传递给char序列。

StringJoiner类的构造方法 

构造方法	描述
public StringJoiner(CharSequence delimiter)	构造一个不带任何字符，没有前缀或后缀的StringJoiner，以及提供的定界符的副本。如果分隔符为null，则抛出NullPointerException。
public StringJoiner(CharSequence delimiter,CharSequence prefix,CharSequence suffix)	使用提供的前缀，定界符和后缀的副本构造一个不带任何字符的StringJoiner。如果前缀，分隔符或后缀为null，则抛出NullPointerException。

 StringJoiner类的方法

方法	描述
public StringJoiner add(CharSequence newElement)	将给定CharSequence值的副本添加为StringJoiner值的下一个元素。如果newElement为null，则添加“ null”。
public StringJoiner merge(StringJoiner other)	如果它不是空的，它将添加不带前缀和后缀的给定StringJoiner的内容作为下一个元素。如果给定的StringJoiner为空，则该调用无效。
public int length()	返回此StringJoiner的String表示形式的长度。
public StringJoiner setEmptyValue(CharSequence emptyValue)	设置确定此StringJoiner的字符串表示形式时要使用的字符序列，并且尚未添加任何元素（即，当它为空时）。

 StringJoiner类案例

public static void main(String[] args) {  
    StringJoiner joinNames = new StringJoiner(",");
          
    // Adding values to StringJoiner  
    joinNames.add("Rahul");  
    joinNames.add("Raju");  
    joinNames.add("Peter");  
    joinNames.add("Raheem");  
                  
    System.out.println(joinNames); 
    //Rahul,Raju,Peter,Raheem

    //添加前缀和后缀
    //StringJoiner joinNames = new StringJoiner(",", "[", "]");  
    ...
    //[Rahul,Raju,Peter,Raheem] 
}  

 合并两个StringJoiner   
 merge() 方法合并两个StringJoiner对象，但不包括第二个StringJoiner对象的前缀和后缀。

public static void main(String[] args) {  
  
    StringJoiner joinNames = new StringJoiner(",", "[", "]");   
          
    joinNames.add("Rahul");  
    joinNames.add("Raju");  
  
    StringJoiner joinNames2 = new StringJoiner(":", "[", "]");  
          
    joinNames2.add("Peter");  
    joinNames2.add("Raheem");  
 
    StringJoiner merge = joinNames.merge(joinNames2);   
    System.out.println(merge); 
    //[Rahul,Raju,Peter:Raheem] 
}  

StringJoiner方法

public static void main(String[] args) {  
    StringJoiner joinNames = new StringJoiner(",");    
          
    System.out.println(joinNames);  
          
    joinNames.setEmptyValue("It is empty");  
    System.out.println(joinNames);  
          
    joinNames.add("Rahul");  
    joinNames.add("Raju");  
    System.out.println(joinNames);  
          
    int length = joinNames.length();  
    System.out.println("Length: "+length);  
          
    String str = joinNames.toString();  
    System.out.println(str);  
          
    char ch = str.charAt(3);  
    System.out.println("Character at index 3: "+ch);  
          
    joinNames.add("Sorabh");  
    System.out.println(joinNames);  
          
    int newLength = joinNames.length();  
    System.out.println("New Length: "+newLength);  
}  

/*输出结果为：

It is empty
Rahul,Raju
Length: 10
Rahul,Raju
Character at index 3: u
Rahul,Raju,Sorabh
New Length: 17
*/