📋 자바로 이해하는 얕은 복사 & 깊은 복사

class Address {
  private String city;
  public Address(String city) { this.city = city; }
  public String getCity() { return city; }
  public void setCity(String city) { this.city = city; }
}

class Person {
  private String name;     // 불변(문자열 자체는 불변)
  private Address address; // 가변 참조 필드
  
  public Person(String name, Address address) {
    this.name = name;
    this.address = address;
  }
  
  public String getName() { return name; }
  public Address getAddress() { return address; }
}

Person p1 = new Person("Min", new Address("Seoul"));

// 새 객체를 생성하였지만 내부 참조 공유
Person p2 = new Person(p1.getName(), p1.getAddress());

p1.getAddress().setCity("Busan");
System.out.println(p2.getAddress().getCity()); // Busan (같이 바뀜)

Person p1 = new Person("Min", new Address("Seoul"));

// 깊은 복사
Person p4 = new Person(
  p1.getName(),
  new Address(p1.getAddress().getCity())
);

p1.getAddress().setCity("Busan");
System.out.println(p4.getAddress().getCity()); // Seoul (영향 없음)

// Cloneable 상속
class Address implements Cloneable {
  private String city;
  public Address(String city) { this.city = city; }
  public String getCity() { return city; }
  public void setCity(String city) { this.city = city; }
  
  // public으로 오버라이드
  @Override
  public Address clone() {
    // 예외 처리
    try {
      return (Address) super.clone(); // 불변/문자열 필드만 있으면 안전
    } catch (CloneNotSupportedException e) {
      throw new AssertionError(e);
    }
  }
}

class Person implements Cloneable {
  private String name;
  private Address address; // 가변 참조
  
  public Person(String name, Address address) {
    this.name = name;
    this.address = address;
  }
  
  @Override
  public Person clone() {
    try {
      Person copy = (Person) super.clone(); // 필드 단위 복사
      copy.address = address == null ? null : address.clone(); // 깊은 복사
      return copy;
    } catch (CloneNotSupportedException e) {
      throw new AssertionError(e);
    }
  }
}

class Person {
  private final String name;
  private final Address address;
  
  public Person(String name, Address address) {
    this.name = name;
    this.address = address; // 주의: 그대로 대입하면 얕은 복사
  }
  
  // 복사 생성자 (깊은 복사)
  public Person(Person other) {
    this.name = other.name; // String은 불변
    this.address = other.address == null ? null : new Address(other.address.getCity());
  }
  
  public static Person copyOf(Person other) {
    return new Person(other);
  }
}

ObjectMapper om = new ObjectMapper();

// original 객체를 JSON 바이트로 직렬화 
byte[] bytes = om.writeValueAsBytes(original);

// JSON 바이트를 다시 Person.class로 역직렬화 -> 새로운 객체 생성
Person copy = om.readValue(bytes, Person.class);

@Mapper
public interface PersonMapper {
  PersonMapper INSTANCE = Mappers.getMapper(PersonMapper.class);
  
  PersonDto toDto(Person entity);
  Person toEntity(PersonDto dto);
}

// 사용 시
Person p1 = new Person("Min", new Address("Seoul"));
PersonDto dto = PersonMapper.INSTANCE.toDto(p1);
// dto 안의 Address도 새 인스턴스로 매핑되어 깊은 복사

List<Person> src = ...; // 원본 리스트
List<Person> deep = src.stream()
  .map(Person::new)     // Person 복사 생성자를 이용해 새 객체 생성
  .toList();            // 새 리스트로 수집

List<String> list = new ArrayList<>();
list.add("Blue");
list.add("Cool");

List<String> copy = List.copyOf(list); // 불변 리스트 + 얕은 복사
copy.add("c"); // UnsupportedOperationException 발생

Address[] a1 = { new Address("Seoul") };
Address[] a2 = a1.clone(); // 배열 객체는 새로 생성, 요소는 같은 참조

class Order {
  private final Date createdAt; // Date는 가변 클래스
  
  public Order(Date createdAt) {
    this.createdAt = new Date(createdAt.getTime()); // 입력 방어 복사
  }
  
  public Date getCreatedAt() {
    return new Date(createdAt.getTime()); // 반환 방어 복사
  }
}

public record PersonR(String name, AddressR address) {}
public record AddressR(String city) {}

// 사용 시
PersonR p1 = new PersonR("Min", new AddressR("Seoul"));
PersonR p2 = p1; // 같은 참조를 써도 안전하다. (불변)

class Address {
  String city;
  Address(String city) { this.city = city; }
  // equals/hashCode city 기준으로 구현했다고 가정
  @Override
  public boolean equals(Object o) { ... }
  @Override
  public int hashCode() { ... }
}

class Person {
  String name;
  Address address;
  // equals/hashCode: name + address 기준으로 구현했다고 가정
  ...
}

Person p1 = new Person("Min", new Address("Seoul"));
Person p2 = new Person(p1.name, p1.address); // 얕은 복사

Set<Person> set = new HashSet<>();
set.add(p1);

// 중첩 객체(Address) 변경
p1.address.city = "Busan";

// p2.equals(p1)는 여전히 true (같은 참조 공유)
// set.contains(p1) -> false (hashCode가 달라짐)