How to make a deep copy of an object with a List variable in Java?

user_14979447 0
Viewed 330

I am working in Java and I want to make a deep copy of a MoleculeDTO object. I tried to make a copy constructor too, but it is not working and it is refering to the initial object.

public class MoleculeDTO {
    private int ID;
    private String name;
    private List<AtomDTO> atoms = new ArrayList<>();
    private int nrAtoms =0;

    public MoleculeDTO(String name, List<AtomDTO> atoms, int nrAtoms) {
        this.name = name;
        this.atoms = atoms;
        this.nrAtoms = nrAtoms;
    }

    public MoleculeDTO(MoleculeDTO molecule) {
        this(molecule.getName(), molecule.getAtoms(), molecule.getNrAtoms());
    }
...getter, setter
}

Here is class AtomDTO.

public class AtomDTO{
    private int ID;
    private String name;
    private String symbol;
    private int nrOfBonds;
    private List<BondDTO> bonds = new ArrayList<>();
    private int type;
    private AnchorNode anchorNode;


    public AtomDTO(String name, String symbol, int nrOfBonds, List<BondDTO> bonds, int type) {
        this.name = name;
        this.nrOfBonds = nrOfBonds;
        this.bonds = bonds;
        this.type = type;
    }

    public AtomDTO(AtomDTO copyAtom) {
        this(copyAtom.getName(),copyAtom.getSymbol(), copyAtom.getNrOfBonds(), copyAtom.getBonds(), copyAtom.getType());
    }
...getter, setter
}

Here is class BondDTO.

public class BondDTO {
    private int ID;
    private int otherAtomID;
    private int otherAtomType;
    private int bondType;

    public BondDTO(int otherAtomID, int otherAtomType, int bondType) {
        this.otherAtomID = otherAtomID;
        this.otherAtomType = otherAtomType;
        this.bondType = bondType;
    }

    public BondDTO(BondDTO copyBond) {
        this(copyBond.getOtherAtomID(), copyBond.otherAtomType, copyBond.bondType);
    }
...getter, setter
}
copy-constructor deep-copy oop java
1 Answers

Your copy constructors are just doing shallow copies of each field. That's fine for strings because they're immutable, and it's fine for ints because they're primitive (which means they lack identity and are immutable). In those cases, there is no important difference between shallow and deep copies. But it doesn't work in general for lists because lists can be mutable and so can their elements. So instead of just pointing at the same list, you need to make a new list and deep copy each element of the original list into the new one.

Use this helper method to make deep copies of any lists:

static <T> List<T> deepCopyList(List<T> list, UnaryOperator<T> deepCopyElement) {
    return list.stream().map(deepCopyElement).collect(
        Collectors.toCollection(ArrayList::new)
    );
}

Like so:

public AtomDTO(AtomDTO that) {
    this(that.getName(), that.getType(), deepCopyList(that.getBonds(), BondDTO::new));
}
user_4643060
Related