Comment créer une liste immuable en java?
j'ai besoin de convertir l'objet liste mutable en liste immuable,Quelle est la manière 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;
}
}
6 réponses
une fois votre beanList a été initialisé, vous pouvez le faire
beanList = Collections.unmodifiableList(beanList);
pour faire inmodifiable. (Voir immuable vs Unmodifiable collection)
si vous avez à la fois des méthodes internes qui devraient pouvoir modifier la liste, et des méthodes publiques qui ne devraient pas permettre de modification, je vous suggérerais de 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;
}
(Bean objets semblent immuables.)
en tant que side-note: si vous utilisez 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));
Utiliser Collections.unmodifiableList(). Vous passez votre original ArrayList et il renvoie une liste qui lance une exception si vous essayez d'ajouter, supprimer ou déplacer des éléments. Par exemple, utiliser return Collections.unmodifiableList(beanList); au lieu de return beanList; à la fin de getImmutableList(). main() va jeter une exception. Collections la classe a des méthodes pour tous les autres types communs de collecte en plus de la liste aussi.
à Partir 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 créera pas de copie.si la collection donnée est mutable et modifiée, la liste retournée ne reflétera pas ces modifications. Ce qui signifie qu'ils sont dépendants.
la solution ci-dessous est pour rendre la liste immuable sans utiliser D'API.
Immuable Objet avec ArrayList membre de la variable
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());
}
}
ainsi la liste actuelle ne changera pas, la sortie sera toujours [A, B]
Si sont ouverts à l'utilisation d'une bibliothèque tierce, Collection Eclipse s vous permet de convertir de MutableListImmutableList et de nouveau de retour.
MutableList<String> mutable = Lists.mutable.with("a", "b", "c");
ImmutableList<String> immutable = mutable.toImmutable();
MutableList<String> mutableAgain = immutable.toList();
cela fonctionne aussi avec les collections primitives.
MutableCharList mutable = CharLists.mutable.with('a', 'b', 'c');
ImmutableCharList immutable = mutable.toImmutable();
MutableCharList mutableAgain = immutable.toList();
Si vous avez un ArrayList comme le mutable List, le travail.
List<String> mutable = new ArrayList<>(Arrays.asList("a", "b", "c"));
ImmutableList<String> immutable = Lists.immutable.withAll(mutable);
List<String> mutableAgain = immutable.toList();
Note: je suis un committer pour Eclipse Collections.