写了个常用的工具方法类

经常写业务代码，会用到各种apache或Hutool的工具类和方法，在业务代码中大量充斥着apache或者Hutool的工具类名。

发现有这么几个问题：

1. 类名占用一定的长度，导致一行代码中不少内容是工具类的类名，阅读成本变高，核心业务逻辑容易被这些工具类方法淹没，默认的代码格式化容易产生中间换行（大部分人并不习惯使用import static）
2. 不同的工具方法在不同的工具类中，你使用前需要知道在哪个工具类中，对于不那么熟的人不太友好，需要每个类都看一遍才知道有哪些工具方法
3. apache或Hutool的工具方法非常多，且分散在不同的jar包和类中，但日常特别常用的其实并不多，有时候大家还会自己写一点工具类作为apache或Hutool工具类的补充，这也导致多人协作时不知道哪些工具方法在哪里

所以我写了一个工具类，只有一个类，直接解决上面的问题，有这么几个核心原则：

1. 就一个类：所有常用工具方法放在一个类中，不用想改使用哪个类
2. 类名简洁：就一个字母“X”，表示什么都可以代表，不占用代码篇幅
3. 见名知义：方法名尽量一看就知道含义，部分方法跟apache相同或者相似
4. 语义一致：相同的方法名在不同的类型上表现是一致的
5. 不做全能：覆盖最常用的工具方法，但追求覆盖所有工具方法
6. 不抛异常：除requireXxx方法外，不会抛出任何异常，意外情况会有默认实现
7. 线程安全：所有方法都是线程安全的
8. 内存安全：所有方法都不会导致内存泄露
9. 无依赖：仅依赖jdk自身，无其他外部依赖
10. 鼓励定制：不打包到nexus maven仓库中，使用方式是直接复制代码到自己的代码仓库，方便大家根据需要修改和补充，没有任何负担

代码在这里，其实内容很简单，代码一看就懂，Welcome to pull requests：

github.com/java-util-x…

主要包含这些工具方法：

工具方法（通用）

<T> T as(T obj, T defaultObj)
String string(Object obj, Object defaultObj)

数字解析

int numberInt(String str)
int number(String str, int defaultInt)
long numberLong(String str)
long number(String str, long defaultLong)

字符串操作

int indexOf(String str, String searchString)
int indexOf(String str, String searchString, int fromIndex)
String replaceByRegex(String str, String regex, String replacement)
Pattern pattern(String regex)
String replace(String str, String searchStr, String replacement)
List<String> split(String str, String separator)
List<String> split(String str, char c)
String trimToEmpty(String str)
String trimToNull(String str)
boolean contains(String str, String s)
boolean isNumber(CharSequence cs)
String format(String template, Object... args) // 字符串模板格式化（SLF4J 风格）

集合/数组类型转换

<T> T[] array(T... arr)
<T> List<T> list()
<T> List<T> list(Collection<T> l)
<T> List<T> list(T... arr)
<T> Set<T> set()
<T> Set<T> set(Collection<T> s)
<T> Set<T> set(T... arr)
<K, V> Map<K, V> map()
<K, V> Map<K, V> map(Map<K, V> m)
<K, V> Map<K, V> map(K key, V value)
<K, V> Map<K, V> map(K k1, V v1, K k2, V v2)
<K, V> Map<K, V> map(K k1, V v1, K k2, V v2, K k3, V v3)
<K, V> Map<K, V> map(Object... kOrV)

判空/判等/布尔判断

boolean isNull(Object o)
boolean isNotNull(Object o)
boolean isTrue(boolean b)
boolean isFalse(boolean b)
boolean isTrue(Boolean b)
boolean isFalse(Boolean b)
boolean isBlank(CharSequence cs)
boolean isNotBlank(CharSequence cs)
boolean isAllBlank(CharSequence... arr)
boolean isAnyNotBlank(CharSequence... arr)
boolean isAnyBlank(CharSequence... arr)
boolean isAllNotBlank(CharSequence... arr)
boolean isEmpty(CharSequence cs)
boolean isNotEmpty(CharSequence cs)
<T> boolean isEmpty(T[] arr)
<T> boolean isNotEmpty(T[] arr)
<T> boolean isEmpty(Collection<T> collection)
<T> boolean isNotEmpty(Collection<T> collection)
<K, V> boolean isEmpty(Map<K, V> map)
<K, V> boolean isNotEmpty(Map<K, V> map)
boolean equals(Object o1, Object o2)
boolean notEquals(Object o1, Object o2)
<T> boolean equals(T[] a1, T[] a2)
<T> boolean notEquals(T[] a1, T[] a2)
boolean equals(byte[] a1, byte[] a2)
boolean notEquals(byte[] a1, byte[] a2)
boolean equals(int[] a1, int[] a2)
boolean notEquals(int[] a1, int[] a2)
boolean equals(long[] a1, long[] a2)
boolean notEquals(long[] a1, long[] a2)
boolean equals(float[] a1, float[] a2)
boolean notEquals(float[] a1, float[] a2)
boolean equals(float[] a1, float[] a2, float epsilon)
boolean notEquals(float[] a1, float[] a2, float epsilon)
boolean equals(double[] a1, double[] a2)
boolean notEquals(double[] a1, double[] a2)
boolean equals(double[] a1, double[] a2, double epsilon)
boolean notEquals(double[] a1, double[] a2, double epsilon)
<T> boolean equals(List<T> a1, List<T> a2)
<T> boolean notEquals(List<T> a1, List<T> a2)
<T> boolean equals(Set<T> a1, Set<T> a2)
<T> boolean notEquals(Set<T> a1, Set<T> a2)
<K, V> boolean equals(Map<K, V> a1, Map<K, V> a2)
<K, V> boolean notEquals(Map<K, V> a1, Map<K, V> a2)

包含性检查

<T> boolean contains(Collection<T> list, T t)
<T> boolean contains(T[] array, T t)
<K, V> boolean contains(Map<K, V> map, K k, V v)
<K, V> boolean containsKey(Map<K, V> map, K k)
<K, V> boolean containsValue(Map<K, V> map, V v)

大小获取

int size(CharSequence cs)
<T> int size(Collection<T> list)
<K, V> int size(Map<K, V> map)
int size(byte[] array)
int size(int[] array)
int size(long[] array)
int size(float[] array)
int size(double[] array)
<T> int size(T[] array)

获取元素

<T> T get(T[] arr, int index)
<T> T get(List<T> list, int index)
<K, V> V get(Map<K, V> map, K key)

集合/Map 操作

Map<String, String> put(Map<String, String> map, String key, String value)
<K, V> Map<K, V> put(Map<K, V> map, K key, V value)
<K, V> Map<K, V> putIfAbsent(Map<K, V> map, K key, V value)
<T> Set<T> add(Set<T> collection, T t)
<T> List<T> add(List<T> collection, T t)

日期时间处理

Date date(String str)
Date date(String str, DateTimeFormatter formatter)
String format(Date date)
String format(Date date, DateTimeFormatter formatter)

断言并取值（requireXXX）

boolean requireTrue(boolean b, String messageTemplate, Object... args)
boolean requireFalse(boolean b, String messageTemplate, Object... args)
<T> T requireNull(T obj, String messageTemplate, Object... args)
<T> T requireNotNull(T obj, String messageTemplate, Object... args)
String requireBlank(String str, String messageTemplate, Object... args)
String requireNotBlank(String str, String messageTemplate, Object... args)
<T extends Collection> T requireEmpty(T t, String messageTemplate, Object... args)
<T extends Collection> T requireNotEmpty(T t, String messageTemplate, Object... args)
<T> T[] requireEmpty(T[] arr, String messageTemplate, Object... args)
<T> T[] requireNotEmpty(T[] arr, String messageTemplate, Object... args)
Map requireEmpty(Map m, String messageTemplate, Object... args)
Map requireNotEmpty(Map m, String messageTemplate, Object... args)
Object requireEquals(Object obj1, Object obj2, String messageTemplate, Object... args)