JDK8-新特性-附demo

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Base64;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
public class test {
  public static void main(String[] args) {
    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 过滤
    过滤通过一个predicate接口来过滤并只保留符合条件的元素，该操作属于中间操作，所以我们可以在过滤后的结果来应用其他Stream操作 （比如forEach）。
    forEach需要一个函数来对过滤后的元素依次执行。forEach是一个最终操作，所以我们不能在forEach之后来执行 其他Stream操作。*/
    stringCollection
     .stream()
     .filter((s) -> s.startsWith("a"))
     .forEach(System.out::println);
    System.out.println("--------1------");
    /*Sort 排序
    排序是一个中间操作，返回的是排序好后的Stream。如果你不指定一个自定义的Comparator则会使用默认排序。
    倒叙
    */
    stringCollection
    .stream()
    .filter((s) -> s.startsWith("a"))
    .sorted(Comparator.reverseOrder())
    .collect(Collectors.toList())
    .forEach(a ->{
      System.out.println(a.toString());
    });


    System.out.println("-------2-------");
    //正序
    stringCollection
    .stream()
    .filter((s) -> s.startsWith("a"))
    .sorted()
    .forEach(a ->{
      System.out.println(a.toString());
    });

    System.out.println("-------3-------");

  /*  Map 映射
    中间操作map会将元素根据指定的Function接口来依次将元素转成另外的对象，
    下面的示例展示了将字符串转换为大写字符串。你也可以通过map来讲对象转换成其他类型，map返回的Stream类型是根据你map传递进去的函数的返回值决定的。*/

    stringCollection
    .stream()
    .map(String :: toUpperCase)//大写
    .map(String :: toLowerCase)//小写
    .sorted((a, b) ->b.compareTo(a))
    .forEach(System.out::println);


    System.out.println("-------4-------");
    /*Match 匹配
    Stream提供了多种匹配操作，允许检测指定的Predicate是否匹配整个Stream。所有的匹配操作都是最终操作，并返回一个boolean类型的值。*/
    boolean anyMatch = stringCollection
    .stream()
    .anyMatch((a) -> a.startsWith("a"));

    System.out.println(anyMatch);

    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



    System.out.println("------5------");
    /*对两个 List 遍历匹配数据的优化处理*/
    List<Map<Object, Object>> list1 = new ArrayList<>();
    List<Map<Object, Object>> list2 = new ArrayList<>();
    List<Map<Object, Object>> list3 = list1.stream()
                  .map(map -> list2.stream()
                                  .filter(m -> Objects.equals(m.get("id"), map.get("id")))
                                  .findFirst().map(m -> {
                                      map.putAll(m);
                                      return map;
                                  }).orElse(null))
                  .filter(Objects::nonNull).collect(Collectors.toList());



    //count
    long l = stringCollection
    .stream()
    .sorted()
    .filter((a) ->a.startsWith("a"))
    .count();
    System.out.println(l);

    System.out.println("------6------");

//    并行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));
    // 串行耗时: 899 ms

    long t01 = System.nanoTime();
    long count1 = values.parallelStream().sorted().count();
    System.out.println(count1);
    long t11 = System.nanoTime();
    long millis1 = TimeUnit.NANOSECONDS.toMillis(t11 - t01);
    System.out.println(String.format("parallel sort took: %d ms", millis1));
    // 并行排序耗时: 472 ms

    System.out.println("------7------");
    /*Map
    前面提到过，Map类型不支持stream，不过Map提供了一些新的有用的方法来处理一些日常任务。*/
    Map<Integer, String> map = new HashMap<>();
    for (int i = 0; i < 10; i++) {
     map.putIfAbsent(i, "val" + i);
    }
    map.forEach((id, val) ->
    System.out.println(val));



    System.out.println("-------8--------");

    /*新增base64加解密API*/
    final String text = "就是要测试加解密！！abjdkhdkuasu!!@@@@";
           String encoded = Base64.getEncoder()
               .encodeToString( text.getBytes( StandardCharsets.UTF_8 ) );
           System.out.println("加密后="+ encoded );

           final String decoded = new String( 
               Base64.getDecoder().decode( encoded ),
               StandardCharsets.UTF_8 );
           System.out.println( "解密后="+decoded );



    System.out.println("-------9--------");


  }
}