База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / Java

Копиращ конструктор, плитко и дълбоко копиране

Копиращият конструктор създава нов екземпляр от съществуващ. Плиткото копие продължава да споделя вложени обекти, а дълбокото отделя изменяемото състояние, обхванато от договора за копиране.

Версия: Java SE 21

Синтаксис

T(T source) { /* initialize the new instance from source */ }
T copy = new T(source);

Копиращият конструктор е обикновен конструктор, който приема екземпляр от същия клас, например T(T source). Java SE 21 не го създава автоматично. При new T(source) вариантът на претоварения конструктор се избира при компилация, а реализацията определя какво се копира и какво се споделя. За разлика от това T alias = source копира само референцията и не създава обект.

Плиткото копие създава нов външен обект, но взема стойностите на полетата без промяна: както примитивните стойности, така и референциите. Промяна в споделен изменяем обект се вижда през двата екземпляра. Поле с референция, обявено като final, не позволява присвояване на друга референция, но не забранява промени в сочения обект. Базовата реализация на Object.clone() прави плитко копие и хвърля CloneNotSupportedException, ако обектът не реализира Cloneable. Копиращият конструктор не изисква този интерфейс.

Дълбокото копие създава наново и вложените изменяеми обекти, обхванати от договора за копиране. Промените в това състояние не се пренасят между оригинала и копието. Неизменяемите обекти могат да се споделят. Само нов контейнер не е достатъчен, ако изменяемите му елементи остават споделени.

За да запазиш циклите и споделените възли в граф от обекти, запиши всяка двойка оригинал–копие според идентичността на обектите, например в IdentityHashMap, преди да проследиш референциите на възела. Така няколко референции към един и същ възел водят до едно копие, а циклите не причиняват безкрайна рекурсия.

Примери

public class Main {
    static final class Box {
        private final int[] values;

        private Box(int[] values) {
            this.values = values;
        }

        Box(Box source) {
            this(source.values.clone());
        }

        static Box shallowCopyOf(Box source) {
            return new Box(source.values);
        }
    }

    public static void main(String[] args) {
        Box original = new Box(new int[] {1});
        Box shallow = Box.shallowCopyOf(original);
        Box deep = new Box(original);

        System.out.println("Distinct boxes: " + (original != shallow) + ", " + (original != deep));
        System.out.println("Shared arrays: " + (original.values == shallow.values)
                + ", " + (original.values == deep.values));

        shallow.values[0] = 7;
        deep.values[0] = 9;
        System.out.println("Values: original=" + original.values[0]
                + ", shallow=" + shallow.values[0] + ", deep=" + deep.values[0]);
    }
}

Резултат

Distinct boxes: true, true
Shared arrays: true, false
Values: original=7, shallow=7, deep=9

И двете копия са нови обекти `Box`; само `shallow` споделя масива си с `original`. Промяната през `shallow` задава `7` като стойност, видима в `original`, а промяната през `deep` задава `9` само за неговата стойност. Клонирането на `int[]` е достатъчно, защото елементите са примитивни; клонирането на масив от референции не копира обектите, към които сочат.

Свързани уроци

  • Java · Урок 6 · Напреднало · Версия: 2

Източници