ListUtils技巧大全：提升你的Java列表操作效率-51CTO.COM

本文将介绍Apache Commons Collection库中的ListUtils类。这个类为Java中的List接口提供了实用功能和装饰方法。

引入依赖包

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-collections4</artifactId>
   <version>4.4</version>
 </dependency>1.
2.
3.
4.
5.

我们现在创建一个简单的用户对象，使用这个对象来测试ListUtils类的功能性。如下所示：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserObject {
    private String userName;
    private Integer userId;
    private Double userSalary;
}1.
2.
3.
4.
5.
6.
7.
8.

接下来创建一个叫做 defaultUserList的列表：

List<UserObject> defaultUserList = Arrays.asList(
   new UserObject("User1", 1, 10000.0),
   new UserObject("User2", 2, 20000.0),
   new UserObject("User3", 3, 30000.0),
   new UserObject("User4", 4, 40000.0),
   new UserObject("User5", 5, 50000.0));1.
2.
3.
4.
5.
6.

ListUtils核心功能

1）DefaultIfNull

它接收两个参数：一个默认列表和一个用户列表。如果现有的用户列表为空，该方法将返回默认列表。当通过List实例处理引用数据时，这很有用。它可以防止发生空指针异常。

List<UserObject> nullList = null;
assertEquals(defaultUserList,ListUtils.defaultIfNull(defaultUserList, nullList));1.
2.

2）EmptyIfNull

它接收一个用户列表作为输入参数，如果用户列表为空，则返回一个空列表，避免发生空指针异常。

List<UserObject> nullList = null;
assertTrue(ListUtils.emptyIfNull(nullList).isEmpty());1.
2.

3）FixedSizeList

这个方法是输出一个固定大小的列表，不能添加或删除元素，但可以编辑列表的元素。

如下面的代码所示，如果我们尝试从固定列表中添加还是删除元素，都会抛出UnsupportedOperationException。

List < UserObject > fixedList = ListUtils.fixedSizeList(defaultUserList);

 assertEquals(Double.valueOf(10000), fixedList.get(0).getUserSalary());

 Exception exception = assertThrows(UnsupportedOperationException.class,
         () -> {
                 fixedList.add(new UserObject("User6", 6, 60000.0));
         });
 assertEquals("List is fixed size", exception.getMessage());

 assertThrows(UnsupportedOperationException.class, () -> {
         fixedList.remove(0);
 });1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

4）PredicatedList

当我们希望将谓词作为对用户列表的检查时，这个方法非常有用，可以使用两种方式。

方法1：创建一个包含用户数据的列表，然后使用谓词进行验证。如果存在元素未通过谓词条件，则抛出错误。

例如：ListUtils.predicatedList检查输入列表的所有元素的salary参数是否大于20000.0；如果不是，它将抛出IllegalArgumentException。

assertThrows(IllegalArgumentException.class, () -> {
   ListUtils.predicatedList(defaultUserList,
     userObj -> userObj.getUserSalary() > 20000.0);
  });1.
2.
3.
4.

方法2：在数据插入列表时执行验证。通过输入一个空列表和一个谓词条件，可以获取一个预测列表。当我们尝试添加一个新的数据条目时，它会与谓词进行验证，如果条件不满足，就会抛出异常。

List<UserObject> predicatedUserList = ListUtils.predicatedList(
    new ArrayList<UserObject>(),
    userObj -> userObj.getUserSalary() > 20000.0);

  assertThrows(IllegalArgumentException.class, () -> {
   predicatedUserList.add(new UserObject("User", 2, 10000.0));
  });1.
2.
3.
4.
5.
6.
7.

5）Partition

该方法通过指定子列表的大小将用户列表划分为子列表。如下所示：

List<List<UserObject>> partitionedList = ListUtils
    .partition(defaultUserList, 2);
  assertEquals(3, partitionedList.size());1.
2.
3.

6）Index Of

该方法接受用户列表和谓词作为输入。然后找到第一个满足谓词条件的元素并返回其下标。

int indexOfObject = ListUtils.indexOf(defaultUserList,
    userObj -> userObj.getUserSalary().equals(20000.0));
  assertEquals(1, indexOfObject);1.
2.
3.

7）Select

它与Java 8流过滤器的工作方式相同，接收用户列表和谓词作为输入，并返回满足谓词条件的参数列表。

// Java 8 Stream示例
 List<UserObject> java8List = defaultUserList
    .stream()
    .filter(userObj -> userObj.getUserSalary() > 20000.0)
    .collect(Collectors.toList());
  assertEquals(3, java8List.size());1.
2.
3.
4.
5.
6.

// ListUtils.select方法使用示例
 List<UserObject> predicatedList = ListUtils.select(defaultUserList,
    userObj -> userObj.getUserSalary() > 20000.0);
  assertEquals(3, predicatedList.size());1.
2.
3.
4.

8）SelectRejected

这个方法是ListUtils.select的逆操作。将用户列表和谓词作为输入传递给此方法，并返回所有不满足谓词条件的元素列表。

List<UserObject> listNotMeetingPredicate = ListUtils.selectRejected(
    defaultUserList, userObj -> userObj.getUserSalary() > 20000.0);
  assertEquals(2, listNotMeetingPredicate.size());1.
2.
3.

9）IsEqualList

此方法用于比较两个列表。仅当两个列表具有相同的大小，并且两个列表中所有相应的元素对都相等时，才返回true。

List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
  List<Integer> list2 = Arrays.asList(1, 2, 3, 4);
  List<Integer> list3 = Arrays.asList(3, 4, 5, 6, 7);
  
  assertTrue(ListUtils.isEqualList(list1, list2));
  assertFalse(ListUtils.isEqualList(list1, list3));1.
2.
3.
4.
5.
6.

它还可以比较两个不同的List接口实现。示例如下：比较ArrayList、LinkedList和HashSet。

List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
  List<Integer> linkedList = new LinkedList<>(list1);
  Set<Integer> hashSet = new HashSet<>(list1);
  assertTrue(ListUtils.isEqualList(list1, linkedList));
  assertTrue(ListUtils.isEqualList(list1, hashSet));1.
2.
3.
4.
5.

10）Intersection

该方法接受两个列表作为输入，并返回两个列表的交集。

List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
  List<Integer> list3 = Arrays.asList(3, 4, 5, 6, 7);
 
  assertEquals(Arrays.asList(3, 4), ListUtils.intersection(list1, list3));1.
2.
3.
4.

11）LazyList

这是ListUtils类提供的另一个有趣的方法。它接收一个列表和一个转换器或工厂作为输入，然后返回一个懒加载列表，其元素在需要时创建。

如下所示：

Transformer<Integer, UserObject> transformer = input -> {
   if (defaultUserList.size() > input)
    return defaultUserList.get(input);
   else
    return new UserObject();
  };

  List<UserObject> lazyList = ListUtils
    .lazyList(new ArrayList<UserObject>(),
    transformer);

  assertEquals(defaultUserList.get(0), lazyList.get(0));
  assertEquals(new UserObject(), lazyList.get(6));
  assertEquals(1, lazyList.indexOf(null));1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.