前言

博客：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）常用方法

特性	`putIfAbsent`	`computeIfAbsent`
值来源	必须提前提供一个具体的 `value`	通过函数动态计算 value
	不会覆盖已有的值	不会覆盖已有的值
是否懒加载	否（`value` 必须预先创建）	是（仅当 key 不存在时才调用函数）
支持 null 值	取决于 `Map` 实现（如 `ConcurrentHashMap` 不允许 null）	函数返回 `null` 时不会插入，视为无操作
性能	若 `value` 创建开销大，可能浪费资源	更高效，避免不必要的对象创建
适用场景	简单插入已知值	需要根据 key 动态生成值（如 new ArrayList<>()）

a、`computeIfAbsent`

mappingFunction 只在需要时才被调用（懒加载），且不能返回 null（若返回 null，不会插入任何值）。

如果指定的 key 不存在，则调用 mappingFunction 函数来计算 value，并将结果插入 map。
返回：如果 key 存在，返回已有值；否则返回新计算出的值（并插入）。

/**
 * 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`

注意：即使传入的 value 是 null，也会被视为有效值（除非 map 不允许 null 值，如 ConcurrentHashMap）。

put：如果指定的 key 不存在（即当前映射为 null），则将 key-value 对插入 map。
返回：如果 key 已存在，则返回旧值；否则返回 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;
        });
    }
}

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`

方法	说明
`this.totalPage = PageUtil.totalPage(totalCount, pageSize);`	根据总记录数和每页容量计算总页数

五、`com.google.common.base`

1、`Preconditions`

方法	用例	抛出的异常	使用说明
`checkArgument(boolean expression)`	`Preconditions.checkArgument(divisor != 0, "除数不能为零");`	`IllegalArgumentException`	用于检查传入的布尔表达式是否为 `true`。常用于验证方法参数的有效性，当参数不满足条件时，抛出此异常，提示调用者传入的参数有误。
`checkNotNull(T reference)`	`String nonNullStr = Preconditions.checkNotNull(str, "传入的字符串不能为 null");`	`NullPointerException`	用于检查传入的引用是否为 `null`。在需要确保某个对象引用不为空的场景下使用，若为 `null` 则抛出异常，避免后续代码因空引用而出现 `NullPointerException`。
`checkState(boolean expression)`	`Preconditions.checkState(isConnected, "数据库未连接，无法执行查询");`	`IllegalStateException`	用于检查对象的状态是否符合预期。适用于在执行某个操作前，需要确保对象处于特定状态的情况，若状态不满足条件则抛出异常。
`checkElementIndex(int index, int size)`	` Preconditions.checkElementIndex(index, list.size(), “索引超出范围”); `\|` IndexOutOfBoundsException `\| 用于检查索引是否在有效范围内（`0 `到` size - 1`）。常用于验证数组、列表等集合的索引是否合法，若索引超出范围则抛出异常。
`checkPositionIndex(int index, int size)`	` Preconditions.checkPositionIndex(index, list.size(), “插入位置索引超出范围”); `\|` IndexOutOfBoundsException `\| 用于检查索引是否在有效范围内（`0 `到` size`），与` checkElementIndex `不同的是，它允许索引等于` 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

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

五、com.google.common.base

1、Preconditions

一、`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`

五、`com.google.common.base`

1、`Preconditions`