前言

博客：http://blog.healerjean.com

JavaUtil包：http://gitbook.net/java/util/index.html

一、`java.util`;

1、`EnumSet`

package java.util;

public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>
    implements Cloneable, java.io.Serializable
{

1	static > EnumSet allOf(Class elementType) 此方法创建一个包含所有在指定元素类型的元素的枚举set。
2	EnumSet clone() 此方法返回这个集合的一个副本。
3	static > EnumSet complementOf(EnumSet s) 此方法创建一个枚举设置相同的元素类型与指定枚举set，最初包含此类型的所有未包含指定集合中的元素。
4	static > EnumSet copyOf(Collection c) 此方法创建一个枚举集从指定集合初始化。
5	static > EnumSet copyOf(EnumSet s) 此方法创建一个枚举设置相同的元素类型与指定枚举set，最初包含相同的元素（如果有的话）。
6	static > EnumSet noneOf(Class elementType) 此方法创建一个空的枚举set具有指定元素类型。
7	static > EnumSet of(E e) 此方法创建一个最初包含指定元素的枚举set。
8	static > EnumSet of(E first, E… rest) 此方法创建一个最初包含指定元素的枚举set。可变参数效率会低一些
9	static > EnumSet of(E e1, E e2) 此方法创建一个最初包含指定元素的枚举set。
10	static > EnumSet of(E e1, E e2, E e3) 此方法创建一个最初包含指定元素的枚举set。
11	static > EnumSet of(E e1, E e2, E e3, E e4) 此方法创建一个最初包含指定元素的枚举set。
12	static > EnumSet of(E e1, E e2, E e3, E e4, E e5) 此方法创建一个最初包含指定元素的枚举set。
13	static > EnumSet range(E from, E to) 此方法创建最初包含由两个指定端点所定义范围的元素的枚举set。

public enum DayEnum {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

1）`EnumSet.noneOf`

noneOf 返回的Set为空

@Test
public void noneOf(){
  //
  Set<DayEnum> days = EnumSet.noneOf(DayEnum.class);
  log.info("Set<DayEnum> = {} ", days);
  days.add(DayEnum.SATURDAY);
  days.add(DayEnum.SUNDAY);
  log.info("Set<DayEnum> = {} ", days);

  // []
  // [SATURDAY, SUNDAY]
}

2）`EnumSet.of`

创建一个最初包含指定元素的枚举set。

@Test
public void of(){
  Set<DayEnum> days = EnumSet.of(DayEnum.MONDAY, DayEnum.THURSDAY);
  log.info("Set<DayEnum> = {} ", days);
  // Set<DayEnum> = [MONDAY, THURSDAY]
}

3）`EnumSet.allOf`

获取所有的枚举，放入set集合

@Test
public void allOf(){
  Set<DayEnum> days = EnumSet.allOf(DayEnum.class);
  log.info("Set<DayEnum> = {} ", days);
  // Set<DayEnum> = [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]
}

4）`EnumSet.range`

枚举内顺序导出数据

@Test
public void range(){
  Set<DayEnum> range = EnumSet.range(DayEnum.TUESDAY, DayEnum.FRIDAY);
  log.info("Set<DayEnum> = {} ", range);
  // Set<DayEnum> = [TUESDAY, WEDNESDAY, THURSDAY, FRIDAY]
}

5）`EnumSet.complementOf`

此方法创建一个枚举设置相同的元素类型与指定枚举 set，最初包含此类型的所有未包含指定集合中的元素。

@Test
public void (){
  EnumSet<DayEnum> days = EnumSet.of(DayEnum.MONDAY, DayEnum.THURSDAY);
  log.info("Set<DayEnum> = {} ", days);
  // Set<DayEnum> = [MONDAY, THURSDAY]
  
  EnumSet<DayEnum> days2 = EnumSet.complementOf(days);
  log.info("Set<DayEnum> = {} ", days2);
  // Set<DayEnum> = [TUESDAY, WEDNESDAY, FRIDAY, SATURDAY, SUNDAY]
}

6）`EnumSet.copyOf`

从集合类中复制数据

@Test
public void copyOf(){
  List<DayEnum> dayList = ImmutableList.of(DayEnum.MONDAY, DayEnum.THURSDAY, DayEnum.THURSDAY);
  EnumSet<DayEnum> daySet = EnumSet.copyOf(dayList);
  // Set<DayEnum> = [MONDAY, THURSDAY]
  log.info("Set<DayEnum> = {} ", dayList);
  // Set<DayEnum> = [MONDAY, THURSDAY, THURSDAY]
}

2、`Collections`

1）`Collections.emptyList()`

@Test
public void newArrayList1(){
  List<Integer> list = Collections.emptyList();
  log.info("list:{}", list );
  
  //list:[]
}

2）`Collections.singletonList("A")`

@Test
public void test(){
  List<String> strList2 = Collections.singletonList("A");
  strList2.add("B");
  log.info("strList2:{}", strList2 );
  //抛出异常，因为是不可变的
}

3、`EnumMap`

EnumMap 是 Java 中的一个特殊 Map 实现，它要求所有的键（Key）都必须是枚举（Enum）类型。EnumMap 提供了比 HashMap 更高的性能，特别是在键是枚举类型时。以下是 EnumMap 的使用教程，包括如何创建 EnumMap、添加和获取元素、遍历 EnumMap 以及一些注意事项。

EnumMap 不允许使用 null 作为键。尝试使用 null 作为键会抛出 NullPointerException。

EnumMap 内部使用数组来实现，因此它非常紧凑且高效。

EnumMap 根据其键的自然顺序（即枚举常量声明的顺序）来维护键值对。

EnumMap 不是同步的。如果多个线程同时访问一个 EnumMap，并且至少有一个线程修改该映射，则需要外部同步。

1）创建

enum Day {  
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY  
}  
  
EnumMap<Day, String> dayMap = new EnumMap<>(Day.class);

2）添加和获取元素

dayMap.put(Day.MONDAY, "Monday");  
dayMap.put(Day.TUESDAY, "Tuesday");  
  
String monday = dayMap.get(Day.MONDAY); // 获取并打印 Monday  
System.out.println(monday); // 输出: Monday

3）遍历

// 遍历键和值  
for (Map.Entry<Day, String> entry : dayMap.entrySet()) {  
    System.out.println(entry.getKey() + ": " + entry.getValue());  
}  
  
// 遍历键  
for (Day day : dayMap.keySet()) {  
    System.out.println(day);  
}  
  
// 遍历值  
for (String value : dayMap.values()) {  
    System.out.println(value);  
}

二、`com.google.common.collect`

1、`Map`

1）`Maps`

a、`Maps.newHashMap`

/**
* 1、创建一个空的Map
*/
@Test
public void test(){
  Map<String, String> map = Maps.newHashMap();
  map.put("name", "HealerJean");
  log.info("map:{}", map);
}

2）`ImmutableMap`

不可改变的Map，修改会报错

a、`ImmutableMap.of`

@Test
public void test() {
  Map<String, String> map = ImmutableMap.of("keyA", "A", "keyB", "B");
  log.info("ImmutableMap.of = {}", map);
  //ImmutableMap.of = {keyA=A, keyB=B}

  map.put("keyN" ,"N");
  //抛出异常，因为是不可变的
}

3）常用方法

a、`computeIfAbsent`

computeIfAbsent() 方法对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hashMap 中。

返回值：如果 key 对应的 value 不存在，则使用获取 remappingFunction 重新计算后的值，并保存为该 key 的 value，否则返回 value。

/**
 * 2、computeIfAbsent
 */
@Test
public void test02(){
    Map<String, List<String>> map = Maps.newHashMap();
    map.put("a", Lists.newArrayList("aVal"));
    //  "a" 已经存在，    则追加 "aNewVal" 到list中
    map.computeIfAbsent("a", (v) -> new ArrayList<>()).add("aNewVal");

    //  "b" 不存在，     则创建新List "bVal" 到list中
    map.computeIfAbsent("b", (v) -> new ArrayList<>()).add("bVal");
    System.out.println(map);

    //  "c" valul为空， 则创建新 List "aNewVal" 到list中
    map.put("c", null);
    map.computeIfAbsent("c", (v) -> new ArrayList<>()).add("cVal");
    System.out.println(map);

    // {a=[aVal, aNewVal], b=[bVal], c=[cVal]}
}

b、`putIfAbsent`

不存在 key 或者值为 null 时，才将键值对放入 Map。跟 put 方法相比，这个方法不会直接覆盖已有的值，在不允许覆盖旧值的场景使用起来会比较简洁

返回值：如果所指定的 key 已经在 HashMap 中存在，返回和这个 key 值对应的 value, 如果所指定的 key 不在 HashMap 中存在，则返回 null。

/**
* 3、putIfAbsent
*/
@Test
public void test03(){
  Map<String,String> map = Maps.newHashMap();
  map.put("a", "aVal");
  // "a"已经存在，则不会覆盖
  map.putIfAbsent("a", "aNewVal");

  // "b"不存在，则放入
  map.putIfAbsent("b", "bVal");

  // "c" value null，则放入
  map.put("c", null);
  map.putIfAbsent("c", "cVal");
  System.out.println(map);
  // {a=aVal, b=bVal, c=cVal}
}

c、构建 `map`

  Map<String, String> map = new HashMap<String, String>() ;

d、遍历 `map`

private static void testForeach() {
  Map<String, String> map = new HashMap<>(4);
  map.put("123", "123");

  // 老写法
  for (Map.Entry<String, String> entry : map.entrySet()) {
      System.out.printf("老写法 key = %s, value = %s%n", entry.getKey(), entry.getValue());
  }

  // 新写法
  map.forEach((key, value) -> System.out.printf("新写法 key = %s, value = %s%n", key, value));
}

e、`computer`

private static void testComputer() {
    Map<String, Integer> cntMap = new HashMap<>(8);
    List<String> list = Arrays.asList("apple", "orange", "banana", "orange");

    // 老写法
    for (String item : list) {
        if (cntMap.containsKey(item)) {
            cntMap.put(item, cntMap.get(item) + 1);
        } else {
            cntMap.put(item, 1);
        }
    }

    // 新写法
    for (String item : list) {
        cntMap.compute(item, (k, v) -> {
            if (v == null) {
                v = 1;
            } else {
                v += 1;
            }
            return v;
        });
    }
}

f、

2、`Set`

1）`Sets`

a、构建和转化

/**
* 1、构建一个空的Set
*/
@Test
public void test1(){
  Set<String> set = Sets.newHashSet();
}

/**
* 2、构建有值的Set
*/
@Test
public void test2(){
  Set<String> set = Sets.newHashSet("a", "a", "b");
  log.info("set:{}", set);
}


/**
 * 3、list转Set
*/
@Test
public void test3(){
  List<String> list = Lists.newArrayList("a", "a", "b");
  Set<String> set = Sets.newHashSet(list);
  log.info("set:{}", set);
}

b、并集、交集、差集

// 差集
Sets.SetView<String> difference = Sets.difference(orderIdSet, existOrderIdSet);

2）`ImmutableSet`

a、`ImmutableSet.of`

不可变的set

@Test
public void test() {
  Set<String> immutalbleSet = ImmutableSet.of("A", "B", "C");
  log.info("ImmutableSet.of ={}" , immutalbleSet);
  //ImmutableSet.of =[A, B, C]

  immutalbleSet.add("C");
  //抛出异常，因为是不可变的
}

3、`List`

1）`Lists`

a、`Lists.newArrayList`

/**
  * 1、构建一个空的ArrayList
  */
@Test
public void newArrayList1(){
  List<Integer> list = Lists.newArrayList();
  log.info("list:{}", list );
}

/**
  * 2、直接创建
  */
@Test
public void newArrayList2(){
  List<String> list = Lists.newArrayList("a", "b");
  log.info("list:{}", list );
}



/**
* 3、set转list
*/
@Test
public void test3(){
  Set<String> set = Sets.newHashSet("a", "a", "b");
  List<String> list = Lists.newArrayList(set);
  log.info("list:{}", list );
}

b、`Lists.partition`

List<List> list1 =Lists.partition(list, 1000);

c、`ImmutableList`

不可变的list

/**
  * 3、不可变的List
  */
@Test
public void test3(){
  List<String> list = ImmutableList.of("a", "b");
  log.info("list:{}", list );

  list.add("c");
  //抛出异常，因为是不可变的

}

三、`org.apache.commons`

1、`Pair`

元素对

1）、`ImmutablePair`

a、`ImmutablePair.of`

ImmutablePair不可变的左右元素对

ImmutablePair<Integer, Double> result = ImmutablePair.of(ASSISTANT_SHOULD_CLOSE, distance);

2、`MapUtils`

1）`MapUtils.isNotEmpty`

MapUtils.isNotEmpty(actionTimeMap)

2）`getBooleanValue`、`getBoolean`

public static boolean getBooleanValue(Map map, Object key) {
  Boolean booleanObject = getBoolean(map, key);
  return booleanObject == null ? false : booleanObject;
}

public static boolean getBooleanValue(Map map, Object key, boolean defaultValue) {
  Boolean booleanObject = getBoolean(map, key);
  return booleanObject == null ? defaultValue : booleanObject;
}



public static Boolean getBoolean(Map map, Object key) {
  if (map != null) {
    Object answer = map.get(key);
    if (answer != null) {
      if (answer instanceof Boolean) {
        return (Boolean)answer;
      }

      if (answer instanceof String) {
        return new Boolean((String)answer);
      }

      if (answer instanceof Number) {
        Number n = (Number)answer;
        return n.intValue() != 0 ? Boolean.TRUE : Boolean.FALSE;
      }
    }
  }

  return null;
}

3）`getLongValue`、`getLong`

public static long getLongValue(Map map, Object key) {
  Long longObject = getLong(map, key);
  return longObject == null ? 0L : longObject;
}

public static long getLongValue(Map map, Object key, long defaultValue) {
  Long longObject = getLong(map, key);
  return longObject == null ? defaultValue : longObject;
}


public static Long getLong(Map map, Object key) {
  Number answer = getNumber(map, key);
  if (answer == null) {
    return null;
  } else {
    return answer instanceof Long ? (Long)answer : new Long(answer.longValue());
  }
}



public static Number getNumber(Map map, Object key) {
  if (map != null) {
    Object answer = map.get(key);
    if (answer != null) {
      if (answer instanceof Number) {
        return (Number)answer;
      }

      if (answer instanceof String) {
        try {
          String text = (String)answer;
          return NumberFormat.getInstance().parse(text);
        } catch (ParseException var4) {
        }
      }
    }
  }

  return null;
}

4）`getObject`

public static Object getObject(Map map, Object key) {
  return map != null ? map.get(key) : null;
}


public static Object getObject(Map map, Object key, Object defaultValue) {
  if (map != null) {
    Object answer = map.get(key);
    if (answer != null) {
      return answer;
    }
  }

  return defaultValue;
}

5）`getString`

  public static String getString(Map map, Object key) {
        if (map != null) {
            Object answer = map.get(key);
            if (answer != null) {
                return answer.toString();
            }
        }

        return null;
    }
public static String getString(Map map, Object key, String defaultValue) {
  String answer = getString(map, key);
  if (answer == null) {
    answer = defaultValue;
  }

  return answer;
}


public static String getString(Map map, Object key) {
  if (map != null) {
    Object answer = map.get(key);
    if (answer != null) {
      return answer.toString();
    }
  }

  return null;
}

3、`CollectionUtils`

1）并集 `CollectionUtils.union`

public static void main(String[] args) {
  String[] arrayA = new String[] { "1", "2", "3", "4"};
  String[] arrayB = new String[] { "3", "4", "5", "6" };
  List<String> listA = Arrays.asList(arrayA);
  List<String> listB = Arrays.asList(arrayB);

  //1、并集 union
  System.out.println(CollectionUtils.union(listA, listB));
  //输出: [1, 2, 3, 4, 5, 6]
 
}

2）交集 `CollectionUtils.intersection`、`CollectionUtils.containsAny`

public static void main(String[] args) {
  String[] arrayA = new String[] { "1", "2", "3", "4"};
  String[] arrayB = new String[] { "3", "4", "5", "6" };
  List<String> listA = Arrays.asList(arrayA);
  List<String> listB = Arrays.asList(arrayB);

  //2、交集 intersection
  System.out.println(CollectionUtils.intersection(listA, listB));
  //输出:[3, 4]

   // true
   System.out.println(CollectionUtils.containsAny(listA, listB));

}

3）差集 `CollectionUtils.subtract`

public static void main(String[] args) {
  String[] arrayA = new String[] { "1", "2", "3", "4"};
  String[] arrayB = new String[] { "3", "4", "5", "6" };
  List<String> listA = Arrays.asList(arrayA);
  List<String> listB = Arrays.asList(arrayB);

  //4、差集（扣除）
  System.out.println(CollectionUtils.subtract(listA, listB));
  //输出:[1, 2]
}

4）交集的补集 `CollectionUtils.disjunction`

public static void main(String[] args) {
  String[] arrayA = new String[] { "1", "2", "3", "4"};
  String[] arrayB = new String[] { "3", "4", "5", "6" };
  List<String> listA = Arrays.asList(arrayA);
  List<String> listB = Arrays.asList(arrayB);

  //3、交集的补集（析取）disjunction
  System.out.println(CollectionUtils.disjunction(listA, listB));
  //输出:[1, 2, 5, 6]

}

四、`cn.hutool`


hutool-aop	JDK 动态代理封装，提供非 IOC 下的切面支持
hutool-bloomFilter	布隆过滤，提供一些 Hash 算法的布隆过滤
hutool-cache	缓存
hutool-core	核心，包括 Bean 操作、日期、各种 Util 等
hutool-cron	定时任务模块，提供类 Crontab 表达式的定时任务
hutool-crypto	加密解密模块
hutool-db	JDBC 封装后的数据操作，基于 ActiveRecord 思想
hutool-dfa	基于 DFA 模型的多关键字查找
hutool-extra	扩展模块，对第三方封装（模板引擎、邮件等）
hutool-http	基于 HttpUrlConnection 的 Http 客户端封装
hutool-log	自动识别日志实现的日志门面
hutool-script	脚本执行封装，例如 Javascript
hutool-setting	功能更强大的 Setting 配置文件和 Properties 封装
hutool-system	系统参数调用封装（JVM 信息等）
hutool-json	JSON 实现
hutool-captcha	图片验证码实现

1、`DesensitizedUtil`

1）脱敏

方法	说明
`mobilePhone(phone)`	手机号输出：`137****1234`
`bankCard(bankCard)`	银行卡号输出：`6217 ** * 5666`
`idCardNum(idCardNum, 4, 2)`	身份证号输出：`4110************21`
`password(password)`	密码输出：`****************`
`email(email)`	邮箱输出：`h*********@gmail.com`
`desensitized(address, DesensitizedUtil.DesensitizedType.ADDRESS)`	地址输出：`我********`
`StrUtil.hide(any, 2, 7)`	脱敏任意长度输出：`我********`

/**
 * 脱敏
 * 1、手机号 输出：137****1234
 * 2、银行卡号 输出：6217 **** **** *** 5666
 * 3、身份证号 输出：4110************21
 * 4、密码 输出：****************
 * 5、邮箱 输出：h*********@gmail.com
 * 6、地址 输出：我********
 * 7、脱敏任意长度 输出：我********
 *
 */
@Test
public void test() {
    // 1、手机号 输出：137****1234
    String phone = "13723231234";
    System.out.println(DesensitizedUtil.mobilePhone(phone));

    // 2、银行卡号 输出：6217 **** **** *** 5666
    String bankCard = "6217000130008255666";
    System.out.println(DesensitizedUtil.bankCard(bankCard));

    // 3、身份证号 输出：4110************21
    String idCardNum = "411021199901102321";
    //只显示前4位和后2位
    System.out.println(DesensitizedUtil.idCardNum(idCardNum, 4, 2));

    // 4、密码 输出：****************
    String password = "www.jd.com_35711";
    System.out.println(DesensitizedUtil.password(password));

    // 5、邮箱 输出：h*********@gmail.com
    String email = "healerjean@gmail.com";
    System.out.println(DesensitizedUtil.email(email));

    // 6、地址 输出：我********
    String address = "我家在那山沟沟里面";
    String desensitizedAddress = DesensitizedUtil.desensitized(address, 
                                                               DesensitizedUtil.DesensitizedType.ADDRESS);
    System.out.println(desensitizedAddress);

    // 7、脱敏任意长度 输出：我********
    String any ="1234567890";
    System.out.println(StrUtil.hide(any, 2, 7));
}

2、`StrUtil`

1）`StrUtil.format`

/**
 * StrUtil
 * 1、StrUtil.format.
 */
@Test
public void test001(){
    String result = StrUtil.format("Hello, {0}", "world");
    System.out.println(result);
    // 输出：Hello, world
}

3、`DateUtil`

1）`DateUtil.format`、`DateUtil.parse`

说明	方法	输出
日期->字符串	`DateUtil.format(date, "yyyy-MM-dd HH:mm:ss");`	2023-03-15 10:30:15
日期->字符串	`DateUtil.formatDateTime(date);`	2024-04-24 17:37:19
日期->字符串时间	`DateUtil.formatTime(date);`	17:37:19
日期->字符串日期	`DateUtil.formatDate(date)`	2024-04-24
字符串->日期	`DateUtil.parse(dateStr, "yyyy-MM-dd HH:mm:ss")`
字符串->日期	`DateUtil.parseDateTime(dateStr)`

4、`NumberUtil`

方法	说明
`add(Number a, Number b)`	加法
`sub(Number a, Number b)`	减法
`mul(Number a, Number b)`	乘法
`div(Number a, Number b)`	除法
`div(Number v1, Number v2, int scale, RoundingMode roundingMode)`	除法，保留小数和进位规则
`round(Number num, int decimalPlaces)`	保留指定位数小数，四舍五入
`isNumber(String str)`	判断字符串是否是数字
`isInteger(String str)`	判断是否是 `Integer`
`isDouble(String str)`	判断是否是 `Double`

5、`PageUtil`

方法	说明
`totalPage(int total, int size)`	根据总记录数和每页容量计算总页数

ContactAuthor

一、java.util;

1、EnumSet

1）EnumSet.noneOf

2）EnumSet.of

3）EnumSet.allOf

4）EnumSet.range

5）EnumSet.complementOf

6）EnumSet.copyOf

2、Collections

1）Collections.emptyList()

2）Collections.singletonList("A")

3、EnumMap

1）创建

2）添加和获取元素

3）遍历

二、com.google.common.collect

1、Map

1）Maps

a、Maps.newHashMap

2）ImmutableMap

a、ImmutableMap.of

3）常用方法

a、computeIfAbsent

b、putIfAbsent

c、构建 map

d、遍历 map

e、computer

f、

2、Set

1）Sets

a、构建和转化

b、并集、交集、差集

2）ImmutableSet

a、ImmutableSet.of

3、List

1）Lists

a、Lists.newArrayList

b、Lists.partition

c、ImmutableList

三、org.apache.commons

1、Pair

1）、ImmutablePair

a、ImmutablePair.of

2、MapUtils

1）MapUtils.isNotEmpty

2）getBooleanValue、getBoolean

3）getLongValue、getLong

4）getObject

5）getString

3、CollectionUtils

1）并集 CollectionUtils.union

2）交集 CollectionUtils.intersection、CollectionUtils.containsAny

3）差集 CollectionUtils.subtract

4）交集的补集 CollectionUtils.disjunction

四、cn.hutool

1、DesensitizedUtil

1）脱敏

2、StrUtil

1）StrUtil.format

3、DateUtil

1）DateUtil.format、DateUtil.parse

4、NumberUtil

5、PageUtil

一、`java.util`;

1、`EnumSet`

1）`EnumSet.noneOf`

2）`EnumSet.of`

3）`EnumSet.allOf`

4）`EnumSet.range`

5）`EnumSet.complementOf`

6）`EnumSet.copyOf`

2、`Collections`

1）`Collections.emptyList()`

2）`Collections.singletonList("A")`

3、`EnumMap`

二、`com.google.common.collect`

1、`Map`

1）`Maps`

a、`Maps.newHashMap`

2）`ImmutableMap`

a、`ImmutableMap.of`

a、`computeIfAbsent`

b、`putIfAbsent`

c、构建 `map`

d、遍历 `map`

e、`computer`

2、`Set`

1）`Sets`

2）`ImmutableSet`

a、`ImmutableSet.of`

3、`List`

1）`Lists`

a、`Lists.newArrayList`

b、`Lists.partition`

c、`ImmutableList`

三、`org.apache.commons`

1、`Pair`

1）、`ImmutablePair`

a、`ImmutablePair.of`

2、`MapUtils`

1）`MapUtils.isNotEmpty`

2）`getBooleanValue`、`getBoolean`

3）`getLongValue`、`getLong`

4）`getObject`

5）`getString`

3、`CollectionUtils`

1）并集 `CollectionUtils.union`

2）交集 `CollectionUtils.intersection`、`CollectionUtils.containsAny`

3）差集 `CollectionUtils.subtract`

4）交集的补集 `CollectionUtils.disjunction`

四、`cn.hutool`

1、`DesensitizedUtil`

2、`StrUtil`

1）`StrUtil.format`

3、`DateUtil`

1）`DateUtil.format`、`DateUtil.parse`

4、`NumberUtil`

5、`PageUtil`