java反射机制创建对象实现：java 深度拷贝 -超完美

java反射机制创建对象实现：java 深度拷贝 -超完美 ，自己做的，下面 

package aop;

public class Student {
	private String name;
	private int  age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}

 

package aop;

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

import com.alibaba.fastjson.JSONObject;

public class DeepCopy {

	/**
     * 深层拷贝
     *
     * @param 
     * @param obj
     * @return
     * @throws Exception
     */
    static  T copy(T obj) throws Exception {
        //是否实现了序列化接口，即使该类实现了，他拥有的对象未必也有...
        if(Serializable.class.isAssignableFrom(obj.getClass())){
            //如果子类没有继承该接口，这一步会报错
            try {
                return copyImplSerializable(obj);
            } catch (Exception e) {
                //这里不处理，会运行到下面的尝试json
            }
        }
        //如果序列化失败，尝试json序列化方式
        if(hasJson()){
            try {
                return copyByJson(obj);
            } catch (Exception e) {
                //这里不处理，下面返回null
            }
        }
        return null;
    }

    /**
     * 深层拷贝 - 需要类继承序列化接口
     * @param 
     * @param obj
     * @return
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    private static  T copyImplSerializable(T obj) throws Exception {
        ByteArrayOutputStream baos = null;
        ObjectOutputStream oos = null;

        ByteArrayInputStream bais = null;
        ObjectInputStream ois = null;

        Object o = null;
        //如果子类没有继承该接口，这一步会报错
        try {
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(obj);
            bais = new ByteArrayInputStream(baos.toByteArray());
            ois = new ObjectInputStream(bais);

            o = ois.readObject();
            return (T) o;
        } catch (Exception e) {
            throw new Exception("对象中包含没有继承序列化的对象");
        } finally{
            try {
                assert baos != null;
                baos.close();
                assert oos != null;
                oos.close();
                assert bais != null;
                bais.close();
                assert ois != null;
                ois.close();
            } catch (Exception e2) {
                //这里报错不需要处理
            }
        }
    }

    /**
     * 是否可以使用json
     * @return
     */
    private static boolean hasJson(){
        try {
            Class.forName("com.alibaba.fastjson.JSONObject");
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 深层拷贝 - 需要net.sf.json.JSONObject
     * @param 
     * @param obj
     * @return
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    private static  T copyByJson(T obj) throws Exception {
    	return (T) JSONObject.parseObject(JSONObject.toJSONString(obj),obj.getClass());
    }
    
    //方法2：最多只做了两层的数组处理：即数组里的数组
    public static void copyObjectSZ(Object[] obj,Object[] objTemp) throws Exception{
		for(int i=0;i){
			    List