jdk8流试语法

Table of Contents

前置

前置

创建实体类及初始化集合

static class User {
    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
        // 忽略 get、set、toString、constructor
    }
    
private static List<User> initList() {
    return Arrays.asList(new User("lisa", 23), new User("mack", 19),
            new User("jennis", 26), new User("tin", 26),
            new User("tom", 11), new User("army", 26),
            new User("jobs", 65), new User("john", 16));
}

集合筛选

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
System.out.println("筛选列表: " + filtered);

结果：
    筛选列表: [abc, bc, efg, abcd, jkl]

System.out.println("\n====================过滤年龄小于11的数据===================");
users = initList();
List<User> userList = users.stream().filter(o -> o.getAge() > 11).collect(Collectors.toList());
userList.forEach(System.out::println);
结果：
    ====================过滤年龄小于11的数据===================
    User{name='lisa', age=23}
    User{name='john', age=16}

集合字段非空过滤及字符串拼接

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(","));
System.out.println("合并字符串: " + mergedString);

结果：
    合并字符串: abc,bc,efg,abcd,jkl

集合中数组长度是否一致

List<Double[]> a = Arrays.asList(new Double[]{2D, 2D}, new Double[]{1D, 2D});
long count = a.stream().map(num -> num.length).distinct().count();
System.out.println("判断集合中数组长度是否一致: " + (count == 1 ? true : false));

结果：
    判断集合中数组长度是否一致: true

排序

List<Integer> integer = Arrays.asList(1, 2, 3, 4, 6, 5);
integer.sort(Comparator.reverseOrder());
System.out.println("基本类型倒序：" + integer);
结果：
    基本类型倒序：[6, 5, 4, 3, 2, 1]


integer = Arrays.asList(1, 2, 3, 4, 6, 5);
Collections.sort(integer);
System.out.println("基本类型正序：" + integer);
结果：
    基本类型倒序：[6, 5, 4, 3, 2, 1]


System.out.println("\n====================根据集合中数组第一个值升序===================");
List<Double[]> collect = a.stream().sorted((x, y) -> x[0] > y[0] ? 1 : -1).collect(Collectors.toList());
collect.forEach(o -> System.out.println(Arrays.toString(o)));
结果：
    ====================根据集合中数组第一个值升序===================
    [1.0, 2.0]
    [2.0, 2.0]


System.out.println("\n====================对象集合升序===================");
List<User> users = initList();
Collections.sort(users, Comparator.comparing(User::getAge));
users.forEach(System.out::println);
结果：
    ====================对象集合升序===================
    User{name='tom', age=11}
    User{name='john', age=16}
    User{name='mack', age=19}
    User{name='lisa', age=23}
    User{name='jennis', age=26}
    User{name='tin', age=26}
    User{name='army', age=26}
    User{name='jobs', age=65}


System.out.println("\n====================对象集合降序===================");
users = initList();
users.sort(Comparator.comparing(User::getAge).reversed());
users.forEach(System.out::println);
结果：
    ====================对象集合降序===================
    User{name='jobs', age=65}
    User{name='jennis', age=26}
    User{name='tin', age=26}
    User{name='army', age=26}
    User{name='lisa', age=23}
    User{name='mack', age=19}
    User{name='john', age=16}
    User{name='tom', age=11}


System.out.println("\n====================自定义对象集合排序===================");
users = initList();
users.sort((o1, o2) -> o1.getAge() > o2.getAge() ? 1 : -1);
users.forEach(System.out::println);
结果：
    ====================自定义对象集合排序===================
    User{name='tom', age=11}
    User{name='john', age=16}
    User{name='mack', age=19}
    User{name='lisa', age=23}
    User{name='army', age=26}
    User{name='tin', age=26}
    User{name='jennis', age=26}
    User{name='jobs', age=65}


System.out.println("\n====================jdk8 组合排序，Comparator提供的静态方法，先按年纪排序，年纪相同的按名称排序===================");
users = initList();
Collections.sort(users, Comparator.comparing(User::getAge).thenComparing(User::getName));
users.forEach(System.out::println);
结果:
    ====================jdk8 组合排序，Comparator提供的静态方法，先按年纪排序，年纪相同的按名称排序===================
    User{name='tom', age=11}
    User{name='john', age=16}
    User{name='mack', age=19}
    User{name='lisa', age=23}
    User{name='army', age=26}
    User{name='jennis', age=26}
    User{name='tin', age=26}
    User{name='jobs', age=65}

前置

相关文章