Comment créer une liste immuable dans Java?

J'ai besoin de convertir mutable objet de liste de liste immuable,ce qui est la façon possible en java.

public void action() {
    List<MutableClass> mutableList = Arrays.asList(new MutableClass("san", "UK", 21), new MutableClass("peter", "US", 34));
    List<MutableClass> immutableList = immutateList(mutableList);
}

public List<MutableClass> immutateList(List<MutableClass> mutableList){
    //some code here to make this beanList immutable
    //ie. objects and size of beanList should not be change.
    //ie. we cant add new object here.
    //ie. we cant remove or change existing one.
}

`MutableClass`

final class MutableClass {
    final String name;    
    final String address;
    final int age;
    MutableClass(String name, String address, int age) {
        this.name = name;
        this.address = address;
        this.age = age;
    }
}

source d'informationauteur

Une fois votre beanList a été initialisé, vous pouvez le faire

beanList = Collections.unmodifiableList(beanList);

à faire inmodifiable. (Voir Immuable vs Inmodifiable collection)

Si vous avez deux méthodes internes qui doivent être en mesure de modifier la liste, et les méthodes publiques qui ne devrait pas autoriser la modification, je vous suggère de vous faire

//public facing method where clients should not be able to modify list    
public List<Bean> getImmutableList(int size) {
    return Collections.unmodifiableList(getMutableList(size));
}

//private internal method (to be used from main in your case)
private List<Bean> getMutableList(int size) {
    List<Bean> beanList = new ArrayList<Bean>();
    int i = 0;

    while(i < size) {
        Bean bean = new Bean("name" + i, "address" + i, i + 18);
        beanList.add(bean);
        i++;
    }
    return beanList;
}

(Votre Bean objets semblent immuables.)

Comme un side-note: S'il vous arrive d'être à l'aide de Java 8+, votre getMutableList peut être exprimée comme suit:

return IntStream.range(0,  size)
                .mapToObj(i -> new Bean("name" + i, "address" + i, i + 18))
                .collect(Collectors.toCollection(ArrayList::new));

5

Utilisation Collections.unmodifiableList(). Vous passez votre original ArrayList et elle renvoie une liste qui lève une exception si vous essayez d'ajouter, de supprimer ou de changement des éléments. Par exemple, l'utilisation return Collections.unmodifiableList(beanList); au lieu de return beanList; à la fin de getImmutableList(). main() lèvera une exception. Le Collections classe possède des méthodes pour tous les autres types de collection en plus de la liste ainsi.

Ci-dessous la solution est de faire liste comme Immuable, sans l'aide d'une API.

Immuable Objet avec ArrayList variable membre

public final class Demo {

private final List<String> list = new ArrayList<String>();

public Demo() {
    list.add("A");
    list.add("B");
}

public List<String> getImmutableList() {
    List<String> finalList = new ArrayList<String>();
    list.forEach(s -> finalList.add(s));
    return finalList;
}

public static void main(String[] args) {
    //TODO Auto-generated method stub
    Demo obj = new Demo();
    System.out.println(obj.getImmutableList());
    obj.getImmutableList().add("C");
    System.out.println(obj.getImmutableList());
}

}

Donc la liste ne sera pas changé, toujours la sortie sera [A,B]

1

De Java 10, List.copyOf(Collection) peut être utilisé pour renvoyer un inmodifiable liste de la collection donnée. À partir du code source de List.copyOf méthode:
- si la collection est une inmodifiable Liste, List.copyOf() ne va pas créer une copie.
- si la collection est mutable et modifié, la liste retournée ne sera pas tenir compte de ces modifications. Ce qui signifie qu'ils sont dépendants.

Dans le JDK 8:

List<String> stringList = Arrays.asList("a", "b", "c");
stringList = Collections.unmodifiableList(stringList);

Dans le JDK 9:

List stringList = List.of("a", "b", "c");

référence

Si sont ouverts à l'utilisation d'une bibliothèque tierce, Eclipse Collections vous permet de convertir de MutableList à ImmutableList et de retour à nouveau.

MutableList<String> mutable = Lists.mutable.with("a", "b", "c");
ImmutableList<String> immutable = mutable.toImmutable();
MutableList<String> mutableAgain = immutable.toList();

Cela fonctionne également avec les collections de primitifs.

MutableCharList mutable = CharLists.mutable.with('a', 'b', 'c');
ImmutableCharList immutable = mutable.toImmutable();
MutableCharList mutableAgain = immutable.toList();

Si vous avez un ArrayList que la mutable Listle travail.

List<String> mutable = new ArrayList<>(Arrays.asList("a", "b", "c"));
ImmutableList<String> immutable = Lists.immutable.withAll(mutable);
List<String> mutableAgain = immutable.toList();

Remarque: je suis un committer pour Eclipse Collections.

Vous devez vous connecter pour publier un commentaire.