Java实验 - new一个对象真的比clone一个对象快？

• 用于创建对象的类

public class Person implements Cloneable {
    private String id;
    private String name;

    public Person(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

• 测试代码

public class MainTest {
    public static void main(String[] args) {
        int count = 10000000;
        long start = System.currentTimeMillis();
        for (int i = 0; i < count; i++) {
            newObject();
        }
        System.out.println("newObject: " + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        Person person = new Person("01", "name");
        for (int i = 0; i < count; i++) {
            cloneObject(person);
        }
        System.out.println("cloneObject: " + (System.currentTimeMillis() - start));
    }

    private static void newObject() {
        Person person = new Person("01", "name");
    }

    private static void cloneObject(Person person) {
        Person clone = (Person) person.clone();
    }
}

• 测试结果

	第一次	第二次	第三次	第四次	第五次
new对象	5ms	8ms	6ms	7ms	6ms
clone对象	83ms	172ms	127ms	107ms	118ms

从测试结果来看，clone一个对象要比new一个对象更耗时，怎么回事呢，既然clone更耗时，那clone还有什么用呢？

• 修改下创建对象的类

public class Person implements Cloneable {
    private String id;
    private String name;

    public Person(String id, String name) {
        if (id == null) {
            id = "0000000001";
        } else if (id.length() < 10) {
            id = String.format("%010d", Integer.parseInt(id));
        }        
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

• 修改后的测试结果

	第一次	第二次	第三次	第四次	第五次
new对象	9404ms	9827ms	9701ms	10889ms	10340ms
clone对象	54ms	64ms	62ms	61ms	58ms

从测试结果来看，new一个对象比clone一个对象耗时高了不少。

• 最终结论

当new一个对象的时候，构造函数没有比较耗时的逻辑，这个时候要比new一个对象耗时更少。如果构造函数有比较耗时的逻辑，则clone一个对象耗时更少。既clone的时候，会减去了执行构造函数的操作。

具体什么样是比较耗时的逻辑，这个需要实际测试。当要大量创建对象，且有性能要求的时候，可以考虑clone这种方式可行性。