SpringBoot工具类清单

SpringBoot自带了很多有用的工具类，我们应该学会使用它们。

CollectionUtils

isEmpty

判断集合或Map是否为空，支持集合或Map

@Test
void isEmpty() {
    var list = Arrays.asList(1, 2, 3);
    assertFalse(CollectionUtils.isEmpty(list));
    list = List.of();
    assertTrue(CollectionUtils.isEmpty(list));
    list = null;
    assertTrue(CollectionUtils.isEmpty(list));
​
    var map = Map.of(1, "first", 2, "second");
    assertFalse(CollectionUtils.isEmpty(map));
    map = Map.of();
    assertTrue(CollectionUtils.isEmpty(map));
    map = null;
    assertTrue(CollectionUtils.isEmpty(map));
}

newHashMap

创建一个可以容纳指定数量元素的HashMap，而不需要扩容

@Test
void newHashMap() throws IllegalAccessException, NoSuchFieldException {
    // 创建一个可以容纳15个元素的HashMap，内部数组大小应该是32
    var map = CollectionUtils.<String, String>newHashMap(15);
    var threshold = HashMap.class.getDeclaredField("threshold");
    threshold.setAccessible(true);
    var thresholdValue = (int) threshold.get(map);
    assertEquals(32, thresholdValue);
}

newLinkedHashMap

创建一个可以容纳指定数量元素的LinkedHashMap，而不需要扩容

@Test
void newLinkedHashMap() throws IllegalAccessException, NoSuchFieldException {
    // 创建一个可以容纳15个元素的HashMap，内部数组大小应该是32
    var map = CollectionUtils.<String, String>newLinkedHashMap(15);
    var threshold = HashMap.class.getDeclaredField("threshold");
    threshold.setAccessible(true);
    var thresholdValue = (int) threshold.get(map);
    assertEquals(32, thresholdValue);
}

arrayToList

将提供的数组转换成一个列表，一般推荐使用Arrays.asList，这里支持Object类型，并且在参数为null时，返回空集合。

@Test
void arrayToList() {
    var array = new int[]{1, 2, 3, 4};
    var list = CollectionUtils.arrayToList(array);
    assertEquals(4, list.size());
​
    // 虽然入参是Object，但是不支持非数组
    var number = 1;
    assertThrows(IllegalArgumentException.class, () -> CollectionUtils.arrayToList(number));
​
    String item = null;
    list = CollectionUtils.arrayToList(item);
    assertEquals(0, list.size());
}

mergeArrayIntoCollection

将给定的数组合并到给定的集合中。

@Test
void mergeArrayIntoCollection() {
    var list = new ArrayList<>();
    var array = new int[]{1, 2, 3};
    CollectionUtils.mergeArrayIntoCollection(array, list);
​
    assertEquals(3, list.size());
​
    // Arrays.asList是不可写集合
    var list1 = Arrays.asList(4, 5, 6);
    assertThrows(UnsupportedOperationException.class, () -> CollectionUtils.mergeArrayIntoCollection(array, list1));
}

mergePropertiesIntoMap

将给定的属性实例合并到给定的Map中。

@Test
void mergePropertiesIntoMap() {
    var properties = System.getProperties();
    var size = properties.size();
    var map = CollectionUtils.newHashMap(size);
    assertEquals(0, map.size());
    CollectionUtils.mergePropertiesIntoMap(properties, map);
    assertEquals(size, map.size());
}

contains

检查给定的Iterator/Enumeration是否包含给定的元素。

注意，这里支持的入参是迭代器，所以用途范围很广。

@Test
void contains() {
    var list = Arrays.asList(1, 2, 3, 4, 5);
    assertTrue(CollectionUtils.contains(list.iterator(), 1));
}

containsInstance

检查给定的 Collection 是否包含给定的元素实例。

@Test
void containsInstance() {
    var list = Arrays.asList(1, 2, 3, 4, 5);
    assertTrue(CollectionUtils.containsInstance(list, 1));
}

containsAny

检查两个集合是否存在交集。

@Test
void containsAny() {
    var list1 = Arrays.asList(1, 2, 3, 4, 5);
    var list2 = Arrays.asList(6, 7, 8, 9, 10);
​
    assertFalse(CollectionUtils.containsAny(list1, list2));
    list2 = Arrays.asList(5, 6, 7, 8, 9);
    assertTrue(CollectionUtils.containsAny(list1, list2));
}

findFirstMatch

寻找两个集合首次出现的相同元素。

@Test
void findFirstMatch() {
    var list1 = Arrays.asList(1, 2, 3, 4, 5);
    var list2 = Arrays.asList(6, 7, 8, 9, 10);
​
    assertNull(CollectionUtils.findFirstMatch(list1, list2));
    list2 = Arrays.asList(5, 6, 7, 8, 9);
    assertEquals(5, CollectionUtils.findFirstMatch(list1, list2));
}

findValueOfType

在给定的 Collection 中查找给定类型的单个值。通常应该用于非单一泛型集合。

@Test
void findValueOfType() {
    var list = Arrays.asList(1, "first", 0.0);
​
    assertEquals(1, CollectionUtils.findValueOfType(list, Integer.class));
    assertEquals("first", CollectionUtils.findValueOfType(list, String.class));
    assertEquals(0.0, CollectionUtils.findValueOfType(list, Double.class));
}

findValueOfType（支持多个类型）

在给定的 Collection 中查找给定类型的单个值，支持传入多个类型，第一个类型找不到，继续找第二个，直到找到为止。

@Test
void findValueOfType1() {
    var list = Arrays.asList(1, "first", 0.0);
​
    // 因为1匹配Integer类型，所以不会继续往下找
    assertEquals(1, CollectionUtils.findValueOfType(list, new Class[]{Integer.class, String.class}));
    // 因为1不匹配BigDecimal，所以会继续往下找，找到"first"就终止了
    assertEquals("first", CollectionUtils.findValueOfType(list, new Class[]{BigDecimal.class, String.class}));
}

hasUniqueObject

确定给定的 Collection 是否只包含一个唯一的对象，不知道用在哪里，感觉没有使用场景啊。

@Test
void hasUniqueObject() {
    var list = List.of(1, 2);
    assertFalse(CollectionUtils.hasUniqueObject(list));
​
    list = List.of(1);
    assertTrue(CollectionUtils.hasUniqueObject(list));
}

findCommonElementType

查找给定 Collection 的公共元素类型（如果有）。

@Test
void findCommonElementType() {
    var list = List.of(1, 2);
    assertEquals(Integer.class, CollectionUtils.findCommonElementType(list));
​
    // 如果集合元素类型不一致，返回null
    var list1 = List.of(1, "2");
    assertNull(CollectionUtils.findCommonElementType(list1));
}

firstElement

返回Set的第一个元素，如果是SortedSet，返回第一个元素，如果是Set，返回迭代器的第一个元素（该元素每次都不一致）

@Test
void firstElement() {
    var set = Set.of(1, 2, 3);
    // 可能成功可能失败，因为Set是无序的，第一个元素不一定
    // assertEquals(1, CollectionUtils.firstElement(set));
​
    var sortedSet = new TreeSet<Integer>();
    sortedSet.add(1);
    sortedSet.add(2);
    sortedSet.add(3);
    assertEquals(1, CollectionUtils.firstElement(sortedSet));
​
    var list = List.of(1, 2, 3);
    assertEquals(1, CollectionUtils.firstElement(list));
}

lastElement

返回Set的最后一个元素，如果是SortedSet，返回最后一个元素，如果是Set，返回迭代器的最后一个元素（该元素每次都不一致）

@Test
void lastElement() {
    var set = Set.of(1, 2, 3);
    // 可能成功可能失败，因为Set是无序的，第一个元素不一定
    // assertEquals(1, CollectionUtils.lastElement(set));
​
    var sortedSet = new TreeSet<Integer>();
    sortedSet.add(1);
    sortedSet.add(2);
    sortedSet.add(3);
    assertEquals(3, CollectionUtils.lastElement(sortedSet));
​
    var list = List.of(1, 2, 3);
    assertEquals(3, CollectionUtils.lastElement(list));
}

toMultiValueMap

unmodifiableMultiValueMap

ObjectUtils

isCheckedException

返回给定的 throwable 是否是受检异常

@Test
void isCheckedException() {
    var ex = new RuntimeException();
    assertFalse(ObjectUtils.isCheckedException(ex));
​
    var ex1 = new IOException();
    assertTrue(ObjectUtils.isCheckedException(ex1));
}

isCompatibleWithThrowsClause

检查给定的异常是否是指定的异常类型。

如果不是受检异常，直接返回True

@Test
void isCompatibleWithThrowsClause() {
    var ex = new TestRuntimeException();
    // 如果不是受检异常，直接返回True
    assertTrue(ObjectUtils.isCompatibleWithThrowsClause(ex));
​
    var ex1 = new TestException();
    assertFalse(ObjectUtils.isCompatibleWithThrowsClause(ex1));
    // 可以用准确的类型
    assertTrue(ObjectUtils.isCompatibleWithThrowsClause(ex1, TestException.class));
    // 可以用父类
    assertTrue(ObjectUtils.isCompatibleWithThrowsClause(ex1, IOException.class));
}

isArray

判断对象是否是数组，可以是一维数组，或者多维数组。但不能是集合

底层使用Class native方法

@Test
void isArray() {
    var arr = new int[1];
    var arr1 = new int[1][2];
​
    assertTrue(ObjectUtils.isArray(arr));
    assertTrue(ObjectUtils.isArray(arr1));
​
    var list = new ArrayList<>();
    assertFalse(ObjectUtils.isArray(list));
}

isEmpty

确定给定数组是否为空: 即null或长度为零。

@Test
void isEmpty() {
    var arr = new int[0];
    assertTrue(ObjectUtils.isEmpty(arr));
​
    arr = null;
    assertTrue(ObjectUtils.isEmpty(arr));
​
    arr = new int[2];
    assertFalse(ObjectUtils.isEmpty(arr));
}

unwrapOptional

展开Optional对象

@Test
void unwrapOptional() {
    var optional = Optional.of(11);
    assertEquals(11, ObjectUtils.unwrapOptional(optional));
​
    optional = Optional.empty();
    assertNull(ObjectUtils.unwrapOptional(optional));
​
    // 不支持嵌套Optional
    var wrappedOptional = Optional.of(optional);
    assertThrows(IllegalArgumentException.class, () -> ObjectUtils.unwrapOptional(wrappedOptional));
}

containsElement

检查给定的数组是否包含给定的元素。

@Test
void containsElement() {
    var arr = new Integer[]{1, 2, 3};
    assertTrue(ObjectUtils.containsElement(arr, 1));
    assertFalse(ObjectUtils.containsElement(arr, 0));
    assertFalse(ObjectUtils.containsElement(null, 0));
}

containsConstant

检查给定的枚举常量数组是否包含给定名称的常量， 在确定匹配时忽略大小写。

@Test
void containsConstant() {
    assertTrue(ObjectUtils.containsConstant(Gender.values(), "MALE"));
    assertTrue(ObjectUtils.containsConstant(Gender.values(), "male"));
    assertFalse(ObjectUtils.containsConstant(Gender.values(), "male111"));
​
    // 不忽略大小写
    assertFalse(ObjectUtils.containsConstant(Gender.values(), "male", true));
}

caseInsensitiveValueOf

Enum.valueOf(Class，String) 不区分大小写。

@Test
void caseInsensitiveValueOf() {
    assertNotNull(ObjectUtils.caseInsensitiveValueOf(Gender.values(), "male"));
    assertThrows(IllegalArgumentException.class, () -> ObjectUtils.caseInsensitiveValueOf(Gender.values(), "male111"));
}

addObjectToArray

将给定对象附加到给定数组，返回一个新数组，由输入数组内容加上给定的对象组成。

@Test
void addObjectToArray() {
    var arr = new Integer[]{1, 2, 3};
    var newArr = ObjectUtils.addObjectToArray(arr, 4);
​
    assertEquals(4, newArr.length);
    // 原数组未变化
    assertEquals(3, arr.length);
}

toObjectArray

将给定的数组 (可能是原始数组) 转换为 对象数组 (如果需要原始包装对象)。 null值将转换为 空对象数组。

@Test
void toObjectArray() {
    var arr = new Integer[]{1, 2, 3};
    assertEquals(3, ObjectUtils.toObjectArray(arr).length);
    // NULL转为空数组
    assertEquals(0, ObjectUtils.toObjectArray(null).length);
}

nullSafeEquals

确定给定的对象是否相等，如果返回true 如果只有一个是null或false ，则两者都是null。 将数组与arrays.equals进行比较，表示相等 根据数组元素而不是数组引用进行检查。

@Test
void nullSafeEquals() {
    assertFalse(ObjectUtils.nullSafeEquals(null, 111));
    assertTrue(ObjectUtils.nullSafeEquals(111, Integer.parseInt("111")));
    // 2个都是NULL，返回True
    assertTrue(ObjectUtils.nullSafeEquals(null, null));
​
    // 和Objects比较
    assertFalse(Objects.equals(null, 111));
    assertTrue(Objects.equals(111, Integer.parseInt("111")));
    assertTrue(Objects.equals(null, null));
}