ObjectUtil.java

/*
 * File：ObjectUtil.java
 * User：xiaocao000
 * Date：2009-3-14
 */
package com.xiaocao000.lang;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import com.xiaocao000.io.IOStreamUtil;

/**
 * ObjectUtil<br>
 * <ol>
 * <li>isEmpty(); isNotEmpty();
 * <li>toString();
 * <li>equals();
 * <li>clone();
 * </ol>
 * 
 * @author xiaocao000 
 * Date：2009-3-14
 * @version 1.0
 */
public class ObjectUtil
{
    private static final String NULL = "null";
    private static final String EMPTY_STR = "";

    /** 定义toString时忽略的属性名称字符串集合 */
    private static final String[] IGNORE_FIELD_NAMES = {"log", "logger",
            "serialVersionUID", // 实现序列化接口时自动添加的字段
    };

    /** 定义toString时忽略的属性类名字符串集合 */
    private static final String[] IGNORE_FIELD_CLASSES = {
            "org.apache.log4j.Logger",
            "java.util.logging.Logger", // 日志记录器声明的属性
            "java.lang.Object", "java.lang.Class",
            "java.lang.reflect.AccessibleObject", "java.lang.reflect.Field",
            "java.lang.reflect.Method", "java.lang.reflect.Constructor",};

    // =====================================================
    // isNull(); isNotNull();
    // isEmpty(); isNotEmpty();
    // =====================================================
    /**
     * 判断指定的对象是否为null。
     * 
     * @param obj 要判断的对象实例
     * @return true：为null false：非null
     */
    public static boolean isNull(Object obj)
    {
        return obj == null;
    }

    /**
     * 判断指定的对象是否不为null。
     * 
     * @param obj 要判断的对象实例
     * @return true：非null false：为null
     */
    public static boolean isNotNull(Object obj)
    {
        return !isNull(obj);
    }

    /**
     * 判断指定的对象数组是否为空。
     * 
     * @param objs 要判断的对象数组实例
     * @return true：对象数组为空 false：对象数组非空
     */
    public static boolean isEmpty(Object[] objs)
    {
        return isNull(objs) || objs.length == 0;
    }

    /**
     * 判断指定的对象数组是否非空。
     * 
     * @param objs 要判断的对象数组实例
     * @return true：对象数组非空 false：对象数组为空
     */
    public static boolean isNotEmpty(Object[] objs)
    {
        return !isEmpty(objs);
    }

    /**
     * 判断指定的集合类是否为空。<BR>
     * 为空的含义是指：该集合为null，或者该集合不包含任何元素。
     * 
     * @param coll 要判断的集合实例
     * @return true：集合为空 false：集合非空
     */
    public static boolean isEmpty(Collection<?> coll)
    {
        return isNull(coll) || coll.isEmpty();
    }

    /**
     * 判断指定的集合类是否非空。 <BR>
     * 非空的含义是指：该集合非null并且该集合包含元素。
     * 
     * @param coll 要判断的集合实例
     * @return true：集合非空 false：集合为空
     */
    public static boolean isNotEmpty(Collection<?> coll)
    {
        return !isEmpty(coll);
    }

    /**
     * 判断指定的Map类是否为空。 <BR>
     * 为空的含义是指：该Map为null，或者该Map不包含任何元素。
     * 
     * @param map 要判断的Map实例
     * @return true：Map为空 false：Map非空
     */
    public static boolean isEmpty(Map<?, ?> map)
    {
        return isNull(map) || map.isEmpty();
    }

    /**
     * 判断指定的Map类是否非空。<BR>
     * 非空的含义是指：该Map非null并且该Map包含元素。
     * 
     * @param map 要判断的Map实例
     * @return true：Map非空 false：Map为空
     */
    public static boolean isNotEmpty(Map<?, ?> map)
    {
        return !isEmpty(map);
    }

    /**
     * 判断指定的CharSequence类是否为空。 <BR>
     * 为空的含义是指：该CharSequence为null，或者该CharSequence长度为0。<BR>
     * 对String类型，虽然也属于CharSequence，<BR>
     * 但因为通常字符串都有特殊的处理要求，所以使用方法isEmpty(String str);
     * 
     * @param charSeq 要判断的CharSequence实例
     * @return true：CharSequence为空 false：CharSequence非空
     */
    public static boolean isEmpty(CharSequence charSeq)
    {
        return isNull(charSeq) || charSeq.length() == 0;
    }

    /**
     * 判断指定的CharSequence类是否非空。 <BR>
     * 非空的含义是指：该CharSequence非null并且该CharSequence包含元素。<BR>
     * 对String类型，虽然也属于CharSequence， <BR>
     * 但因为通常字符串都有特殊的处理要求，所以使用方法isNotEmpty(String str);
     * 
     * @param charSeq 要判断的CharSequence实例
     * @return true：CharSequence非空 false：CharSequence为空
     */
    public static boolean isNotEmpty(CharSequence charSeq)
    {
        return !isEmpty(charSeq);
    }

    /**
     * 判断指定的String类是否为空。 <BR>
     * 为空的含义是指：该String为null，或者该String为空串""。
     * 
     * @param str 要判断的String实例
     * @return true：String为空 false：String非空
     */
    public static boolean isEmpty(String str)
    {
        return isNull(str) || EMPTY_STR.equals(str);
    }

    /**
     * 判断指定的String类是否非空。 <BR>
     * 非空的含义是指：该String非null并且该String不为空串。
     * 
     * @param str 要判断的String实例
     * @return true：String非空 false：String为空
     */
    public static boolean isNotEmpty(String str)
    {
        return !isEmpty(str);
    }

    /**
     * 判断指定的String类是否为空。<BR>
     * 为空的含义是指：该String为null，或者该String为空串""。
     * 
     * @param str 要判断的String实例
     * @return true：String为空 false：String非空
     */
    public static boolean isTrimEmpty(String str)
    {
        return isNull(str) || EMPTY_STR.equals(str.trim());
    }

    /**
     * 判断指定的String类是否非空。 <BR>
     * 非空的含义是指：该String非null并且该String不为空串。
     * 
     * @param str 要判断的String实例
     * @return true：String非空 false：String为空
     */
    public static boolean isTrimNotEmpty(String str)
    {
        return !isTrimEmpty(str);
    }

    // =============================================================
    // toString()
    // 1. Java 基本型别，包括基本对象型别 直接调用对象本身的toString()
    // 2. 简单的Bean类型 采用反射机制取得每个属性的值
    // 3. Java集合类型 如：Collection，Map以及对象数组
    // 4. 非Java基本型别的对象类型作为属性
    // 5. enum处理：能正确调用object.toString()，归类为Java基本类型
    // 6. 继承关系处理：先取得所有父类，再取得所有属性 递归toString
    // 7. 内部类处理：内部类包含了一个对外部类的默认引用，其名称会包含"this$",忽略即可
    // =============================================================

    /**
     * 通用的toString方法。 <BR>
     * 1. 以对象形式存在的基本型别数组，如：byte[],long[]需要特殊处理。<BR>
     * 
     * @param obj 要转化为字符串的对象
     * @return 转化后的字符串
     */
    public static String toString(Object obj)
    {
        if (isNull(obj))
        {
            return NULL;
        }

        Class<?> clazz = obj.getClass();
        if (clazz.equals(Object.class) || clazz.equals(Class.class))
        {
            return obj.toString();
        }

        // 如果是Java基本型别 可以直接调用toString得到正确的信息
        if (ClassUtil.isJavaBasicType(clazz))
        {
            return obj.toString();
        }

        StringBuilder sb = new StringBuilder();

        // 如果是数组类
        if (clazz.isArray())
        {
            // Java基本型别的数组，可以利用Arrays.toString()完成转化，
            // 这里转为对象数组再用deepToString()，只是为了添加附加信息和减少代码
            if (ClassUtil.isPrimitiveArray(clazz))
            {
                Object[] objs = new Object[] {obj};
                sb.append(clazz.getSimpleName()).append("=");
                String objsStr = Arrays.deepToString(objs);
                sb.append(objsStr.substring(1, objsStr.length() - 1));
                return sb.toString();
            }

            // 基本类型的数组已经处理，这里只可能是对象数组。
            // 将基本型别数组与对象数字分开处理的原因是：
            // 基本型别数组可以利用Arrays.deepToString(Object[] objs)转为String
            // 但对象数组中的对象没有声明toSring 方法时也需要deepToString，
            // Arrays.deepToString方法就无能为力了
            return toString((Object[]) obj);
        }

        // 如果是集合类Collection
        if (Collection.class.isAssignableFrom(clazz))
        {
            return toString((Collection<?>) obj);
        }

        // 如果是映射类Map
        if (Map.class.isAssignableFrom(clazz))
        {
            return toString((Map<?, ?>) obj);
        }

        // 到这里，是Bean类型的对象，反射每个字段toString
        sb.append(clazz.getSimpleName()).append("{");
        Field[] fields = ClassUtil.getAllField(clazz);

        if (fields.length > 0)
        {
            boolean isAppend = false;
            AccessibleObject.setAccessible(fields, true);
            for (Field field : fields)
            {
                // 需要忽略的属性
                if (isIgnoreField(field))
                {
                    continue;
                }
                isAppend = true;
                sb.append(field.getName()).append("=");
                try
                {
                    // 这里如果对每一个属性都调用ObjectUtil.toString()
                    // 对内部类，会造成堆栈溢出，需要解决
                    sb.append(toString(field.get(obj))).append(",");
                }
                catch (Exception e)
                {
                    sb.append("???,");
                }
            }
            if (isAppend)
            {
                sb.deleteCharAt(sb.length() - 1);
            }
        }
        sb.append("}");
        return sb.toString();
    }

    public static <T> void addAll(List<T> list, T[] array)
    {
        if (isNull(list) || isNull(array))
        {
            return;
        }

        for (T t : array)
        {
            list.add(t);
        }
    }

    /**
     * 判断属性字段是否为toString时忽略的字段属性。
     * 
     * @param field 需要判断是否忽略属性的字段。
     * @return true：为忽略属性 false：非忽略属性
     */
    public static boolean isIgnoreField(Field field)
    {
        if (isNull(field))
        {
            return false;
        }

        // 根据名称判断总归比根据类名判断要快
        return isIgnoreFieldByName(field) || isIgnoreFieldByClass(field);
    }

    /**
     * 根据字段的Name判断是否该字段为已定义的忽略属性
     * 
     * @param field 需要判断是否忽略属性的字段。
     * @return true：为忽略属性 false：非忽略属性
     */
    private static boolean isIgnoreFieldByName(Field field)
    {
        // 如果是已定义的需要忽略的属性
        for (String fieldName : IGNORE_FIELD_NAMES)
        {
            if (fieldName.equals(field.getName()))
            {
                return true;
            }
        }

        // 如果是需要模糊匹配需要忽略的属性
        // 说明：如果一个类定义了内部类，内部类保留一个对外部类的默认引用
        // 这会导致递归toString时堆栈溢出，而这个默认引用又不需要toString，所以忽略
        if (field.getName().indexOf("this$") != -1)
        {
            return true;
        }

        return false;
    }

    /**
     * 根据字段的Class判断是否该字段为已定义的忽略属性
     * 
     * @param field 需要判断是否忽略属性的字段。
     * @return true：为忽略属性 false：非忽略属性
     */
    private static boolean isIgnoreFieldByClass(Field field)
    {
        Class<?> clazz = null;
        for (String className : IGNORE_FIELD_CLASSES)
        {
            clazz = ReflectionUtil.forName(className);
            if (clazz != null && clazz.isAssignableFrom(field.getType()))
            {
                return true;
            }
        }

        return false;
    }

    /**
     * 将对象数组转换为String。
     * 
     * @param objs 对象数组
     * @return 转换后的字符串
     */
    public static String toString(Object[] objs)
    {
        if (isNull(objs))
        {
            return NULL;
        }
        if (objs.length == 0)
        {
            return "[]";
        }

        StringBuilder sb = new StringBuilder();
        sb.append(objs.getClass().getSimpleName()).append("(length=").append(
                objs.length).append(")=[");
        for (Object obj : objs)
        {
            sb.append(toString(obj)).append(',');
        }
        sb.deleteCharAt(sb.length() - 1);
        sb.append(']');

        return sb.toString();
    }

    /**
     * 将Collection转换为String。
     * 
     * @param coll Collection
     * @return 转换后的字符串
     */
    public static String toString(Collection<?> coll)
    {
        if (isNull(coll))
        {
            return NULL;
        }
        if (coll.isEmpty())
        {
            return "{}";
        }

        StringBuilder sb = new StringBuilder();
        sb.append(coll.getClass().getSimpleName()).append("(size=").append(
                coll.size()).append(")={");
        for (Object obj : coll)
        {
            sb.append(toString(obj)).append(',');
        }
        sb.deleteCharAt(sb.length() - 1);
        sb.append('}');

        return sb.toString();
    }

    /**
     * 将Map转换为String。
     * 
     * @param map Map
     * @return 转换后的字符串
     */
    public static String toString(Map<?, ?> map)
    {
        if (isNull(map))
        {
            return NULL;
        }
        if (map.isEmpty())
        {
            return "{}";
        }

        StringBuilder sb = new StringBuilder();
        sb.append(map.getClass().getSimpleName());
        sb.append("(size=").append(map.size()).append(")={");
        for (Map.Entry<?, ?> entry : map.entrySet())
        {
            sb.append(toString(entry.getKey())).append('=');
            sb.append(toString(entry.getValue())).append(',');
        }
        sb.deleteCharAt(sb.length() - 1);
        sb.append('}');

        return sb.toString();
    }

    // =============================================================
    // equals()
    // 1. Java 基本型别，包括基本对象型别 直接调用对象本身的equals()
    // 2. 简单的Bean类型 采用反射机制比较每个属性的equals
    // 3. Java集合类型 如：Collection，Map以及对象数组
    // 4. 非Java基本型别的对象类型作为属性如何处理
    // 5. enum类型
    // 6. 内部类如何处理
    // =============================================================

    /**
     * 通用的equals 方法
     * 
     * @param a 对象a
     * @param b 对象b
     * @return true 两个对象值相等 false 两个对象值不相等
     */
    public static boolean equals(Object a, Object b)
    {
        // 如果任何一个对象为null，认为值不等。
        if (isNull(a) || isNull(b))
        {
            return false;
        }

        // 如果是同一个对象，认为值相等。
        if (a == b)
        {
            return true;
        }

        Class<?> aClazz = a.getClass();

        // 如果两个对象不是同一型别，认为值不等。
        if (!aClazz.equals(b.getClass()))
        {
            return false;
        }

        // 以下开始，认为两个对象是相同型别的对象
        // 是Java基本类型的，可以直接equals
        if (ClassUtil.isJavaBasicType(aClazz))
        {
            return a.equals(b);
        }

        // 如果是数组类
        if (aClazz.isArray())
        {
            // Java基本型别的数组，可以利用Arrays.toString()完成转化，
            // 这里转为对象数组再用deepToString()，只是为了添加附加信息和减少代码
            if (ClassUtil.isPrimitiveArray(aClazz)
                    || ClassUtil.isPrimitiveWrapperArray(aClazz))
            {
                return Arrays.deepEquals(new Object[] {a}, new Object[] {b});
            }

            // 基本类型的数组已经处理，这里只可能是对象数组。
            // 将基本型别数组与对象数字分开处理的原因是：
            // 基本型别数组可以利用Arrays.deepEquals()
            // 但对象数组中的对象没有声明equals 方法时也需要deepEquals，
            // Arrays.deepEquals方法就无能为力了
            return equals((Object[]) a, (Object[]) b);
        }

        // 如果是集合类
        if (ClassUtil.isCollection(aClazz))
        {
            return equals((Collection<?>) a, (Collection<?>) b);
        }

        // 如果是映射类
        if (ClassUtil.isMap(aClazz))
        {
            return equals((Map<?, ?>) a, (Map<?, ?>) b);
        }

        // 到这里认为是基本Bean类型，比较每一个属性。
        try
        {
            Field[] fields = aClazz.getDeclaredFields();

            // 没有声明属性
            if (isEmpty(fields))
            {
                return true;
            }

            AccessibleObject.setAccessible(fields, true);
            for (int i = 0; i < fields.length; i++)
            {
                Field field = fields[i];

                if (!equals(field.get(a), field.get(b)))
                {
                    return false;
                }
            }
        }
        catch (Exception e)
        {
            return false;
        }

        return true;
    }

    /**
     * 通用的equals 方法
     * 
     * @param a 对象数组a
     * @param b 对象数组b
     * @return true 两个对象数组值相等 false 两个对象数组值不相等
     */
    public static boolean equals(Object[] a, Object[] b)
    {
        if (isNull(a) || isNull(b))
        {
            return false;
        }

        // 去掉这段代码，不区分对象数组具体类型，只比较值
        if (!a.getClass().equals(b.getClass()))
        {
            return false;
        }

        if (a.length != b.length)
        {
            return false;
        }

        for (int i = 0; i < a.length; i++)
        {
            if (!equals(a[i], b[i]))
            {
                return false;
            }
        }

        return true;
    }

    /**
     * 通用的equals 方法
     * 
     * @param a Collection a
     * @param b Collection b
     * @return true 两个Collection值相等 false 两个Collection值不相等
     */
    public static boolean equals(Collection<?> a, Collection<?> b)
    {
        if (isNull(a) || isNull(b))
        {
            return false;
        }

        // 去掉这段代码，不区分集合具体子类型，只比较值
        if (!a.getClass().equals(b.getClass()))
        {
            return false;
        }

        if (a.size() != b.size())
        {
            return false;
        }

        return equals(a.toArray(), b.toArray());
    }

    /**
     * 通用的equals 方法
     * 
     * @param a Map a
     * @param b Map b
     * @return true 两个Map值相等 false 两个Map值不相等
     */
    public static boolean equals(Map<?, ?> a, Map<?, ?> b)
    {
        if (isNull(a) || isNull(b))
        {
            return false;
        }

        // 去掉这段代码，不区分映射具体子类型，只比较值
        if (!a.getClass().equals(b.getClass()))
        {
            return false;
        }

        if (a.size() != b.size())
        {
            return false;
        }

        for (Map.Entry<?, ?> entry : a.entrySet())
        {
            if (!b.containsKey(entry.getKey())
                    || !equals(entry.getValue(), b.get(entry.getKey())))
            {
                return false;
            }
        }

        return true;
    }

    /**
     * clone方法。需要克隆的对象必须实现Serializable接口
     * 
     * @param obj 需要克隆的对象。
     * @return 克隆的对象。
     */
    public static Object clone(Object obj)
    {
        if (isNull(obj))
        {
            return null;
        }

        Object cloneObj = null;
        if (obj instanceof Serializable)
        {
            ByteArrayOutputStream baos = null;
            ObjectOutputStream oos = null;
            ObjectInputStream ois = null;

            try
            {
                baos = new ByteArrayOutputStream();
                oos = new ObjectOutputStream(baos);
                oos.writeObject(obj);
                ois = new ObjectInputStream(new ByteArrayInputStream(baos
                        .toByteArray()));

                cloneObj = ois.readObject();
            }
            catch (Exception e)
            {
                return cloneObj;
            }
            finally
            {
                IOStreamUtil.closeQuietly(baos);
                IOStreamUtil.closeQuietly(oos);
                IOStreamUtil.closeQuietly(ois);
            }
        }

        return cloneObj;
    }
}