Java-新特性

[toc]

一、函数式接口

函数式接口：只有一个抽象方法的接口，可以使用@FunctionalInterface注解修饰。

1.1、Predicate 判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static void main(String[] args) {
	// 数据源
    List<Integer> list1 = Arrays.asList(3,5,1,8,4,4);

    // 判断的规则
    Predicate<Integer> con = new Predicate<Integer>() {
        @Override
        public boolean test(Integer integer) {
            // 元素值大于5时，符合规则
            return integer > 5;
        }
    };

    // 判断每个元素是否符合大于5的规则
    List<Integer> resList = list1.stream()
        .filter(con::test)
        .collect(Collectors.toList());

    // [8]
    System.out.println(resList);

}

1.2、Supplier 获取

1
2
3
4
5
6
7
public static void main(String[] args){
    
		Supplier<Random> s1 = Random::new;
        Random random = s1.get();
        System.out.println(random.nextInt(10));
    
}

二、Lambda 表达式

Lambda 表达式 一般用于函数式接口，可以简化匿名内部类的使用。

（1）定义一个函数式接口：

1
2
3
4
@FunctionalInterface
public interface Op(){
    int op(int a,int b);
}

（2）使用 Lambda 表达式 重写 函数式接口中的抽象方法：

1
2
3
4
5
6
public static void main(String[] args){
    
        Op addition = (int a,int b) -> a+b;
        int c = addition.op(1,2); 
    
}

三、方法引用

方法引用通过方法的名字来指向一个方法。

方法引用使用一对冒号 ::。

调用：

  • 调用静态方法：类名::方法名

  • 调用成员方法：对象名::方法名

  • 调用构造函数：类型::new

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String args[]){
    
    List<String> names = new ArrayList();

    names.add("Google");
    names.add("Runoob");
    names.add("Taobao");
    names.add("Baidu");
    names.add("Sina");

    // 使用方法的引用
    names.forEach(System.out::println);
}

四、流式编程

Collection集合类可以通过调用stream()得到数据流。

3.1、打印

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args){ 
    
    // 注意：Arrays.asList() 得到的是一个不可变的列表
	List<Integer> list1 = Arrays.asList(3,5,1,8,4,4);
    
    
    // 打印集合内的每个元素
    list1.stream()
         .forEach(item->System.out.println(item));
    
    // 打印集合内的每个元素
    list1.stream()
         .forEach(System.out::println);   
    
}

3.2、过滤

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args){ 
    
    // 注意：Arrays.asList() 得到的是一个不可变的列表
	List<Integer> list1 = Arrays.asList(3,5,1,8,4,4);
    
    // 过滤出大于等于4的数，组成集合
    List<Integer> resList = list1.stream()
        .filter(item -> item >= 4)
        .collect(Collectors.toList());
    
    // [5,8,4,4]
    System.out.println(resList);
    
}

3.3、处理

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String[] args){ 
    
    // 注意：Arrays.asList() 得到的是一个不可变的列表
	List<Integer> list1 = Arrays.asList(3,5,1,8,4,4);
    
    // 将每个元素扩大1倍
    List<Integer> resList = list1.stream()
        .map(item -> item * 2)
        .collect(Collectors.toList());
    
    // [6, 10, 2, 16, 8, 8]
    System.out.println(resList);
}

3.4、判断

判断是否全部元素符合指定的条件：

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String[] args){ 
    
    // 注意：Arrays.asList() 得到的是一个不可变的列表
	List<Integer> list1 = Arrays.asList(3,5,1,8,4,4);
    
    // 判断集合中的元素是否全部大于等于1
    boolean b = list1.stream()
        .allMatch(item -> item >= 1);

    // true
    System.out.println(b);
    
}

判断是否有一个元素符合指定的条件：

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String[] args){ 
    
    // 注意：Arrays.asList() 得到的是一个不可变的列表
	List<Integer> list1 = Arrays.asList(3,5,1,8,4,4);
    
    // 判断集合中的元素是否有一个元素大于等于1
    boolean b = list1.stream()
        .anyMatch(item -> item >= 1);

    // true
    System.out.println(b);
    
}

判断是否没有元素符合指定的条件：

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String[] args){ 
    
    // 注意：Arrays.asList() 得到的是一个不可变的列表
	List<Integer> list1 = Arrays.asList(3,5,1,8,4,4);
    
    // 判断集合中的元素是否没有元素大于20
    boolean b = list1.stream()
        .noneMatch(item -> item > 20);

    // true
    System.out.println(b);
    
}

3.5、去重

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args){ 
    
    // 注意：Arrays.asList() 得到的是一个不可变的列表
	List<Integer> list1 = Arrays.asList(3,5,1,8,4,4);
    
    // 去重
    List<Integer> resList = list1.stream()
        .distinct()
        .collect(Collectors.toList());

    // [3, 5, 1, 8, 4]
    System.out.println(resList);
    
}

3.6、查找

查找第一个元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args){ 
    
    // 注意：Arrays.asList() 得到的是一个不可变的列表
	List<Integer> list1 = Arrays.asList(3,5,1,8,4,4);
    
	// 查找第一个元素
    List<Integer> resList = list1.stream()
        .findFirst()
        .stream()
        .toList();
    
	// [3]
    System.out.println(resList);
    
}

3.7、获取指定数量的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args){ 
    
    // 注意：Arrays.asList() 得到的是一个不可变的列表
	List<Integer> list1 = Arrays.asList(3,5,1,8,4,4);
    
    // 获取3个元素
    List<Integer> resList = list1.stream()
        .limit(3)
        .collect(Collectors.toList());

    // [3, 5, 1]
    System.out.println(resList);
    
}

3.8、排序

sorted()方法的参数是一个compator接口，可以用 lambda 表达式简化compator接口中的比较规则的实现。

升序（默认）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args){ 
    
    // 注意：Arrays.asList() 得到的是一个不可变的列表
	List<Integer> list1 = Arrays.asList(3,5,1,8,4,4);
    
    // 升序，
    List<Integer> resList = list1.stream()
        .sorted()
        .collect(Collectors.toList());

    // [1, 3, 4, 4, 5, 8]
    System.out.println(resList);
    
}

降序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args){ 
    
    // 注意：Arrays.asList() 得到的是一个不可变的列表
	List<Integer> list1 = Arrays.asList(3,5,1,8,4,4);
    
    // 降序，sorted()的参数是对`compator`接口compare方法的重写（比较规则）
    // a-b：升序，b-a:降序
    List<Integer> resList = list1.stream()
        .sorted((a,b)-> b-a)
        .collect(Collectors.toList());

    System.out.println(resList);
    
}