JAVA8 - LIST常用操作

写在前面

在实际的工作中经常会操作LIST对象，现对LIST对象的创建、过滤、排序、去重等等操作进行整理。

准备工作

创建一个User对象

@Data
@AllArgsConstructor
class User {
    private String name;
    private String gender;
    private Integer age;
    private Integer weight;
}

准备好测试数据

List<User> users = Arrays.asList(
                new User("ROCKY", "MALE", 30, 150),
                new User("LUKYZ", "FEMALE", 30, 180),
                new User("TOMEE", "MALE", 28,130),
                new User("DORIS", "FEMALE", 10, 30),
                new User("TIMII", "MALE", 28, 145)
);

创建LIST

// 0. 创建空LIST
List<String> list0 = Collections.EMPTY_LIST;

// 1. 创建并初始化LIST-JAVA5
List<String> list1 = new ArrayList<String>() {{
    add("ROCKY");
    add("MALE");
    add("30");
}};

// 2. 创建并初始化LIST
List<String> list2 = Arrays.asList("ROCKY", "MALE", "30");

// 3. 创建并初始化LIST
List<String> list3_1 = new ArrayList(Arrays.asList("ROCKY", "MALE", "30"));

List<String> list3_2 = new ArrayList<>(Arrays.asList("ROCKY", "MALE", "30"));

// 4. 创建并初始化LIST
List<String> list4 = Arrays.asList(new String[]{"ROCKY", "MALE", "30"});

// 5. 创建并初始化LIST
List<String> list5 = Stream.of("ROCKY", "MALE", "30").collect(Collectors.toList());

// 6. GUAVA创建LIST
List<String> list6 = Lists.newArrayList("ROCKY", "MALE", "30");

// 7. GUAVA创建LIST
List<String> list7 = ImmutableList.of("ROCKY", "MALE", "30");

LIST扁平化

// 8. LIST扁平化
Map<String, List<List<String>>> checkMessage = new ConcurrentHashMap<String, List<List<String>>>() {{
    put("编程语言", Arrays.asList(
            Arrays.asList("RUBY", "88", "第一学期"),
            Arrays.asList("JAVA", "90", "第二学期")

    ));
    put("数据库", Arrays.asList(
            Arrays.asList("MYSQL", "100", "第一学期"),
            Arrays.asList("MONGODB", "60", "第二学期"),
            Arrays.asList("ORACLE", "78", "第三学期")
    ));
    put("设计模式", Arrays.asList(
            Arrays.asList("代理模式", "66", "第一学期"),
            Arrays.asList("策略模式", "100", "第二学期")
    ));
}};
// LIST扁平化
List<List<String>> result = checkMessage.values().stream().flatMap(item -> item.stream()).collect(Collectors.toList());

LIST去重

// 元素处理并去重
List<String> distinct = result.stream().map(r -> r.get(1)).distinct().collect(Collectors.toList());
// 根据性别去重(单个元素)
List<User> unique1 = users.stream().collect(
       Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(User::getGender))), ArrayList::new)
);

// 根据性别和年龄去重(两个元素)
List<User> unique2 = users.stream().collect(
       Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(u -> u.getGender() + ";" + u.getAge()))), ArrayList::new)
        );

LIST分组

// 根据性别进行分组
Map<String, List<User>> group = users.stream().collect(Collectors.groupingBy(User::getGender));

LIST转换

// LIST转MAP(注意: MAP1中的KEY不能重复, 否则Exception in thread "main" java.lang.IllegalStateException: Duplicate key User)
// 当有重复的KEY时保留k1
Map<String, User> map1 = users.stream().collect(Collectors.toMap(User::getName, u -> u, (k1, k2) -> k1));
// 当有重复的KEY时保留k2
Map<String, User> map2 = users.stream().collect(Collectors.toMap(User::getName, u -> u, (k1, k2) -> k2));

// KEY为名称,值为性别, 当有重复的KEY时保留k1
Map<String, String> map3 = users.stream().collect(Collectors.toMap(User::getName, User::getGender, (k1, k2) -> k1));

// LIST转数组
String[] array1 = users.stream().filter(u -> Objects.equals(u.getGender(), "MALE"))
.sorted(Comparator.comparing(User::getName))
.map(User::getName).toArray(String[]::new);

User[] array2 = users.stream().toArray(User[]::new);

LIST过滤

// 过滤
List<String> filtered = distinct.stream().filter(k -> !k.equals(String.valueOf(-1))).collect(Collectors.toList());
// 计算为空的元素个数
long count = Stream.of("A", "", "B").filter(String::isEmpty).count();

LIST查找

boolean b1 = users.stream().filter(m -> m.getGender().equals("MALE")).findAny().isPresent();
boolean b2 = users.stream().anyMatch(m -> m.getGender().equals("MALE"));

LIST求和

// 每个元素平方后求和
int sum1 = Arrays.asList(1, 2, 3, 4, 5, 6, 7).stream().map(x -> x * x).reduce((x, y) -> x + y).get();  // 140

// 求和
int sum2 = Arrays.asList(1, 2, 3, 4, 5, 6, 7).stream().mapToInt(s -> s).sum();  // 28
int sum3 = Arrays.asList(1, 2, 3, 4, 5, 6, 7).stream().reduce(0, (x, y) -> x + y).intValue();  // 28

LIST求平均

// 平均数(转换函数必须返回大于等于LIST的数据类型, 且LIST中的数据其类型必须一致)
double average1 = Arrays.asList(1.6, 2.8, 3.9, 4.0, 5.0, 6.0, 7.33).stream().mapToDouble(Double::valueOf).average().getAsDouble();
double average2 = Arrays.asList(1, 2, 3, 4, 5, 6, 7).stream().mapToDouble(Double::valueOf).average().getAsDouble();
double average3 = Arrays.asList(1.6, 2.8, 3.9, 4.0, 5.0, 6.0, 7.33).stream().collect(Collectors.averagingDouble(x -> x));
double average4 = Arrays.asList(1, 2, 3, 4, 5, 6, 7).stream().collect(Collectors.averagingDouble(x -> x));

LIST交/并/差

List<String> list8 = Arrays.asList("ROCKY", "MALE", "30", "180", "奔驰大G");
List<String> list9 = Arrays.asList("ROCKY", "175", "", "清华大学", "");

// 差(list8 - list9)
List difference = list8.stream().filter(item -> !list9.contains(item)).collect(Collectors.toList());

// 交
List intersection = list8.stream().filter(item -> list9.contains(item)).collect(Collectors.toList());

// 并
List<String> union = list8.parallelStream().collect(Collectors.toList());
List<String> other = list9.parallelStream().collect(Collectors.toList());
union.addAll(other);

// 去掉空值
List<String> list11 = list9.stream().filter(StringUtils::isNotBlank).collect(Collectors.toList());

// 将LIST中的元素用逗号连接
String joining1 = list8.stream().collect(Collectors.joining(",")); // ROCKY,MALE,30,180,奔驰大G
String joining2 = list8.stream().collect(Collectors.joining(",", "(", ")")); // (ROCKY,MALE,30,180,奔驰大G)

LIST截取

// 索引从1开始到3结束(不含3)
List<String> list10 = list8.subList(1, 3); // [MALE, 30]

// 取前两个元素
List<User> limit = users.stream().limit(2).collect(Collectors.toList());

// 从索引为2的元素开始(含索引为2的元素), 取后面的元素
List<User> skip = users.stream().skip(2).collect(Collectors.toList());

LIST排序

// 排序
List<Integer> list12 = Arrays.asList(10, 2, -3, 4, 15, 6, 17);
// 反序
Collections.reverse(list12);            // [17, 6, 15, 4, -3, 2, 10]
// 从小到大
Collections.sort(list12);               // [-3, 2, 4, 6, 10, 15, 17]
// 从大到小
list12.sort(Comparator.reverseOrder()); // [17, 15, 10, 6, 4, 2, -3]

// 按年龄从小到大
List<User> asc = users.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());
// 按年龄从大到小
List<User> desc = users.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());

// 按年龄从小到大体重从大到下排序
List<User> ageAndWeight = users.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getWeight, Comparator.reverseOrder()))
  .collect(Collectors.toList());