java深克隆讨论

第一种:
/**
 * 实现对象的克隆
 * 
 * @author jianhua.fengjh
 */
@SuppressWarnings("all")
public class UCloneUtil {
    /**
     * 序列化实现深克隆
     * 
     * 通过Jdk原生对象序列化流实现深度克隆，虽然简便，但是性能非常之低。
     * @TODO 后续要改成递归克隆方式实现
     * 
     * @param src
     * @return
     * @throws IOException
     * @throws ClassNotFoundException
     */
    @Deprecated
    public static <T> T deepClone(T src) throws IOException, ClassNotFoundException {
        T t = null;
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(src);
            oos.flush();
            ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
            t = (T) ois.readObject();
        } finally {
            if (ois != null) {
                ois.close();
            }
            if (oos != null) {
                oos.close();
            }
        }
        return t;
    }
}
 
第二种
import com.thoughtworks.xstream.XStream;
@SuppressWarnings("all")
public class XCloneUtil {
    private static XStream xstream = new XStream();
    public static <T> T deepClone(T t) {
        return (T) xstream.fromXML(xstream.toXML(t));
    }
}
 
第三种
public class FastCloneUtil {
    public static <T> T deepClone(T src) throws IOException, ClassNotFoundException {
        T t = null;
        ObjectInputStream ois = null;
        ObjectOutputStream oos = null;
        try {
            FastByteArrayOutputStream fbos = new FastByteArrayOutputStream();
            oos = new ObjectOutputStream(fbos);
            oos.writeObject(src);
            oos.flush();
            ois = new ObjectInputStream(fbos.getInputStream());
            t = (T) ois.readObject();
        } finally {
            if (ois != null) {
                ois.close();
            }
            if (oos != null) {
                oos.close();
            }
        }
        return t;
    }
}
 
 
import java.io.InputStream;
/**
 * ByteArrayInputStream implementation that does not synchronize methods.
 */
public class FastByteArrayInputStream extends InputStream {
    /**
     * Our byte buffer
     */
    protected byte[] buf   = null;
    /**
     * Number of bytes that we can read from the buffer
     */
    protected int    count = 0;
    /**
     * Number of bytes that have been read from the buffer
     */
    protected int    pos   = 0;
    public FastByteArrayInputStream(byte[] buf, int count){
        this.buf = buf;
        this.count = count;
    }
    public final int available() {
        return count - pos;
    }
    public final int read() {
        return (pos < count) ? (buf[pos++] & 0xff) : -1;
    }
    public final int read(byte[] b, int off, int len) {
        if (pos >= count) {
            return -1;
        }
        if ((pos + len) > count) {
            len = (count - pos);
        }
        System.arraycopy(buf, pos, b, off, len);
        pos += len;
        return len;
    }
    public final long skip(long n) {
        if ((pos + n) > count) {
            n = count - pos;
        }
        if (n < 0) {
            return 0;
        }
        pos += n;
        return n;
    }
}

 
 
import java.io.InputStream;
import java.io.OutputStream;
/**
 * ByteArrayOutputStream implementation that doesn't synchronize methods and doesn't copy the data on toByteArray().
 */
public class FastByteArrayOutputStream extends OutputStream {
    /**
     * Buffer and size
     */
    protected byte[] buf  = null;
    protected int    size = 0;
    /**
     * Constructs a stream with buffer capacity size 5K
     */
    public FastByteArrayOutputStream(){
        this(5 * 1024);
    }
    /**
     * Constructs a stream with the given initial size
     */
    public FastByteArrayOutputStream(int initSize){
        this.size = 0;
        this.buf = new byte[initSize];
    }
    /**
     * Ensures that we have a large enough buffer for the given size.
     */
    private void verifyBufferSize(int sz) {
        if (sz > buf.length) {
            byte[] old = buf;
            buf = new byte[Math.max(sz, 2 * buf.length)];
            System.arraycopy(old, 0, buf, 0, old.length);
            old = null;
        }
    }
    public int getSize() {
        return size;
    }
    /**
     * Returns the byte array containing the written data. Note that this array will almost always be larger than the
     * amount of data actually written.
     */
    public byte[] getByteArray() {
        return buf;
    }
    public final void write(byte b[]) {
        verifyBufferSize(size + b.length);
        System.arraycopy(b, 0, buf, size, b.length);
        size += b.length;
    }
    public final void write(byte b[], int off, int len) {
        verifyBufferSize(size + len);
        System.arraycopy(b, off, buf, size, len);
        size += len;
    }
    public final void write(int b) {
        verifyBufferSize(size + 1);
        buf[size++] = (byte) b;
    }
    public void reset() {
        size = 0;
    }
    /**
     * Returns a ByteArrayInputStream for reading back the written data
     */
    public InputStream getInputStream() {
        return new FastByteArrayInputStream(buf, size);
    }
}

第四种
import com.rits.cloning.Cloner;
public class VeryFastCloneUtil {
    public static <T> T deepClone(T src) {
        Cloner cloner = new Cloner();
        return cloner.deepClone(src);
    }
}

最快的是第四种, 搞技术的代码一看就懂, 不多说.