Ce n'Collections.unmodifiableSet() faire en Java?

Je peux voir que Collections.unmodifiableSet retourne un inmodifiable vue de l'ensemble, mais je ne comprends pas pourquoi on ne peut pas utiliser le final modificateur pour accomplir cette tâche.

Dans ma compréhension, final déclare une constante: quelque chose qui ne peut pas être modifié. Donc, si un jeu est déclaré comme une constante, alors il ne peut pas être modifié: rien ne peut être enlevé de l'ensemble et rien ne peut être ajouté.

Pourquoi avons-nous besoin Collections.unmodifiableSet?

InformationsquelleAutor Roman | 2010-03-10

62

final déclare un objet de référence qui ne peut pas être modifié, par exemple
```
private final Foo something = new Foo();
```
crée un nouveau Foo et des lieux de référence dans something. Par la suite, il n'est pas possible de modifier something de pointer vers une autre instance de Foo.

Cela ne pas empêcher toute modification de l'état interne de l'objet. Je peux toujours appeler toutes les méthodes sur Foo y sont accessibles à la portée. Si une ou plusieurs de ces méthodes modifie l'état interne de l'objet, puis final ne vais pas l'en empêcher.

En tant que tel, les éléments suivants:
```
private final Set<String> fixed = new HashSet<String>();
```
ne pas créer un Set qui ne peut pas être ajouté ou altéré; il signifie simplement que fixed ne jamais référence à cette instance.

En revanche, en faisant:
```
private Set<String> fixed = Collections.unmodifiableSet( new HashSet<String>() );
```
crée une instance d'un Set qui lancera UnsupportedOperationException si l'on tente d'appeler fixed.add() ou fixed.remove(), par exemple - l'objet lui-même de protéger son état interne et l'empêcher d'être modifié.

Par souci d'exhaustivité:
```
private final Set<String> fixed = Collections.unmodifiableSet( new HashSet<String>() );
```
crée une instance d'un Set qui ne permet pas de son état interne d'être changé, et signifie également que fixed ne jamais pointer à une instance de ce jeu.

La raison que final peut être utilisé pour créer des constantes de primitives est basée sur le fait que la valeur ne peut pas être changé. Rappelez-vous que fixed ci-dessus était juste une référence à une variable contenant une adresse qui ne peut pas être changé. Eh bien, pour les primitives, par exemple
```
private final int ANSWER = 42;
```
la valeur de ANSWER est que de 42. Depuis ANSWER ne peut pas être changé, il ne pourront jamais avoir la valeur 42.

Un exemple qui brouille toutes les lignes serait celui-ci:
```
private final String QUESTION = "The ultimate question";
```
Par les règles ci-dessus, QUESTION contient l'adresse d'une instance de String qui représente "L'ultime question", et que l'adresse ne peut pas être changé. La chose à retenir ici est que String lui-même est immuable - vous ne pouvez rien faire à une instance de String qui change, et toutes les opérations qui seraient autrement (comme replace, substring, etc.) retour références à tout à fait différentes instances de String.

InformationsquelleAutor Rob
15

final garantit seulement que le référence à l'objet de la variable représente ne peut pas être changé, il ne fait rien pour l'instance de l'objet et sa mutabilité.

final Set s = new Set(); juste des garanties que vous ne pouvez pas faire s = new Set(); de nouveau. Il ne veut pas faire le jeu inmodifiable, si ne vous ne pouvez pas ajouter quoi que ce soit, pour commencer. Donc, pour le rendre vraiment clair, final affecte uniquement la variable référence pas l'objet de points de référence.

Je peux faire ce qui suit:
```
final List<String> l = new ArrayList<String>();
l.add("hello");
l.add("world");
l.remove(0);
```
mais je ne peux pas faire cela.
```
l = new ArrayList<String>();
```
encore en raison de la final je ne peux pas modifier le type de la variable l points à.

que vous avez à faire une des trois choses suivantes pour faire un contenant de Collecte thread-safe.
```
java.util.Collections.syncronizedXXX();
```
ou
```
java.util.Collections.unmodifiableXXX();
```
ou
utilisez l'une des conteneurs appropriés de java.util.concurrency.* package.

si j'avais un Person objet et n'a final Person p = new Person("me"); cela signifie que je ne peux pas réaffecter p à point à un autre Person objet. Je peux encore faire p.setFirstName("you");

Ce qui confond la situation est que
```
final int PI = 3.14;
final String greeting = "Hello World!";
```
ressembler const en C++, alors qu'en fait, les objets qu'ils désignent sont immuables/inmodifiable par la nature. Des conteneurs ou des objets avec mutateur méthodes qui peuvent modifier l'état interne de l'objet ne sont pas const juste le référence à ces objets sont final et ne peut pas être réaffectés à référence un autre objet.
- Bon poste. En bref, le référence qui ne peut être changé, mais le table des matières de l'objet peut.
InformationsquelleAutor
3

final n'est pas C++-style) const. Contrairement au C++, Java n'a pas const-méthodes ou quelque chose comme ça, et les méthodes qui permettent de modifier l'objet peut être appelée par un final de référence.

Collections.unmodifiable* est un wrapper qui applique (au moment de l'exécution, et non à la compilation) la lecture-seule-ness pour la collection concernée.

InformationsquelleAutor Chris Jester-Young
3

La Collections.unmodifiableSet(Set<? extends T>) permettra de créer un wrapper sur le jeu original. Ce wrapper set ne peut pas être modifié. mais encore le jeu d'origine peut être modifié.

Exemple:
```
 Set<String> actualSet=new HashSet<String>(); //Creating set
```
De l'ajout de certains éléments
```
actualSet.add("aaa");
actualSet.add("bbb");
```
Impression ajouté des éléments
```
System.out.println(actualSet);   //[aaa, bbb]
```
Mettre le actualSet en inmodifiable ensemble et assignés à la nouvelle référence(wrapperSet).
```
Set<String> wrapperSet=Collections.unmodifiableSet(orginalSet);
```
Imprimer le wrapperSet. alors il aura actualSet Valeurs
```
System.out.println(wrapperSet);   //[aaa, bbb]
```
permet d'essayer de supprimer/ajouter un élément sur wrapperSet.
```
wrapperSet.remove("aaa");   //UnSupportedOperationException 
```
Ajouter un élément de plus dans actualSet
```
    actualSet .add("ccc");
```
Impression actualSet et wrapperSet. les deux ensembles de valeurs sont les mêmes. donc, Si vous ajouter/supprimer des éléments réels que les modifications seront répercutées sur wrapper set.
```
    System.out.println(actualSet);  //[aaa, ccc, bbb]
    System.out.println(wrapperSet);  //[aaa, ccc, bbb]
```
Utilisation:

Ce Collections.unmodifiableSet(Set<? extends T>) est utilisé pour empêcher la modification de l'Ensemble de la méthode de lecture de n'importe quel objet. disons
```
public class Department{

    private Set<User> users=new HashSet<User>();

    public Set<User> getUsers(){
        return Collections.unmodifiableSet(users); 
    }
}
```
InformationsquelleAutor MAA

Résumer ce que nous pouvons faire et ne peut pas:

Préparation:

private Set<String> words = new HashSet<>(Arrays.asList("existing word"));

Finale par référence

private final Set<String> words = new HashSet<>();

peut:

words.add("new word");

ne peut pas:

words = new HashSet<>(); //compilation error

Finale par référence et inmodifiable par collecte.

finale privée Jeu de mots = Collections.unmodifiableSet(mots);

peut:

String word = words.iterator().next();

ne peut pas:

words = new HashSet<>(); //compilation error
words.add("new word"); //runtime error UnsupportedOperationException

Finale par référence et inmodifiable par la collection, mais réciproque, la collecte de l'objet.

Mais si vous disposez de la collection avec mutuelle objets vous pouvez MODIFIER l'état interne de l'objet.

 class A {
       public int a; //mutable field. I can change it after initialization
       public A(int a) {this.a = a;}
     }

 private final Set<A> set = Collections.unmodifiableSet(Arrays.asList(new A(25)));

Toujours pas

set = new HashSet<>(); //compilation error
set.add(new A(777)); //runtime error UnsupportedOperationException

Mais peut

 A custom = words.iterator().next(); //here custom.a = 25;
 custom.a = 777; //here first element of **final, unmodifible** collection 
    //was changed from 25 to 777

InformationsquelleAutor Dmitry N.

Vous devez vous connecter pour publier un commentaire.