JDK1.8新特性

发表于 | 分类于 |
字数统计: 553 | 阅读时长 ≈ 2

[TOC]

Lambda表达式

lambda表达式允许你通过表达式来代替功能接口。

1
(parameters) -> expression 或 (parameters) ->{ statements; }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//匿名内部类
Comparator<Integer> cpt = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return Integer.compare(o1,o2);
    }
};

TreeSet<Integer> set = new TreeSet<>(cpt);

System.out.println("=========================");

//使用lambda表达式
Comparator<Integer> cpt2 = (x,y) -> Integer.compare(x,y);
TreeSet<Integer> set2 = new TreeSet<>(cpt2);

Stream API

Stream操作的三个步骤

  • 创建stream

  • 中间操作（过滤、map）

  • 终止操作

    stream的创建：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 1，校验通过Collection 系列集合提供的stream()或者paralleStream()
List<String> list = new ArrayList<>();
Strean<String> stream1 = list.stream();

// 2.通过Arrays的静态方法stream()获取数组流
String[] str = new String[10];
Stream<String> stream2 = Arrays.stream(str);

// 3.通过Stream类中的静态方法of
Stream<String> stream3 = Stream.of("aa","bb","cc");

// 4.创建无限流
// 迭代
Stream<Integer> stream4 = Stream.iterate(0,(x) -> x+2);

//生成
Stream.generate(() ->Math.random());

Stream的中间操作:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/**
   * 筛选 过滤  去重
   */
  emps.stream()
          .filter(e -> e.getAge() > 10)
          .limit(4)
          .skip(4)
          // 需要流中的元素重写hashCode和equals方法
          .distinct()
          .forEach(System.out::println);


  /**
   *  生成新的流 通过map映射
   */
  emps.stream()
          .map((e) -> e.getAge())
          .forEach(System.out::println);


  /**
   *  自然排序  定制排序
   */
  emps.stream()
          .sorted((e1 ,e2) -> {
              if (e1.getAge().equals(e2.getAge())){
                  return e1.getName().compareTo(e2.getName());
              } else{
                  return e1.getAge().compareTo(e2.getAge());
              }
          })
          .forEach(System.out::println);

Stream的终止操作：

reduce:

1
2
3
4
5
6
7
8
9
10
11
12
 /**
 *  reduce ：规约操作
 */
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
Integer count2 = list.stream()
        .reduce(0, (x, y) -> x + y);
System.out.println(count2);

Optional<Double> sum = emps.stream()
        .map(Employee::getSalary)
        .reduce(Double::sum);
System.out.println(sum);

collect操作：Collect-将流转换为其他形式，接收一个Collection接口的实现，用于给Stream中元素做汇总的方法

1
2
3
4
5
6
7
8
/**
 *  collect：收集操作
 */

List<Integer> ageList = emps.stream()
        .map(Employee::getAge)
        .collect(Collectors.toList());
ageList.stream().forEach(System.out::println);

接口中可以定义默认实现方法和静态方法

1
2
3
4
5
6
7
8
9
public interface Interface {
    default  String getName(){
        return "zhangsan";
    }

    static String getName2(){
        return "zhangsan";
    }
}