jdk1.8特性2

public class User {
    private Long id;
    private String userName;
    private String roleName;
    private String password;
    private Integer age;
    private Integer gender;
    private String nickName;
    private Double salary;
    private StatsType Type;
     
    /**
     * 
     * @param id
     * @param userName
     * @param roleName
     * @param password
     * @param age
     * @param gender
     * @param nickName
     * @param salary
     * @param Type
     */
    public User(Long id,String userName,String roleName,String password,Integer age,Integer gender,String nickName,Double salary,StatsType Type) {
        this.id = id;
        this.userName = userName;
        this.roleName = roleName;
        this.password = password;
        this.age = age;
        this.gender = gender;
        this.nickName = nickName;
        this.salary = salary;
        this.Type = Type;
    }
 
    /**
     * 分段类型
     */
    public static enum StatsType {
 
        OFFLINE((short) 0), NOTWORK((short) 1), WORKING((short) 2);
 
        private short value;
 
        private StatsType(short value) {
            this.value = value;
        }
 
        public void setValue(short value) {
            this.value = value;
        }
 
        public short getValue() {
            return value;
        }
 
        public static StatsType valueOf(Short value) {
 
            if (value == null) {
                return null;
            }
 
            switch (value) {
            case 0:
                return OFFLINE;// 缺勤
            case 1:
                return NOTWORK;// 闲置
            case 2:
                return WORKING;// 工作
            }
            return null;
        }
    }
 
    get,set.....
 
}

List<User> list2 = Lists.newArrayList(
                new User(1L,"sa","职员","***",18,0,"张三",13242.69,User.StatsType.NOTWORK), 
                new User(2L,"yunying","职员","***",30,1,"李四",12746.36,User.StatsType.WORKING),
                new User(3L,"ta","经理","***",50,0,"王五",15312.98,User.StatsType.OFFLINE)
                );

　　取出对象中某个属性值

private static List<String> getUserName(List<User> list) {
return list.stream().map(User::getUserName).collect(Collectors.toList());
}

　　List<User> 分组(根据性别)

private static Map<Integer, List<User>> getGroupMapByGender(List<User> userList) {
return userList.stream().collect(Collectors.groupingBy(User::getGender));
}

Map<Integer, List<User>> map = getGroupMapByGender(list2);
        for (Integer key : map.keySet()) {
            System.out.println(key + "---" + JSONArray.toJSONString((List<User>) map.get(key)));
        }

　　求两个数组的交集

String str = "a,b,c,d,e";
String str1 = "a,b,c,d,e,f,g";
List<String> list = Arrays.asList(str.split(","));
List<String> list1 = Arrays.asList(str1.split(","));

private static List<String> getMixList(List<String> orgList, List<String> deskList) {
        return orgList.stream().filter(t -> deskList.contains(t)).collect(Collectors.toList());
    }

　　对map的value进行排序

Map<String, Integer> mapData = new HashMap<>();
mapData.put("aa", 20);
mapData.put("bb", 7);
mapData.put("cc", 10);

private static Map<String, Integer> sortOrderByMapValue(Map<String, Integer> map) {
        return map.entrySet().stream().sorted(Map.Entry.<String, Integer> comparingByValue())
                .collect(Collectors.toMap(k -> k.getKey(), v -> v.getValue(), (k, v) -> k, LinkedHashMap::new));
    }

　　List转Map（抽取某一属性做value）

private static Map<String, String> getList2Map(List<User> list) {
return list.stream().collect(Collectors.toMap(User::getUserName, User::getNickName));
}

List转Map（value为对象本身）

private static Map<String, User> getList2Map2(List<User> list) {
        return list.stream()
                .collect(Collectors.toMap(User::getUserName, User -> User, (key1, key2) -> key2, LinkedHashMap::new));
    }

　　数组中某属性最大值

private static Optional<User> getMaxAgeByList(List<User> list) {
        return list.stream().max((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));
    }

分组查询职员数量

Map<String,Long> map5 = list2.stream()
                .collect(Collectors.groupingBy(User::getRoleName,Collectors.counting()));
        System.out.println(map5);

　　数组中返回的第一个元素

private static Optional<User> getFirstValueByList(List<User> list) {
        return list.stream().findFirst();
    }

　　数组中属性是否有某值(是否所有人都没在工作)

private static boolean isHasNoneValueByList(List<User> list) {
        return list.stream().noneMatch((e) -> e.getType().equals(User.StatsType.WORKING));
    }

　　数组中属性是否有某值(是否所有人都在工作)

private static boolean isHasAllValueByList(List<User> list) {
        return list.stream().allMatch((e) -> e.getType().equals(User.StatsType.WORKING));
    }

　　数组中属性是否有某值(是否有人没来)

private static boolean isHasAnyValueByList(List<User> list) {
return list.stream().anyMatch((e) -> e.getType().equals(User.StatsType.OFFLINE));
}

　　数组中某属性最小值

private static Optional<User> getMinAgeByList(List<User> list2) {
        return list2.stream().min((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));
    }
 
System.out.println(user4.get().getAge());