【java8新特性之Lambda表达式运用】

public class TestLambda {
    public static void main(String[] args) {
        List<User> userList= new ArrayList<>();
        userList.add(new User(1,"看似心软的神",18));
        userList.add(new User(2,"心软的神",19));
        userList.add(new User(2,"看似心软的神2",20));
        /**
         * 现在我们可以通过Collectors.toMap将list转换成map
         * (k1, k2) -> k1 这个表示当key值相同时取第一个
         */
        Map<Integer, User> map = userList.stream().collect(Collectors.toMap(User::getId, user -> user, (k1, k2) -> k1));
        for (User user : map.values()) {
            System.out.println(user);
        }
    }
}

public class TestLambda {
    public static void main(String[] args) {
        List<User> userList= new ArrayList<>();
        userList.add(new User(1,"看似心软的神",18));
        userList.add(new User(2,"心软的神",19));
        userList.add(new User(2,"看似心软的神2",20));
        /**
         * 现在我们可以通过filter()将list集合中不符合条件的元素过滤掉
         * 过滤掉id小于等于1的数据
         */
        List<User> list = userList.stream().filter(v -> v.getId() > 1).collect(Collectors.toList());
        list.forEach(v-> System.out.println(v));
    }
}

public class TestLambda {
    public static void main(String[] args) {
        List<User> userList= new ArrayList<>();
        userList.add(new User(1,"看似心软的神",18));
        userList.add(new User(2,"心软的神",19));
        userList.add(new User(2,"看似心软的神2",20));
        /**
         * 现在我们可以通过Collectors.groupingBy将list集合中的元素进行分组
         * 现在我们通过id进行分组
         */
        Map<Integer, List<User>> map = userList.stream().collect(Collectors.groupingBy(User::getId));
        for (List<User> value : map.values()) {
            System.out.println(value);
        }
    }
}

public class TestLambda {
    public static void main(String[] args) {
        List<User> userList= new ArrayList<>();
        userList.add(new User(1,"看似心软的神",18));
        userList.add(new User(2,"心软的神",19));
        userList.add(new User(2,"看似心软的神2",20));
        /**
         * 现在我们可以通过Comparator将list集合中的元素进行自定义规则排序
         * 现在我们通过年龄进行排序
         */
        System.out.println("*****************正叙排列****************************");
        List<User> list = userList.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());
       list.forEach(v-> System.out.println(v));
        /**
         * 我们通过年龄进行倒叙排列，倒叙需要加上reversed
         */
        System.out.println("*****************倒叙排列****************************");
        List<User> list1 = userList.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());
        list1.forEach(v-> System.out.println(v));
    }
}

public class TestLambda {
    public static void main(String[] args) {
        List<User> userList= new ArrayList<>();
        userList.add(new User(1,"看似心软的神",18));
        userList.add(new User(2,"心软的神",19));
        userList.add(new User(2,"看似心软的神2",20));
        /**
         * 现在我们可以通过Count将list集合中的元素进行统计
         * 现在我们统计年龄大于18岁的数量,这里返回的是一个long类型
         */
        long count = userList.stream().filter(v -> v.getAge() > 18).count();
        System.out.println(count);
    }
}

public class TestLambda {
    public static void main(String[] args) {
        List<User> userList= new ArrayList<>();
        userList.add(new User(1,"看似心软的神",18));
        userList.add(new User(2,"心软的神",19));
        userList.add(new User(2,"看似心软的神",20));
        /**
         * 现在我们可以获取list集合中的指定列的数据
         *
         */
        System.out.println("*****去重之前的数据*****");
        List<String> collect = userList.stream().map(v -> v.getName()).collect(Collectors.toList());
        collect.forEach(v-> System.out.println(v));
        /**
         * 现在我们可以获取list集合中的指定列的数据使用distinct去重
         *
         */
        System.out.println("******去重之后的数据******");
        List<String> collect2 = userList.stream().map(v -> v.getName()).distinct().collect(Collectors.toList());
        collect2.forEach(v-> System.out.println(v));
    }
}