ObjectUtils.java

package com.ces.common.utils;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * 对象的一些判断操作的工具类。
 *
 */
public class ObjectUtils{

    /**
     * List非空判断。 包含了null与empty的判断。
     * 
     * @param list
     * @return
     */
    public static boolean isNotEmpty(List<?> list) {

        return list != null && !list.isEmpty();
    }

    /**
     * List为空判断。 包含了null与empty的判断。
     * 
     * @param list
     * @return
     */
    public static boolean isEmpty(List<?> list) {

        return list == null || list.isEmpty();
    }

    /**
     * Map非空判断。 包含了null与empty的判断。
     * 
     * @param map
     * @return
     */
    public static boolean isNotEmpty(Map<?, ?> map) {

        return map != null && !map.isEmpty();
    }

    /**
     * Map为空判断。 包含了null与empty的判断。
     * 
     * @param map
     * @return
     */
    public static boolean isEmpty(Map<?, ?> map) {

        return map == null || map.isEmpty();
    }

    /**
     * Object[]非空判断。 包含了null与length的判断。
     * 
     * @param objs
     * @return
     */
    public static boolean isNotEmpty(Object[] objs) {

        return objs != null && objs.length != 0;
    }

    /**
     * Object[]为空判断。 包含了null与length的判断。
     * 
     * @param objs
     * @return
     */
    public static boolean isEmpty(Object[] objs) {

        return objs == null || objs.length == 0;
    }

    /**
     * 字符串非空判断。 包含了null和去除字符串首尾空格后的判断。
     * 
     * @param str
     * @return
     */
    public static boolean isNotBlank(String str) {

        return str != null && !"".equals(str.trim());
    }

    /**
     * 字符串非空判断。 包含了null、去除字符串首尾空格后的空串和"null"的判断。
     * 
     * @param str
     * @return
     */
    public static boolean isNotBlankAndStrNull(String str) {

        if (str != null) {
            str = str.trim();
            return !"".equals(str) && !"null".equals(str);
        }
        return false;
    }

    /**
     * 字符串空判断。 包含了null、去除字符串首尾空格后的空串和"null"的判断。
     * 
     * @param str
     * @return
     */
    public static boolean isBlankAndStrNull(String str) {

        if (str == null) {
            return true;
        } else {
            str = str.trim();
            return "".equals(str) || "null".equals(str);
        }
    }

    /**
     * 字符串为空判断。 包含了null和去除字符串首尾空格后的空串判断。
     * 
     * @param str
     * @return
     */
    public static boolean isBlank(String str) {

        return str == null || "".equals(str.trim());
    }

    /**
     * 判断参数为0或0.0，包含参数为null的情况，返回也为true。
     * 
     * @param num
     * @return
     */
    public static boolean isNullOrZero(Number num) {

        return num == null || (num.longValue() == 0 && num.doubleValue() == 0);
    }

    /**
     * 判断参数不为0、0.0和null。
     * 
     * @param num
     * @return
     */
    public static boolean isNotNullOrZero(Number num) {

        return num != null && (num.longValue() != 0 || num.doubleValue() != 0);
    }

    /**
     * 判断obj是否为null，如果为null 返回空串，否则传入对象toString方法后的结果。
     * 
     * @param obj
     * @return
     */
    public static String toString(Object obj) {

        return obj == null ? "" : obj.toString();
    }

    /**
     * 判断是否为正整数，且不等于0
     * 
     * @param str
     * @return
     */
    public static boolean isPositiveNum(String str) {

        if (ObjectUtils.isNotBlank(str) && !"0".equals(str)) {
            Pattern pattern = Pattern.compile("[\\d]*$");
            return pattern.matcher(str).matches();
        }
        return false;
    }

    /**
     * 计算map初始化容量，用于优化map的速度和节约空间
     * 
     * @param elemNum
     *            需要存储的元素个数
     * @return
     */
    public static int calcMapInitCapacity(int elemNum) {
        int n = elemNum - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return ((n < 0) ? 1 : n + 1);
    }

    /**
     * 关闭流。
     * 
     * @param closeable
     */
    public static void closeQuietly(AutoCloseable closeable) {
        try {
            if (closeable != null) {
                closeable.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 对象转换为byte数组。
     * 
     * @param obj
     * @return
     */
    public static byte[] toByteArray(Object obj) {

        byte[] bytes = null;

        try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos)) {

            oos.writeObject(obj);
            bytes = bos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return bytes;
    }

    /**
     * byte数组转换为对象。
     *
     * @param bytes
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T toObject(byte[] bytes, Class<T> clazz) {

        T obj = null;

        try (ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bis)) {

            obj = clazz.cast(ois.readObject());
        } catch (Exception e) {
            e.printStackTrace();
        }

        return obj;
    }

    /**
     * 深拷贝对象。
     *
     * @param obj
     * @param <T>
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T cloneObject(T obj) {

        try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos)) {

            oos.writeObject(obj);

            try (ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
                ObjectInputStream ois = new ObjectInputStream(bis)) {

                return (T)ois.readObject();
            } catch (Exception e) {
                e.printStackTrace();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 合并多个list
     * 
     * @param <T>
     * @param lists
     * @return
     */
    @SafeVarargs
    public static <T> List<T> mergeList(List<? extends T>... lists) {
        List<T> list = new ArrayList<>();
        for (List<? extends T> item : lists) {
            if (item != null) {
                list.addAll(item);
            }
        }
        return list;
    }

    /**
     * from hutool
     * 
     * 合并多个数组
     * 
     * @param <T>
     * @param arrays
     * @return
     */
    @SuppressWarnings("unchecked")
    @SafeVarargs
    public static <T> T[] mergeArray(T[]... arrays) {

        if (arrays.length == 1) {
            return arrays[0];
        }

        int length = 0;
        for (T[] array : arrays) {
            if (null != array) {
                length += array.length;
            }
        }

        T[] result = (T[])Array.newInstance(arrays.getClass().getComponentType().getComponentType(), length);

        length = 0;
        for (T[] array : arrays) {
            if (null != array) {
                System.arraycopy(array, 0, result, length, array.length);
                length += array.length;
            }
        }
        return result;
    }

    /**
     * 判断段文字在文本中出现的次数
     * 
     * @param words
     *            文字
     * @param text
     *            文本内容
     * @return
     */
    public static int keywordCount(String words, String text) {

        if (ObjectUtils.isNotBlank(words) && ObjectUtils.isNotBlank(text)) {
            int oriLength = text.length();
            text = text.replace(words, "");
            int newLength = text.length();
            return (oriLength - newLength) / words.length();
        }
        return 0;
    }
}