// 比较两个对象是否相同
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 个小时不是梦。

欢迎加入我的知识星球，一起探讨架构，交流源码。加入方式，长按下方二维码噢：

已在知识星球更新源码解析如下：

最近更新《芋道 SpringBoot 2.X 入门》系列，已经 101 余篇，覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例，以及超 4W 行代码的电商微服务项目。

获取方式：点“在看”，关注公众号并回复 666 领取，更多内容陆续奉上。

文章有帮助的话，在看，转发吧。
谢谢支持哟 (*^__^*）

标签

#字符串 #分布式 #java #python #大数据

原文链接：https://mp.weixin.qq.com/s?__biz=MzUzMTA2NTU2Ng==&mid=2247547367&idx=2&sn=97f912c5f81d190a255971eee7e73ee0&chksm=fa4a4656cd3dcf4077cfee07d1be6eed7b40cc7502d05870ac163d3e5f7a4c6859267e13a4fe&scene=126&&sessionid=0>

半导体关键系统之RMS浅谈这种系统还要求设备在设备上的配方发生变化时通知工厂主机，并需要与EAP（Equipment Automation Process）联结，旨在实时管控自动化系统所用配方与用户当初的设定是否匹配，从而使得自动化系统所用的配方更加趋于安全。例如，制药行业中的药品生产管理系统（GMP），它对药品的生产过程进行严格控制，包括原材料的采购、生产工艺流程、质量控制等方面。这些系统通常与企业的生产系统集成，能够对产品的配方进行精细化管理，包括配方的设计、试验、验证、生产等环节。阅读详情

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

相关推荐