⭐⭐⭐ Spring Boot 项目实战	⭐⭐⭐ Spring Cloud 项目实战
《Dubbo 实现原理与源码解析 —— 精品合集》	《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》	《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》	《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》	《Java 面试题 + Java 学习指南》

摘要: 原创出处匠心零度「零度冰炫」欢迎转载，保留摘要，谢谢！

01、能让你提升效率的「轮子」

🙂🙂🙂关注**微信公众号：【芋道源码】**有福利：

RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表

RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址

您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。

新的源码解析文章实时收到通知。每周更新一篇左右。

认真的源码交流微信群。

01、能让你提升效率的「轮子」

在 Java 的庞大体系里面，有太多的工具封装了我们常用的功能，这就是我们平常说的「轮子」。

如果工作中我们开始就知道这些「轮子」，那会极大的提升我们的效率，甚至别人还在 coding、搜索代码、找轮子。你因为熟知这些轮子，早早的写完了代码，提早下班、约妹子吃小龙虾。

这里给大家分享一些我工作中最常用的「轮子」，这都是经过我工作验证的，绝对是能让你提早下班的利器！

02、JDK 自带的常用工具类

JDK 本身就已提供了很多常用的工具类，这些工具类能覆盖到我们很多的业务开发场景。

以下是个人常用的一些工具类：Objects、Collections、Arrays等。

以上三个是工作中使用非常高频的工具类，如果能熟练使用它们，就不需要在自己造轮子或者网上搜索实现了，Java 官方自带安全、可靠。

03、Objects

Objects 封装了对象的常用操作，包括不限于：比较、判空、计算哈希值等功能。

下面是日常使用 Objects 最多的一些 API 示例。

// 比较两个对象是否相同
Objects.equals(new Integer(128), new Integer(128));

// 返回对象的 hashCode
        Objects.hashCode(new Integer(128));

// 对象不为空则返回，否则抛出 NullPointerException
        Objects.requireNonNull(new Integer(128));

// 判断对象是否为空
        Objects.isNull(new Integer(128));

// 判断对象是否不为空
        Objects.nonNull(new Integer(128));

04、Arrays

Arrays 封装了数组的操作，包括不限于以下功能：全排序、指定排序、二分查找、比较、填充、复制等功能。

下面就是日常使用 Arrays 最多的一些 API 示例。

// 数组按照升序排序 [1, 3, 2, 5, 4] => [1, 2, 3, 4, 5]
Arrays.sort(array);

// 数组按照比较器（当前使用的是降序）排序 [1, 3, 2, 5, 4] => [5, 4, 3, 2, 1]
        Arrays.sort(array,(o1, o2) -> o2 - o1);

// 数组按照升序并行排序 [1, 3, 2, 5, 4] => [1, 2, 3, 4, 5]
        Arrays.parallelSort(array);

// 使用二分查找在数组内查找元素，然后返回对应的下标，如果没有找到，返回 -1
// [1, 2, 3, 4, 5] 3 => 2
        Arrays.binarySearch(array, 3);

// 比较两个数组是否相等 [1, 2, 3, 4, 5] [1, 2, 3, 4, 5] => true
        Arrays.equals(new Integer[]{1, 2, 2, 5, 4}, new Integer[]{1, 3, 2, 5, 4});

// 将指定元素填充到数组内，如果数组内元素已存在，则覆盖
// [0, 0, 0, 0] => [1, 1, 1, 1]
        Arrays.fill(new int[4],1);

// 从下标 0 开始复制指定长度的数组，并返回新的数组
// [1, 2, 3, 4, 5] => [1, 2, 3]
        Arrays.copyOf(new int[]{1, 2, 3, 4, 5}, 3);

// 复制指定范围内的数组元素，并返回新的数组
// [1, 2, 3, 4, 5] => [1, 2, 3]
        Arrays.copyOfRange(new int[]{1, 2, 3, 4, 5}, 0, 3);

// 将数组转换为固定大小的 List 对象，不能对返回的 List 对象进行增删操作
        Arrays.asList(1,2,3);

// 将数组转换为 Stream 流对象
        Arrays.stream(new int[]{1,2,3});

05、Collections

Collections 封装了集合的操作，包括不限于以下功能：排序、集合内的最大值/最小值、查找元素、替换元素等功能。

下面就是我日常使用 Collections 最多的一些 API 示例。

// 升序 [10, 4, 6, 1, 2] => [1, 2, 4, 6, 10]
Collections.sort(list);
// 自定义比较器排序（降序） [10, 4, 6, 1, 2] => [10, 6, 4, 2, 1]
        Collections.sort(list, (o1, o2) -> o2 - o1);

// 反转集合 [10, 4, 6, 1, 2] => [2, 1, 6, 4, 10]
        Collections.reverse(list);

// 获取集合内的最大值（必须是Comparable的子类，否则需要自己指定比较器） [10, 4, 6, 1, 2] => 10
        Collections.max(list);

// 获取集合内的最小值（必须是Comparable的子类，否则需要自己指定比较器） [10, 4, 6, 1, 2] => 1
        Collections.min(list);

// 返回空集合、空 Map、空 Set
        Collections.emptyList();
        Collections.emptyMap();
        Collections.emptySet();

// 二分查找集合内元素（集合必须是有序的）返回对应的下标
// [10, 4, 6, 1, 2] => [1, 2, 4, 6, 10] => 2
        Collections.binarySearch(list, 4);

// 转换为不可变集合，不可变集合不可以添加元素，但可以修改元素（针对引用类型），所有的操作都会返回新的集合。
// 所有 Collection 的子类都可以转换为不可变集合，包括：List、Set、Map、Queue、Deque、NavigableSet、NavigableMap、SortedSet、SortedMap
        Collections.unmodifiableList(list);

// 将一个先进先出的队列变为后进先出的队列
        Collections.asLifoQueue(new LinkedList<>(list));

// 打乱集合顺序
        Collections.shuffle(list);

// 交换集合内两个元素的位置 [1, 2, 4, 6, 10] => [4, 2, 1, 6, 10]
        Collections.swap(list,0,2);

// 将集合内的所有元素替换为指定的元素 [10, 4, 6, 1, 2] => [20, 20, 20, 20, 20]
        Collections.fill(list,20);

// 添加指定元素到集合内 [10, 4, 6, 1, 2] => [10, 4, 6, 1, 2, 1, 2, 3]
        Collections.addAll(list,1,2,3);

// 返回集合中指定元素的个数 [10, 4, 6, 1, 2] => 1
        Collections.frequency(list, 4);

// 替换集合内的指定元素（通过 equals 比较） [10, 4, 6, 1, 2] => [10, 4, 6, 20, 2]
        Collections.replaceAll(list,1,20);

06、Apache 工具类

Apache 基金会提供了另外的工具类，包含不限于：commons-collections4、common-lang3、commons-io 等工具依赖，能极大的补充 JDK 工具类没有覆盖到的常用功能。

以下是个人常用的一些工具类：CollectionUtils、StringUtils、IOUtils等。

其实还有其它的工具类，比如：ListUtils、SetUtils、MapUtils、ComparatorUtils、ClassUtils等，有兴趣的可以自己进行查看，这里就不介绍了。

07、CollectionUtils

CollectionUtils 封装了集合的操作，包括不限于以下功能：判空、交集、并集、补集、差集等功能。

下面就是我日常使用 CollectionUtils 最多的一些 API 示例。

// 判断集合是否为空
CollectionUtils.isEmpty(list);

// 判断集合是否不为空
        CollectionUtils.isNotEmpty(list);

// 获取两个可迭代对象的并集 [1, 2, 3]  [2, 3, 4] => [1, 2, 3, 4]
        CollectionUtils.union(list, list1);

// 获取两个可迭代对象的交集 [1, 2, 3]  [2, 3, 4] => [2, 3]
        CollectionUtils.intersection(list, list1);

// 获取两个可迭代对象的差集 [1, 2, 3]  [2, 3, 4] => [1]
        CollectionUtils.subtract(list, list1);

// 获取两个可迭代对象交集的补集 [1, 2, 3]  [2, 3, 4] => [1, 4]
        CollectionUtils.disjunction(list, list1);

// 判断是否是子集 [2, 3]  [1, 2, 3] => true
        CollectionUtils.isSubCollection(list, list1);

// 判断是否是父集 [1, 2, 3]  [2, 3] => true
        CollectionUtils.containsAll(list, list1);

// 判断两个集合的交集是否为空 [1, 2, 3]  [5, 6] => false
        CollectionUtils.containsAny(list, list1);

// 统计元素在可迭代对象中出现次数的 Map，key 为元素本身，value 是元素出现的次数
// [1, 2, 3, 2] => {1=1, 2=2, 3=1}
        CollectionUtils.getCardinalityMap(list);

// 通过 Predicate 接口过滤可迭代对象中的元素，Predicate 返回为 false 则删除元素
// [1, 2, 3, 2] => [3]
        CollectionUtils.filter(list,i -> i > 2);

// 对集合内的所有元素通过 Transformer 转换
// [1, 2, 3, 2] => [2, 3, 4, 3]
        CollectionUtils.transform(list, input -> input+1);

// 通过 Predicate 接口过滤可迭代对象中的元素，返回符合条件的集合
        CollectionUtils.select(list, i -> i > 1);

// 返回输入集合的所有排列的集合 [1, 2, 3] => [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
        CollectionUtils.permutations(list);

// 返回两个集合中相同的元素集合 [1, 2, 3]  [2, 3, 4] => [2, 3]
        CollectionUtils.retainAll(list, list1);

// 从集合中删除移除共同的元素并且返回 [1, 2, 3]  [2, 3, 4] => [1]
        CollectionUtils.removeAll(list, list1);

08、StringUtils

StringUtils 封装了字符串的操作，包括不限于以下功能：判空、包含、比较、查找等功能。

下面就是我日常使用 StringUtils 最多的一些 API 示例。

// 字符串为空、空格、空字符串，则返回 true
StringUtils.isBlank("asd");

// 字符串不为空、不为空格、不为空字符串，则返回 true
        StringUtils.isNotBlank("asd");

// 字符串为空、空字符串，则返回 true
        StringUtils.isEmpty("asd");

// 字符串不为空、不为空字符串，则返回 true
        StringUtils.isNotEmpty("asd");

// 字符串是数字组成，则返回 true
        StringUtils.isNumeric("123");

// 字符串没有以指定后缀结尾，则追加一个后缀 100 => 100$
        StringUtils.appendIfMissing("100", "$", "￥","^");

// 移除字符串后面的换行符，"\n"、 "\r"、 "\r\n" 都会被移除
// "abc\n" => "abc"
        StringUtils.chomp("abc\n");

// 字符串是否包含另一个字符 "abc" "a"  => true
        StringUtils.contains("abc", "a");

// 字符串包含给定字符中的任意一个则返回 true
// "assddw" ['a', 'w'] => true
        StringUtils.containsAny("assddw","a","w");

// 字符串不包含给定字符中的任意一个则返回 true
// "abab" "xyz" => true
        StringUtils.containsNone("abz","xyz");

// 字符串只包含给定字符则返回 true
// "abab" 'abc' => true
        StringUtils.containsOnly("abab", 'a', 'b','c');

// 字符串否包含空格则返回 true
// "abc " => true
        StringUtils.containsWhitespace("abc ");

// 删除字符串中的空格
// "a bc " => "abc"
        StringUtils.deleteWhitespace("a bc ");

// 删除字符串中的前后空格 " a bc " => "a bc"
        StringUtils.strip(" a bc ");

// 统计字符串中包含指定字符的个数
// "aabb" 'a' => 2
        StringUtils.countMatches("aabb",'a');

// 比较两个字符串，返回后者字符串没有在前者字符串中出现的字符
// "abc" "abcd" => "d"
        StringUtils.difference("abc","abcd");

// 字符串是否以指定字符串结尾
// "abc" "c" => true
        StringUtils.endsWith("abc","c");

// 字符串是否以指定字符串中的任意一个结尾
// "abc" "c" => true
        StringUtils.endsWithAny("abc","c","d");

// 两个字符串相等则返回 true
// "abc" "abcd" => false
        StringUtils.equals("abc","abcd");

// 字符串跟跟任意一个相等则返回 true
// "abc" ["abc", "abcd"] => true
        StringUtils.equalsAny("abc", "abc", "abcd");

// 反转字符串，返回新的字符串 "abc" => "cba"
        StringUtils.reverse("abc");

// 字符串分割，返回字符串数组 "a,b,c" => ["a", "b", "c"]
        StringUtils.split("a,b,c",",");

// 将字符串的大小写转换 "Abc" => "aBC"
        StringUtils.swapCase("Abc");

09、IOUtils

IOUtils 封装了 IO 的操作，包括不限于以下功能：读取文件内容、写入文件内容、复制等功能。

需要注意一下，IOUtils 并不会关闭 IO 流，因为不知道调用方是否还会使用，防止关闭流出现问题，因此需要调用方手动关闭 IO 流。

下面就是我日常使用 IOUtils 最多的一些 API 示例。

 // 将文件内容读取出来
IOUtils.toString(new FileInputStream("/temp/ws/a.txt"), StandardCharsets.UTF_8);

// 将内容写入文件
        IOUtils.write("IOUtils#write test",new FileOutputStream("/temp/ws/a.txt"),StandardCharsets.UTF_8);

// 文件复制
        IOUtils.copy(new FileInputStream("/temp/ws/a.txt"),new FileOutputStream("/temp/ws/b.txt"));

10、Google 工具类

Google 提供的工具类，包含不限于：guava 依赖，能极大的补充 JDK 工具类没有覆盖到的常用功能。

以下是个人常用的一些工具类：Lists、Maps、Sets等。

其实还有其它的工具类，比如：Queues、SetUtils、MapUtils、ComparatorUtils、ClassUtils等，有兴趣的可以自己进行查看，这里就不介绍了。

11、Lists、Sets、Maps

因为工作中都是用这三个的工程方法来创建对应的实现，偶尔会用到其它的一些方法，因此发一起介绍了

下面就是我日常使用 Lists 最多的一些 API 示例。

// 创建一个空的 ArrayList
Lists.newArrayList();

// 创建一个空的 LinkedList
        Lists.newLinkedList();

// 将集合按照指定大小分区
        Lists.partition(list,3);

// 创建一个 HashMap
        Maps.newHashMap();

// 根据过滤条件过滤 map#key 的映射，返回一个新的 map
// {1=1, 2=2, 3=3, 4=4, 5=5, 6=6} => {1=1, 2=2, 3=3}
        Maps.filterKeys(new HashMap<Integer,Integer>(), key -> key <= 3);

// 根据过滤条件过滤 map#value 的映射，返回一个新的 map
// {1=1, 2=2, 3=3, 4=4, 5=5, 6=6} => {1=1, 2=2, 3=3}
        Maps.filterValues(new HashMap<Integer,Integer>(), value -> value <= 3);

// 创建一个 HashSet
        Sets.newHashSet();

// 获取两个 set 的差集
// [1, 2, 3] [3, 4, 5] => [1, 2]
        Sets.difference(Sets.newHashSet(1, 2, 3), Sets.newHashSet(3, 4, 5));

// 获取两个 set 的笛卡尔积，返回一个新的 set
// [1, 2] [3, 4] => [1, 3], [1, 4], [2, 3], [2, 4]
        Sets.cartesianProduct(Sets.newHashSet(1,2), Sets.newHashSet(3,4));

12、总结

以上就是个人在工作中最常用的工具类了，包括不限于 JDK、Apache、Google 提供的，如果能熟悉已经有的轮子，可以大大的提高效率，比同事早下班 2 个小时不是梦。