第一种:
/**
* 实现对象的克隆
*
* @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);
}
}
最快的是第四种, 搞技术的代码一看就懂, 不多说.