Java对象克隆方法（浅克隆、深克隆）

浅克隆：顾名思义就是很表面的很表层的克隆，比如我们要克隆User对象，浅克隆只克隆他自身以及他包含的所有对象的引用地址。
深克隆：就是非浅克隆。克隆除自身以外所有的对象，包括自身所包含的所有对象实例。至于深克隆的层次，由具体的需求决定，也有“N层克隆”一说。

浅克隆：
1、使用Cloneable接口实现，步骤如下：
a. 让该类实现Java.lang.Cloneable接口；
b. 重写（override）Object类的clone()方法。

深克隆：
方法1：通过Cloneable接口实现，但这里必须类中所有的非基本类型域都实现Cloneable接口，才能实现深克隆，所以此方法不通用
方法2：通过串行化方式实现（克隆对象必须实现Serializable接口）
把对象写到流里的过程是串行化（Serilization）过程，但是在Java程序师圈子里又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做 “解冻”或者“回鲜(depicking)”过程。
应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。
在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public abstract class BeanUtil {
    @SuppressWarnings("unchecked")
    public static <T> T cloneTo(T src) throws RuntimeException {
        ByteArrayOutputStream memoryBuffer = new ByteArrayOutputStream();
        ObjectOutputStream out = null;
        ObjectInputStream in = null;
        T dist = null;
        try {
            out = new ObjectOutputStream(memoryBuffer);
            out.writeObject(src);
            out.flush();
            in = new ObjectInputStream(new         ByteArrayInputStream(memoryBuffer.toByteArray()));
            dist = (T) in.readObject();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            if (out != null)
                try {
                    out.close();
                    out = null;
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            if (in != null)
                try {
                    in.close();
                    in = null;
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
        }
        return dist;
    }
}

方法3：通过反射的方式实现（克隆对象必须是可序列化的）
即依次遍历克隆对象中的所有域，直至全部域均为基本类型为止

package com.example.xiaowang.clonetest;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by xiaowang on 17/3/9.
 */

public class CloneUtil {

    /**
     * 返回对象的所以属性 包括继承至父类的属性
     *
     * @param o
     * @return
     */
    private static List<Field> getAllFieads(Object o) {
        List<Field> fields = new ArrayList<Field>();
        if (null == o) {
            return fields;
        }
        Class<?> type = o.getClass();
        do {
            for (Field f : type.getDeclaredFields()) {
                fields.add(f);
            }
            type = type.getSuperclass();
        } while (null != type);

        return fields;
    }


    /**
     * 基于效率的考虑不需要进行深度复制的类型：包括基本类型和包装类
     *
     * @param o
     * @return
     */
    public static boolean isSimpleObject(Object o) {
        Class<?> type = o.getClass();
        if (type.isPrimitive()) { // 基本类型
            return true;
        }
        // 不可更改的变量类型 如 String，Long
        if (type.equals(String.class)) {
            return true;
        }
        if (type.equals(Long.class)) {
            return true;
        }
        if (type.equals(Boolean.class)) {
            return true;
        }
        if (type.equals(Short.class)) {
            return true;
        }
        if (type.equals(Integer.class)) {
            return true;
        }
        if (type.equals(Character.class)) {
            return true;
        }
        if (type.equals(Float.class)) {
            return true;
        }
        if (type.equals(Double.class)) {
            return true;
        }
        if (type.equals(Byte.class)) {
            return true;
        }

        return false;
    }


    /**
     * 没有对cloneAble接口进行限制
     *
     * @param o
     * @return
     * @throws IllegalArgumentException
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public static Object cloneObject(Object o) throws IllegalArgumentException, IllegalAccessException, InstantiationException {
        if (null == o) {
            return null;
        }
        // 使用Map保存原对象和副本对象之间的结构，防止被多次引用的对象重复重建
        Map<Object, Object> map = new HashMap<Object, Object>();
        return cloneObject(o, map);
    }


    private static Object cloneObject(Object o, Map<Object, Object> map)
            throws IllegalArgumentException, IllegalAccessException,
            InstantiationException {
        if (null == o) {
            return null;
        }
        Object newInstance = null;
        newInstance = map.get(o);
        if (null != newInstance) {
            return newInstance;
        }
        if (isSimpleObject(o))
            return o;
        // 数组类型
        if (o.getClass().isArray()) {
            return cloneArray(o, map);
        }
        Class<?> type = o.getClass();
        newInstance = type.newInstance();
        map.put(o, newInstance);
        cloneFields(o, newInstance, map);
        return newInstance;
    }

    /**
     * 克隆数组对象
     *
     * @param o
     * @param map
     * @return
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     */
    private static Object cloneArray(Object o, Map<Object, Object> map) throws IllegalArgumentException, IllegalAccessException, InstantiationException {
        if (null == o) {
            return null;
        }
        if (!o.getClass().isArray()) {
            return cloneObject(o, map);
        }
        int len = Array.getLength(o);
        Object array = Array.newInstance(o.getClass().getComponentType(), len);
        map.put(o, array);
        for (int i = 0; i < len; i++) {
            Array.set(array, i, cloneObject(Array.get(o, i), map));
        }
        return array;
    }

    /**
     * 对于final类型的变量 如果其为引用， 则尽管引用的值不需要更改，但引用对象的数据还是需要填充的
     *
     * @param object
     * @param newObject
     * @param map
     * @return
     * @throws IllegalArgumentException
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    private static void cloneFinalObject(Object object, Object newObject, Map<Object, Object> map) throws IllegalArgumentException, IllegalAccessException, InstantiationException {
        if (object == null || newObject == null || object == newObject || !newObject.getClass().equals(newObject.getClass())) {
            return;
        }
        // 对于final类型的变量
        if (null != map.get(newObject)) {
            return;
        }
        map.put(newObject, newObject);
        cloneFields(object, newObject, map);
        return;
    }


    private static void cloneFields(Object object, Object newObject,
                                    Map<Object, Object> map) throws SecurityException,
            IllegalArgumentException, IllegalAccessException,
            InstantiationException {
        if (null == object || null == newObject) {
            return;
        }
        List<Field> fields = getAllFieads(object);
        for (Field f : fields) {
            // 静态变量过滤掉 或者final的变量
            if (Modifier.isStatic(f.getModifiers()))
                continue;
            // 常量
            if (Modifier.isFinal(f.getModifiers())) {
                cloneFinalObject(f.get(object), f.get(newObject), map);
            } else {
                f.setAccessible(true);
                f.set(newObject, cloneObject(f.get(object), map));
            }
        }
    }
}

方法4：通过Json转换的方式（克隆对象必须实现Serializable接口）

Bean bean1 = new Bean();
Bean bean2 = new Gson().fromJson(new Gson().toJson(bean1), new TypeToken<Bean>(){}.getType());