apache commons lang

一、引入Maven依赖

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

二、常用API说明

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.ClassUtils;
import org.apache.commons.lang.RandomStringUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.ClassPathUtils;
import org.apache.commons.lang3.EnumUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.RandomUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.SystemUtils;
import org.springframework.util.SerializationUtils;

/**
 * Lang Java基本对象方法的工具类包 如：StringUtils,ArrayUtils等等.
 * ArrayUtils 数组工具类
 * StringUtils 字符串操作类
 * BooleanUtils 布尔值工具类
 * ClassPathUtils 类、接口等的路径操作类
 * EnumUtils 枚举操作类
 * ObjectUtils 对象操作类，如是否为空
 * RandomUtils 随机数操作类
 * SystemUtils 系统公共工具类
 * RandomStringUtils 随机字符串操作类
 * AnnotationUtils 注解操作类，如获取注解，注解上的值
 * ThreadUtils 线程工具类, 如查找指定的线程
 * ClassUtils 类工具类
 * SerializationUtils 序列化工具类
 */
public class LangDemo {

    /**
     * @MethodName testSerializationUtils
     * @Description 序列化工具类
     */
    private static void testSerializationUtils() {
        Map<String, String> map = new HashMap();
        map.put("及时雨", "宋江");
        // 序列化对象
        byte[] serializeByteArr = SerializationUtils.serialize(map);
        // 反序列化对象
        Map<String, String> deserializeMap = (Map<String, String>) SerializationUtils.deserialize(serializeByteArr);
        System.out.println(deserializeMap.get("及时雨"));
    }

    /**
     * @MethodName testClassUtils
     * @Description 类工具类
     */
    private static void testClassUtils() {
        try {
            // 获取指定类的所有接口
            List<String> allInterfaces = ClassUtils.getAllInterfaces(HashMap.class);
            System.out.println(allInterfaces);
            // 根据全路径名获取Class对象
            Class LangDemo = ClassUtils.getClass("com.appst.mhdapachecommonsdemo.apac.LangDemo");
            System.out.println(LangDemo);

            // 获取包路径：com.appst.mhdapachecommonsdemo.apac
            String canonicalName = ClassUtils.getPackageCanonicalName(LangDemo.class);
            System.out.println("getPackageCanonicalName：" + canonicalName);
            String packageName = ClassUtils.getPackageName(LangDemo.class);
            System.out.println("getPackageName：" + packageName);

        } catch (Exception e) {
            System.out.println("ClassUtils 异常");
            e.printStackTrace();
        }

    }

    /**
     * @MethodName testSystemUtils
     * @Description 系统工具类
     */
    private static void testSystemUtils() {
        System.out.println("返回系统编码：" + SystemUtils.FILE_ENCODING);
        // IS_JAVA_1_1、...、IS_JAVA_1_8、IS_JAVA_10、IS_JAVA_9 判断java版本,返回一个boolean
        System.out.println("判断JDK版本：" + SystemUtils.IS_JAVA_1_1);

        System.out.println("判断系统是否是linux：" + SystemUtils.IS_OS_LINUX);
        System.out.println("判断系统是否是mac：" + SystemUtils.IS_OS_MAC);
        //IS_OS_WINDOWS、IS_OS_WINDOWS_10、 IS_OS_WINDOWS_2000、IS_OS_WINDOWS_2003、IS_OS_WINDOWS_2008、IS_OS_WINDOWS_7、 IS_OS_WINDOWS_8、 IS_OS_WINDOWS_95、 IS_OS_WINDOWS_98、 IS_OS_WINDOWS_XP 判断系统是否是windows,返回一个boolean
        System.out.println("判断系统是否是windows：" + SystemUtils.IS_OS_WINDOWS_10);

        System.out.println("返回系统CLASS_PATH值:" + SystemUtils.JAVA_CLASS_PATH);
        System.out.println("返回系统java版本:" + SystemUtils.JAVA_CLASS_VERSION);
        System.out.println("返回系统java home:" + SystemUtils.JAVA_HOME);
        System.out.println("返回java运行版本:" + SystemUtils.JAVA_RUNTIME_VERSION);
        System.out.println("返回java版本:" + SystemUtils.JAVA_VERSION);
        System.out.println("返回系统名:" + SystemUtils.OS_NAME);
        System.out.println("返回系统版本:" + SystemUtils.OS_VERSION);
        System.out.println("返回用户国家编号:" + SystemUtils.USER_COUNTRY);
        System.out.println("返回项目文件夹:" + SystemUtils.USER_DIR);
        System.out.println("返回系统用户主文件夹:" + SystemUtils.USER_HOME);
        System.out.println("返回系统用户语言:" + SystemUtils.USER_LANGUAGE);
        System.out.println("返回系统用户名:" + SystemUtils.USER_NAME);
        // "\n" on Unix
        System.out.println("返回系统换行符 :" + System.getProperty("line.separator"));
        // "/" on Unix
        System.out.println("返回系统路径符号:" + System.getProperty("file.separator"));
        // ":" on Unix
        System.out.println("返回逗号:" + System.getProperty("path.separator"));
    }

    /**
     * @param
     * @MethodName testRandomStringUtils
     * @Description 随机字符串工具类
     * @Return void
     * @Throw
     */
    private static void testRandomStringUtils() {
        /*
         * count 创建一个随机字符串，其长度是指定的字符数,字符将从参数的字母数字字符集中选择，如参数所示。
         * letters true,生成的字符串可以包括字母字符
         * numbers true,生成的字符串可以包含数字字符
         */
        String random = RandomStringUtils.random(15, true, false);
        System.out.println(random);

        /*
         * 创建一个随机字符串，其长度是指定的字符数。
         * 将从所有字符集中选择字符
         */
        random = RandomStringUtils.random(22);
        System.out.println(random);

        /*
         * 创建一个随机字符串，其长度是指定的字符数。
         * 字符将从字符串指定的字符集中选择，不能为空。如果NULL，则使用所有字符集。
         */
        random = RandomStringUtils.random(15, "abcdefgABCDEFG123456789");
        System.out.println(random);


        /*
         * 创建一个随机字符串，其长度是指定的字符数,字符将从参数的字母数字字符集中选择，如参数所示。
         * count:计算创建的随机字符长度
         * start:字符集在开始时的位置
         * end:字符集在结束前的位置，必须大于65
         * letters true,生成的字符串可以包括字母字符
         * numbers true,生成的字符串可以包含数字字符
         */
        random = RandomStringUtils.random(1009, 5, 129, true, true);


        /*
         * 产生一个长度为指定的随机字符串的字符数，字符将从拉丁字母（a-z、A-Z的选择）。
         * count:创建随机字符串的长度
         */
        random = RandomStringUtils.randomAlphabetic(15);

        /**
         * 创建一个随机字符串，其长度是指定的字符数，字符将从拉丁字母（a-z、A-Z）和数字0-9中选择。
         * count ：创建的随机数长度
         */
        random = RandomStringUtils.randomAlphanumeric(15);

        /*
         * 创建一个随机字符串，其长度是指定的字符数，字符将从ASCII值介于32到126之间的字符集中选择（包括）
         * count:随机字符串的长度
         */
        random = RandomStringUtils.randomAscii(15);

        /*
         * 创建一个随机字符串，其长度是指定的字符数，将从数字字符集中选择字符。
         * count:生成随机数的长度
         */
        random = RandomStringUtils.randomNumeric(15);
    }

    /**
     * @param
     * @MethodName testRandomUtils
     * @Description 随机数值工具类
     * @Return void
     * @Throw
     */
    private static void testRandomUtils() {
        System.out.println("返回一个随机boolean值：" + RandomUtils.nextBoolean());
        System.out.println("返回一个随机double值：" + RandomUtils.nextDouble());
        System.out.println("返回一个指定范围的随机double值：" + RandomUtils.nextDouble(1.21d, 22.2d));
        System.out.println("返回一个随机float值：" + RandomUtils.nextFloat());
        System.out.println("返回一个指定范围的随机float值：" + RandomUtils.nextFloat(1.21f, 22.2f));
        System.out.println("返回一个随机int值：" + RandomUtils.nextInt());
        System.out.println("返回一个指定范围的随机int值：" + RandomUtils.nextInt(50, 100));
        System.out.println("返回一个随机long值：" + RandomUtils.nextLong());
        System.out.println("返回一个指定范围的随机long值：" + RandomUtils.nextLong(10L, 30L));
        // 返回一个指定大小的随机byte数组
        RandomUtils.nextBytes(5);

    }

    /**
     * @param
     * @MethodName testObjectUtils
     * @Description 对象操作类
     * @Return void
     * @Throw
     */
    private static void testObjectUtils() {
        //判断一个或多个元素不为空
        boolean no1 = ObjectUtils.allNotNull(null, new Object());
        //至少有一个元素不为空
        boolean no2 = ObjectUtils.anyNotNull(null, new Object(), null);
        //调用的是类的clone方法，如果是集合，会把集合的下一层拷贝一份（一层深层拷贝）
        Object object1 = ObjectUtils.clone(new Object());
        //返回一个不为Null的对象
        ObjectUtils.firstNonNull(null, null, new Object());
        // 是否不为空（null及元素个数为0）
        ObjectUtils.isNotEmpty(null);
    }

    /**
     * @param
     * @MethodName testEnumUtils
     * @Description 枚举操作类
     * @Return void
     * @Throw
     */
    enum TestEnum {
        BAIDU, TENGXUN, ALIYUN;
    }

    private static void testEnumUtils() {
        //通过字符串获取对应枚举类型（gson也有这功能）
        TestEnum testEnum = EnumUtils.getEnum(TestEnum.class, "BAIDU");
        System.out.println("getEnum：" + testEnum);
        List<TestEnum> testEnums = EnumUtils.getEnumList(TestEnum.class);
        //字符串是否在枚举中
        boolean isHave = EnumUtils.isValidEnum(TestEnum.class, "BAIDU");
        System.out.println("isValidEnum：" + isHave);
    }

    /**
     * @param
     * @MethodName testClassPathUtils
     * @Description ClassPathUtils 类、接口等的路径操作类
     * @Return void
     * @Throw
     */
    private static void testClassPathUtils() {
        //获取指定类路径,com.appst.mhdapachecommonsdemo.apac.LangDemo
        String path = ClassPathUtils.toFullyQualifiedName(LangDemo.class, "LangDemo");
        System.out.println("toFullyQualifiedName：" + path);

        //com/appst/mhdapachecommonsdemo/apac/LangDemo
        String path2 = ClassPathUtils.toFullyQualifiedPath(LangDemo.class, "LangDemo");
        System.out.println("toFullyQualifiedPath：" + path2);
    }

    /**
     * @param
     * @MethodName testBooleanUtils
     * @Description BooleanUtils 布尔值工具类
     * @Return void
     * @Throw
     */
    private static void testBooleanUtils() {
        //判断是否都是true
        Boolean[] andArr = new Boolean[]{true, true, false};
        boolean isTrue = BooleanUtils.and(andArr);

        //判断是不是有一个true
        Boolean[] orArr = new Boolean[]{false, true, false};
        boolean isOr = BooleanUtils.or(orArr);

        //是否是true和false都有
        Boolean[] xorArr = new Boolean[]{true, false};
        boolean isXor = BooleanUtils.xor(xorArr);
    }


    /**
     * @param
     * @MethodName testArrayUtils
     * @Description ArrayUtils 数组工具类
     * @Return void
     * @Throw
     */
    private static void testArrayUtils() {
        int[] array = new int[]{1, 2};
        //给数组添加一个新元素，返回新集合
        int[] array2 = ArrayUtils.add(array, 3);
        //合并数组，其中可以是null,如果只有一个数组相当于copy
        int[] array3 = ArrayUtils.addAll(array, array2);
        int[] array4 = ArrayUtils.clone(array);
        boolean isHave = ArrayUtils.contains(array, 1);
        int code = ArrayUtils.hashCode(array);
        //从array的第二个位置开始插入array4的值
        int[] array5 = ArrayUtils.insert(2, array, array4);
        //isEmpty判断是否是null或者长度0，isNotEmpty只是判断长度是不是0
        ArrayUtils.isEmpty(array);
        ArrayUtils.isNotEmpty(array);
        //判断长度是否一样，null的长度也是0
        ArrayUtils.isSameLength(array, array5);
        //设置数组中null元素为[]
        ArrayUtils.nullToEmpty(array5);

        //同上add
        //ArrayUtils.remove();
        //ArrayUtils.removeAll();
        //反转数组，反转数组指定区间值
        ArrayUtils.reverse(array5);
        ArrayUtils.reverse(array5, 2, 3);
        //打乱顺序
        ArrayUtils.shuffle(array5);
        //截取数组
        ArrayUtils.subarray(array5, 2, 3);
        //指定位置交换数据
        ArrayUtils.swap(array5, 2, 3);
        //创建新数组
        String[] strArray = ArrayUtils.toArray("大", "小");
        //对象数据类型转换为基本数据类型
        Integer[] arrat7 = new Integer[]{5, 6, 7, 8};
        int[] array6 = ArrayUtils.toPrimitive(arrat7);
        //转换成字符串
        String str = ArrayUtils.toString(arrat7);
    }


    /**
     * @param
     * @MethodName testStringUtils
     * @Description StringUtils 字符串操作类
     * @Return void
     * @Throw
     */
    private static void testStringUtils() {
        //2只显示6个长的的字符串，多的用省略号
        String str1 = StringUtils.abbreviate("abcdefg", 6);
        //显示5个长度的字符串，除了最后一个中间用设置的符号代替
        String str2 = StringUtils.abbreviateMiddle("abcdefgmmssmm", "--", 5);
        //拼接字符串，但是str的结尾不能和def重合
        StringUtils.appendIfMissing("abc", "def");
        //设置字符串长的，不足在两边用指定字符填充
        StringUtils.center("hy", 8, "*");
        //检测字符串abcde中是否含有abc
        StringUtils.contains("abcde", "abc");
        //检测字符串abcdef中是否保护abm或者y
        StringUtils.containsAny("abcdef", "abm", "y");
        //为null或者空字符串返回空字符串,有其他字符，返回字符
        String str3 = StringUtils.defaultString(null);
        //检测字符以什么结尾
        StringUtils.endsWith("agffsww", "sww");
        StringUtils.equals("aaa", "bbb");
        //检测为空
        StringUtils.isEmpty("");
        //把数组以固定字符连接，组成字符串char、double、float、int、long、short、object、T同理
        String str5 = StringUtils.join(new String[]{"a", "b", "c", "d"}, ":");
        //把字符串的重复此时控制在指定大小
        StringUtils.repeat("sss", 2);
        //替换所有b为*
        StringUtils.replace("abcd", "b", "*");
        StringUtils.reverse("abcd");
    }


    public static void main(String[] args) {
        //LangDemo.testStringUtils();
        //LangDemo.testClassPathUtils();
        //LangDemo.testEnumUtils();
        //LangDemo.testSystemUtils();
        LangDemo.testClassUtils();
    }
}