Java8 新特征

一、操作集合

定义实体类
public class User{
  private Integer id;
  private String name;
  CONSTRUCTOR; -> 省略构造方法
  GETTER AND SETTER; -> 省略属性的方法

  @Override
  public boolean equals(Object obj) { -> distinct()
      if (obj instanceof User) {
          return this.getId().equals(((User) obj).getId());
      }
      return false;
  }

  @Override
  public int hashCode() { -> distinct()
      return this.getId();
  }
}

定义对象集合
List list = new ArrayList<>();
User w = new User(1,"w");
User j = new User(2,"j");
User x = new User(3,"x");
list.add(w);
list.add(j);
list.add(x);

集合对象通过ID属性分组
Map> map = list.stream()
.collect(Collectors.groupingBy(User::getId));

集合通过自定义条件分组
Map> map = list.stream()
.map(User::getName)
.collect(partitioningBy(s -> s.length() > 1));

集合对象通过ID属性排序
list.stream().sorted(Comparator.comparing(User::getId));
list.stream().sorted(); -> 自然排序
list.stream().sorted(Comparator.reverseOrder()); -> 自然逆向排序

集合对象通过ID属性过滤
List filter = list.stream() -> 保留符合条件的元素
.filter(user -> user.getId().equals(1)).collect(Collectors.toList());

集合过滤重复对象
list = list.stream().distinct().collect(Collectors.toList());

取出集合前i个对象
list = list.stream().limit(i).collect(Collectors.toList());

忽略集合前i个对象
list = list.stream().skip(i).collect(Collectors.toList());

集合对象的ID属性求和
BigDecimal decimal = list.stream()
.map(User::getId)
.reduce(BigDecimal.ZERO, BigDecimal::add);

集合的属性拼接
String join = list.stream()
.map(User::getName)
.collect(Collectors.joining("-","start","end"));

操作集合对象的属性
list = list.stream().peek(l -> l.setId(l.getId()*i))
.collect(Collectors.toList());

集合对象通过ID属性排重
List unique = list.stream()
.collect(collectingAndThen(
toCollection(() -> new TreeSet<>(
comparingLong(User::getId))),ArrayList::new));

获取集合对象里的ID属性的集合
List ids = list.stream()
.map(User::getId) -> ID的GETTER方法
.collect(Collectors.toList());

MAP集合
Map map = list.stream()
.collect(Collectors.toMap(User::getId, a -> a,(k1,k2)->k1));

Set集合(List有序允许重复值,Set无序不允许重复值)
Stream name = Stream.of("w","j","x");
Set set = name.collect(Collectors.toSet());

[]数组
User[] array = list.stream().toArray(User[]::new);
User[] array = list.toArray();

集合长度
long count = list.stream().count();
long count = list.stream().collect(Collectors.counting());

元素匹配
boolean b = list.stream().anyMatch(user -> user.getId().equals(1)); -> 任意成立
boolean b = list.stream().allMatch(user -> user.getId().equals(1)); -> 全部成立
boolean b = list.stream().noneMatch(user -> user.getId().equals(1)); -> 全部不成立

流的扁平化
String[] array = {"flat","map"};
List list = Arrays.stream(array).map(str -> str.split(""))
.flatMap(Arrays::stream).collect(Collectors.toList());
List list = Stream.of(array).flatMap(str -> 
Arrays.stream(str.split(""))).collect(Collectors.toList());

自定义集合类型
List collection = list.stream()
.map(User::getName) 
.collect(Collectors.toCollection(ArrayList::new));

串行流和并行流
list.stream().foreach(System.out::println); -> 串行流有序
list.parallelStream().foreachOrdered(System.out::println); -> 并行流无序

IntSummaryStatistics statistics = list.stream()
.collect(Collectors.summarizingInt(User::getId));
statistics.getMax(); -> 最大值
statistics.getMin(); -> 最小值
statistics.getAverage(); -> 平均值
statistics.getSum(); -> 总值

Integer[] number = {1,2,3,4,5,6,7,8,9};
Arrays.stream(number).collect(Collectors.averagingInt(Integer::new)); -> 平均值
Arrays.stream(number).collect(Collectors.summingInt(Integer::new)); -> 总值
Arrays.stream(number).mapToInt(Integer::new).sum()); -> 总值
Optional max = Arrays.stream(number).collect(Collectors.maxBy(Integer::max));
Optional min = Arrays.stream(number).collect(Collectors.minBy(Integer::min));
Optional max = Arrays.stream(number).max(Comparator.comparing(Function.identity()));
Optional min = Arrays.stream(number).min(Comparator.naturalOrder());

二、循环迭代

List list = Arrays.asList("w","j","x");

普通版
for(int i=0;i iterator = list.iterator();
while (iterator.hasNext()){
  System.out.println(iterator.next());
}

Java8
list.forEach(new Consumer() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
});

Lambda表达式
list.forEach(str -> System.out.println(str));

Map map = new HashMap<>();
map.put("name","wjx");
map.put("age","20");

普通版
for (Map.Entry entry:map.entrySet()){
  String key =  entry.getKey();
  String value = entry.getValue();
}

key版
for (String key:map.keySet()){
    String value = map.get(key);
}

value版
for (String value:map.values()){
    System.out.println(value);
}

迭代器
Iterator> iterator = map.entrySet().iterator();
while (iterator.hasNext()){
  Map.Entry entry = iterator.next();
  String key =  entry.getKey();
  String value = entry.getValue();
}

Java8
map.forEach(new BiConsumer() {
  @Override
  public void accept(String key, String value) {
    System.out.println(key);
    System.out.println(value);
  }
});

Lambda表达式
map.forEach((k,v) -> System.out.println(k+v);

三、函数式接口

• 只包含一个抽象方法，可以包含多个静态方法和默认方法，可以定义Java.Lang.Object类的所有方法
• @FunctionalInterface，声明在函数式接口上，如果接口上存在多个抽象方法则会编译报错，但函数式接口不一定用此注解
• JDK8前的接口方法修饰符为abstract，必须由实现类重写方法。JDK8新引入default和static修饰符，支持方法体，实现类可以不重写方法。接口方法默认修饰符为public，方法同样不能被private和protected修饰符修饰。

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

new Thread(new Runnable() { -> 传统写法
    @Override
    public void run() {
      System.out.println("Thread is started");
    }
}).start();

new Thread(()->{ -> Lambda写法
  System.out.println("Thread is started");
}).start();

• default 修饰接口方法

default void method(){ -> 可继承,通过类对象调用方法
    System.out.println("default method");
}

• static 修饰接口方法

static void method(){ -> 不可继承,通过类名调用方法
    System.out.println("static method");
}

四、时间日期

LocalDateTime localDateTime = LocalDateTime.now(); -> 日期时间
LocalDate localDate = LocalDate.now(); -> 日期
LocalTime localTime = LocalTime.now(); -> 时间

localDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")); -> 格式化

.with*：替代
例:localDateTime.withDayOfYear(1); -> 当前日期替换为一年的第一天(一月一日)
.plus*：加法
例:localDateTime.plusDays(1); -> 当前日期加一日(明天)
.minus*：减法
例:localDateTime.minusDays(1); -> 当前日期减一日(昨天)