java8到java17的主要新增语法特性

一、Predicate谓词(java8)

test():

        Predicate<String> isUserNameValid = u -> u != null && u.length() > 5 && u.length() < 10;
        boolean bo = isUserNameValid.test("Mahesh");
        System.out.println(bo);//true
1
2
3

and():

        Predicate<String> isUserNameValid = u -> u != null && u.length() > 5 && u.length() < 10;
        Predicate<String> isStartU = u -> u.startsWith("M");
        boolean bo = isUserNameValid.and(isStartU).test("Mahesh");
        System.out.println(bo);//true
1
2
3
4

or():

        Predicate<String> isUserNameValid = u -> u != null && u.length() > 5 && u.length() < 10;
        Predicate<String> isStartU = u -> u.startsWith("K");
        boolean bo = isUserNameValid.or(isStartU).test("Mahesh");
        System.out.println(bo);//true
1
2
3
4

negate():

		Predicate<Integer> isGreaterThan20 = n -> n > 20;
		//negate取反操作
        boolean bo = isGreaterThan20.negate().test(30);
        System.out.println(bo);//false
1
2
3
4

stream中使用谓词：

        List<Integer> nums = Arrays.asList(2, 3, 1, 5, 6, 7, 8, 9, 12);
        Predicate<Integer> btf = n -> n > 5 && n % 2 == 0;
        //输出6,8,10
        nums.stream().filter(btf).forEach(System.out::println);
1
2
3
4

二、of创建不可变集合(java9)

不可变集合： 即初始化后里面的数据就固定了，不能再使用add、remove往里面再添加值和删除值

普通的创建不可变集合：

        // 不可变的List
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list = Collections.unmodifiableList(list);
		
		 // 不可变的Set
        Set<String> set = new HashSet<>();
        set.add("aaa");
        set.add("bcc");
        set = Collections.unmodifiableSet(set);
1
2
3
4
5
6
7
8
9
10
11
12

java8中可以使用stream简化创建不可变集合：

		List<String> list = Collections.unmodifiableList(Stream.of("aaa", "bbb", "ccc").collect(toList()));
		Set<String> set = Collections.unmodifiableSet(Stream.of("111", "222", "333").collect(toSet()));
1
2

java9开始可以使用of更简单的创建不可变集合：

		List<String> list = List.of("aaa", "bbb", "ccc");
        Set<String> set = Set.of("111", "222", "333");
        Map<String,String> map = Map.of("key1", "value1", "key2","value2");
1
2
3

List.of与Arrays.asList的区别：

• 两者都不允许使用add、remove往里面再添加值和删除值。但是使用Arrays.asList创建的不可变集合可以使用set修改值，而使用List.of创建的不可以
• Arrays.asList中可以有null值，List.of中不允许有null值

注意：
通过原集合转变为不可变集合时，如果原集合改变，不可变集合里的数据也会改变

		List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        // newList是不可变的,不可以增删改
        List<Integer> newList = Collections.unmodifiableList(list);
        
        list.add(4);
        System.out.println(list);//[1, 2, 3, 4]
        System.out.println(newList);//[1, 2, 3, 4]
1
2
3
4
5
6
7
8
9
10
11

三、copyOf复制为一个不可变集合(java10)

java10开始的java.util.List、java.util.Map 、java.util.Set 新加了copyOf方法用于复制集合返回一个不可变集合

		List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
		
		//copyList是不可变的，不能对copyList进行add、remove操作
        List<String> copyList = List.copyOf(list);
1
2
3
4
5
6

通过copyOf拷贝为一个不可变集合时，如果原集合改变，不会影响不可变集合里的数据

		 List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");

        //copyList是不可变的，不能对copyList进行add、remove操作
        List<String> copyList = List.copyOf(list);

        list.add("ccc");
        System.out.println(list);//[aaa, bbb, ccc]
        System.out.println(copyList);//[aaa, bbb]
1
2
3
4
5
6
7
8
9
10

四、Stream中的toUnmodifiable产生不可变集合(java10)

java.util.stream.Collectors 新增了toUnmodifiable方法来将Stream 收集到的数据产生一个不可修改的List、Map 或Set集合：

        List<Integer> list = Arrays.asList(1,2,3,4,5,6);
		//evenList是不可变的，不能对copyList进行add、remove操作
        List<Integer> evenList = list.stream()
                .filter(i -> i % 2 == 0)
                .collect(Collectors.toUnmodifiableList());
1
2
3
4
5

五、var局部变量类型声明(java10)

java10开始新增了var关键字，用于局部变量的声明(即类变量不能使用var)，它会根据周围的上下文自动检测变量的数据类型。

    public static void main(String[] args) throws Exception {
        // int
        var x = 100;
        // double
        var y = 1.90;
        // char
        var z = 'a';
        // string
        var p = "tanu";
        // boolean
        var q = false;

        System.out.println(x);//100
        System.out.println(y);//1.9
        System.out.println(z);//a
        System.out.println(p);//tanu
        System.out.println(q);//false
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

以下几种情况不能使用var:
1.var 不能在实例和类全局变量声明中使用。
2.var 不能与泛型类型一起使用,如：

var<Integer> al = new ArrayList<Integer>();
1

3.var 不能在没有显式初始化的情况下使用。如：

var variable;  var variable = null;
1

4.var 不能与 Lambda 表达式一起使用。如：

var obj = (a, b) -> (a + b);
1

5.var 不能用于方法参数和返回类型。

六、switch表达式优化(java12)

旧语法：

        DayOfWeek dayOfWeek = LocalDate.now().getDayOfWeek();
        String typeOfDay = "";
        switch (dayOfWeek) {
            case MONDAY:
            case TUESDAY:
            case WEDNESDAY:
            case THURSDAY:
            case FRIDAY:
                typeOfDay = "Working Day";
                break;
            case SATURDAY:
            case SUNDAY:
                typeOfDay = "Day Off";
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

java12开始的新语法优化：
新的 switch 语句不仅更加紧凑和可读。还消除了对 break 语句的需要，更复杂的逻辑箭头后应该用花括号括起来。

        DayOfWeek dayOfWeek = LocalDate.now().getDayOfWeek();
        String typeOfDay = switch (dayOfWeek) {
            case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "Working Day";
            case SATURDAY, SUNDAY -> "Day Off";
        };
1
2
3
4
5

七、instanceof模式匹配(java12)

旧语法：

        Object obj = "Hello World!";
        if (obj instanceof String) {
            String s = (String) obj;
            int length = s.length();
        }
1
2
3
4
5

Java12开始，可以直接在语句中声明新的类型转换变量：

        if (obj instanceof String s) {
            int length = s.length();
        }
1
2
3

八、文本块(java13)

以前的代码，json字符串需要对双引号、tab缩进、换行进行转义：

        String JSON_STRING = "{\r\n" + "\"name\" : \"Baeldung\",\r\n" + "\"website\" : \"https://www.%s.com/\"\r\n" + "}";
1

java13开始时刻使用文本块，不需要转义双引号、tab缩进、换行，结构更加清晰：

               String TEXT_BLOCK_JSON = """
                {
                    "name" : "Baeldung",
                    "website" : "https://www.%s.com/"
                }
                """;
1
2
3
4
5
6

java14文本块中新增了\ ，\放在行尾表示不换行；新增\s表示单个空格

        String multiline = """
                A quick brown fox jumps over a lazy dog; \
                the lazy dog howls loudly.\shello!""";
		//输出：A quick brown fox jumps over a lazy dog; the lazy dog howls loudly. hello!
        System.out.println(multiline);
1
2
3
4
5

九、record减少模板代码(java14)

假设代码里要用到一个user类，里面含有id和neme字段。
以前我们会新建User类：

public class User {
    int id;
    String name;

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}
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
33

调用：

        User user = new User(1, "tom");
        int i = user.getId();
1
2

java14开始增加了record ，简单的声明会自动为我们添加构造函数、getter、equals、hashCode和toString方法：

public class MainServer {
    public static void main(String[] args) throws Exception {
        User user = new User(1, "tom");
        int id = user.id();
        String name = user.name();
	}

    public static  record User(int id, String name) { };
}
1
2
3
4
5
6
7
8
9

十、Stream新增toList(java16)

以前的代码：

List<String> list = Arrays.asList("1", "2", "3");
List<Integer> ints = list.stream().map(Integer::parseInt).collect(Collectors.toList());
1
2

使用toList更简洁

List<String> list = Arrays.asList("1", "2", "3");
List<Integer> ints = list.stream().map(Integer::parseInt).toList();
1
2