Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Copie défensive des collections

Copiez la liste dans le constructeur et dans `getRoles()` pour empêcher le code appelant de modifier la liste stockée dans le DTO. `final` seul ne suffit pas.

Version : Java SE 21

Syntaxe

private final List<String> roles;

RolesDto(List<String> roles) {
    this.roles = new ArrayList<>(roles);
}

public List<String> getRoles() {
    return new ArrayList<>(roles);
}

La copie défensive des collections protège l’état d’un objet contre les modifications effectuées via une référence partagée. Dans un objet de transfert de données (DTO), le constructeur stocke new ArrayList<>(roles) au lieu de conserver la liste fournie. Chaque appel à getRoles() renvoie une nouvelle liste modifiable. Les deux copies conservent l’ordre des éléments. final empêche de réaffecter le champ à une autre liste, mais n’empêche pas les opérations comme add ou set sur la liste elle-même.

new ArrayList<>(roles) produit une copie superficielle : les listes sont des objets distincts, mais référencent les mêmes éléments. Cela suffit avec String, car les chaînes sont immuables. Si les éléments sont mutables, un changement de leur état peut être visible dans les deux listes. Pour isoler aussi cet état, copiez-le à l’entrée et à la sortie ou utilisez des types d’éléments immuables.

Si le code appelant n’a pas besoin de modifier le résultat et que null est exclu, stockez List.copyOf(roles) dans le constructeur et renvoyez directement cette liste. Les modifications ultérieures de la liste source ne sont pas répercutées, et copyOf ne crée pas nécessairement une nouvelle instance. Les méthodes de modification du résultat lèvent UnsupportedOperationException ; une source ou un élément null provoque une NullPointerException. Le résultat reste superficiel. En revanche, Collections.unmodifiableList(roles) crée une vue non modifiable, pas une copie : les modifications de la liste source y restent visibles.

Exemples

import java.util.ArrayList;
import java.util.List;

public class Main {
    static final class RolesDto {
        private final List<String> roles;

        RolesDto(List<String> roles) {
            this.roles = new ArrayList<>(roles);
        }

        public List<String> getRoles() {
            return new ArrayList<>(roles);
        }
    }

    public static void main(String[] args) {
        List<String> input = new ArrayList<>(List.of("reader"));
        RolesDto dto = new RolesDto(input);
        input.add("admin");

        List<String> returned = dto.getRoles();
        returned.set(0, "owner");

        System.out.println(input);
        System.out.println(returned);
        System.out.println(dto.getRoles());
    }
}

Résultat

[reader, admin]
[owner]
[reader]

`input.add("admin")` ne modifie que la liste d’entrée, et `returned.set(0, "owner")` ne modifie que la copie du premier appel à `getRoles()`. Le deuxième appel renvoie toujours `[reader]`.

Leçons associées

  • Java · Leçon 10 · Avancé · Version : 2

Sources