文章目录

• • 一 、开发常用工具类
  • • 1、前言
    • 2、常用工具类（持续更新中...）
    • • 2.1、Pair/Triple 返回多字段数据（commons-lang3）
      • 2.2、 BooleanUtils 判断方法返回的数据值（commons-lang3）
      • 2.3、NumberUtils工具类判断数字相关问题（commons-lang3）
      • 2.4、Objects 工具类使用（java.util）
      • 2.5、CollectionUtils 的集合操作（commons-collections4）
      • 2.6、Lists工具类使用（guava包）
    • 3、依赖的jar文件
    • 4、使用方式举例

一 、开发常用工具类

1、前言

简单介绍common-lang3/guava下的工具类的使用，减少代码臃肿，提高开发效率

2、常用工具类（持续更新中…）

2.1、Pair/Triple 返回多字段数据（commons-lang3）

2.2、 BooleanUtils 判断方法返回的数据值（commons-lang3）

2.3、NumberUtils工具类判断数字相关问题（commons-lang3）

2.4、Objects 工具类使用（java.util）

2.5、CollectionUtils 的集合操作（commons-collections4）

2.6、Lists工具类使用（guava包）

3、依赖的jar文件

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.11</version>
        </dependency>

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>24.1-jre</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.3</version>
        </dependency>

4、使用方式举例

package com.matcha.utils;

import com.google.common.collect.Lists;
import lombok.Data;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.commons.lang3.tuple.Triple;
import org.junit.Test;

import java.util.*;

/**
 * @Description: 常见工具类的使用
 * @Author: 杨同宽
 * @Date: 2021/11/28
 */
public class TestCommonUtil {
    /**
     * commons-lang3包下
     * 1. Pair/Triple 工具类型使用
     */
    @Test
    public void testPair() {
        /**
         * Pair<R,T> 双参数 一般用户方法返回两个参数时 使用
         */
        Pair<Boolean, String> pair = Pair.of(true, "信息");
        final Boolean left = pair.getLeft();
        final String right = pair.getRight();
        System.out.println(" pair-->left--->" + left);
        System.out.println(" pair-->right--->" + right);
        /**
         * Triple<L,M,R> 返回三个参数  一般用户方法返回三个参数时使用
         */
        Triple<Boolean, String, String> triple = Triple.of(true, "中间", "尾部");
        System.out.println(" triple-->left--->" + triple.getLeft());
        System.out.println(" triple-->middle--->" + triple.getMiddle());
        System.out.println(" triple-->right--->" + triple.getRight());
    }

    /**
     * commons-lang3包下
     * 使用BooleanUtils 判断方法返回的数据值
     */
    @Test
    public void testBoolean() {
        /**
         * BooleanUtils 常用方法
         * isTrue(Boolean bool) 是否为true   false/null 均为 false
         * isNotTrue(Boolean bool) 是否不为true  !isTrue(Boolean bool)  false/null 均返回true
         * isFalse(Boolean bool) 是否为false  true/null 均返回false
         * isNotFalse(Boolean bool) 是否不为false !isFalse(Boolean bool) true/null 均返回true
         *
         */
        /**
         * 当方法返回boolean的包装类型时  需要判断空  如果方法判断是否返回为tru判断时可使用
         */
        Boolean judgeIsNewUser = judgeIsNewUser();
        // 原来判断
        if (judgeIsNewUser != null && judgeIsNewUser) {
            // 执行逻辑
        }
        // 等价于工具类
        if (BooleanUtils.isTrue(judgeIsNewUser)) {
            // 执行逻辑
        }
    }

    /**
     * 判断是否是新用户
     *
     * @return Boolean 判断值
     */
    private Boolean judgeIsNewUser() {
        return null;
    }

    /**
     * guava报下
     * Lists工具类使用
     */
    @Test
    public void testLists() {
        Set<String> set = new HashSet<String>();
        set.add("张三");
        set.add("李四");
        set.add("王五");
        // list 转set
        List<String> list = Lists.newArrayList(set);
        // 方法返回空集合对象
        List<String> arrayList = Lists.newArrayList();
        // 创建指定容量大小的集合
        List<String> arrayList1 = Lists.newArrayListWithCapacity(10);
        // 集合按照指定大小分片
        List<List<String>> subList = Lists.partition(list, 1);
        subList.forEach(System.out::println);
        // 将集合倒叙生成新的集合
        List<List<String>> reverseList = Lists.reverse(subList);
        System.out.println("reverseList---->" + reverseList);
        // 对象的集合转为另一个对象的集合
        List<DemoEntity> demoEntityList = Arrays.asList(new DemoEntity("张三", 10),
                new DemoEntity("李四", 10),
                new DemoEntity("王五", 10),
                new DemoEntity("马六", 10)
        );
        List<DemoVO> transformList = Lists.transform(demoEntityList, (x) -> {
            DemoVO demoVO = new DemoVO();
            demoVO.setName(x.getName());
            return demoVO;
        });
        System.out.println("transformList----->" + transformList);
    }

    @Data
    class DemoEntity {
        private String name;
        private Integer age;

        public DemoEntity(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    }

    @Data
    class DemoVO {
        private String name;

        public DemoVO() {
        }

        public DemoVO(String name) {
            this.name = name;
        }
    }

    /**
     * commons-lang3 工具包下
     * NumberUtils工具类的使用
     */
    @Test
    public void testNumberUtils() {
        /**
         * 1. NumberUtils.toInt(String str) 将字符创转为数字 若转化异常  则返回 0
         * 2. NumberUtils.toInt(final String str, final int defaultValue) 将字符创转为数字 转换不成功则使用默认值
         * 3. toLong(final String str)
         * 4. toLong(final String str, final long defaultValue)
         * 5. toFloat(final String str)
         * 6. toDouble(final String str)
         * 7. toScaledBigDecimal(final BigDecimal value)
         * 8. boolean isParsable(final String str) 判断是否可转为数字类型
         * 9. boolean isDigits(final String str) 判断字符创是否为纯数字
         * ...
         */
        int toInt = NumberUtils.toInt("a");
        int toInt1 = NumberUtils.toInt("10.0", 0);
        System.out.println("toInt--->" + toInt);
        System.out.println("toInt1--->" + toInt1);
        // 判断字符串是否可转为数字
        final boolean judgeIsNumber = NumberUtils.isParsable("12");
        // 判断是否全为数字 如包含符号 . 等均返回false
        final boolean digits = NumberUtils.isDigits("123 ");
        System.out.println("judgeIsNumber--->" + judgeIsNumber);
        System.out.println("digits--->" + digits);
    }

    /**
     * java.util包下
     * Objects 工具类使用
     */
    @Test
    public void testObjects() {
        /** Objects
         * 1. String toString(Object o, String nullDefault) 将对象转换为字符串  如果对象为null 则返回默认值
         * 2. boolean equals(Object a, Object b)  判断两个对象是否相等
         * 3.  boolean isNull(Object obj)  判断对象是否为null
         *    boolean nonNull(Object obj)  判断对象是否不为null
         */
        // 1. 对象转string
        final DemoVO vo = new DemoVO();
        System.out.println(Objects.toString(vo, ""));
        // 2. 判断两个对象是否相等 Objects.equals(x,y)
        System.out.println("判断两个对象是否相等---->" + Objects.equals(new DemoVO("1"), new DemoVO("1")));
        // 3. 判断对象是否为null
        Object obj = null;
        System.out.println("判断对象是否为null--->" + Objects.isNull(obj));
        System.out.println("判断对象是否不为null--->" + Objects.nonNull(obj));
    }

    /**
     * commons-collections4 jar 下
     * CollectionUtils 的工具类使用
     */
    @Test
    public void testCollectionUtils() {
        /**
         * 1.  boolean isEmpty(Collection<?> coll) 判断集合是否为空
         * 2. boolean isNotEmpty(Collection<?> coll) 判断集合是否不为空
         * 3. Collection<T> emptyIfNull(Collection<T> collection) 判断集合是否为null  如果为null 则返回空集合 单不可进行增删操作
         * 4. Collection<O> intersection(Iterable<? extends O> a, Iterable<? extends O> b) 集合的交集
         * 5. Collection<O> union(Iterable<? extends O> a, Iterable<? extends O> b)  集合的并集
         * 6. Collection<O> subtract(Iterable<? extends O> a, Iterable<? extends O> b)  集合的差集 集合相减
         * 7. Collection<O> disjunction(Iterable<? extends O> a, Iterable<? extends O> b) 差集的补集
         * 8. boolean containsAll(Collection<?> coll1, Collection<?> coll2) 集合1元素是否全部包含集合2元素
         * 9. boolean containsAny(Collection<?> coll1, Collection<?> coll2) 集合1部分是否包含集合2部分
         */
        final boolean empty1 = CollectionUtils.isEmpty(null);
        final boolean empty = CollectionUtils.isNotEmpty(null);
        // 3. 判断集合是否为null 并返回集合
        final Collection<Object> emptyIfNullList = CollectionUtils.emptyIfNull(null);
        // 4. 获取两个集合的交集 元集合数据不变 以字符创为例 对象对比需重写哈希code 与 equals方法
        List<String> list1 = Arrays.asList("张三", "李四", "王五", "马六");
        List<String> list2 = Arrays.asList("张三", "李四", "王五", "田七");
        Collection<String> intersectionList = CollectionUtils.intersection(list1, list2);
        System.out.println("交集---->" + intersectionList);
        System.out.println("并集---->" + CollectionUtils.union(list1, list2));
        System.out.println("差集---->" + CollectionUtils.subtract(list1, list2));
        System.out.println("交集的补集---->" + CollectionUtils.disjunction(list1, list2));
        // 8. 判断集合包含关系
        System.out.println("集合1是否全部包含集合2---->" + CollectionUtils.containsAll(list1, list2));
        System.out.println("集合1部分是否包含集合2部分---->" + CollectionUtils.containsAny(list1, list2));
    }
}