Java Final arraylist

Ma question est concernant la déclaration d'une liste de tableaux comme définitive. Je sais qu'une fois que j'écris final ArrayList list = new ArrayList(); je peux ajouter, supprimer des objets à partir de cette liste, mais je ne peux pas list = new ArrayList() ou list = list1. Mais quelle sera l'utilisation de déclarer arraylist comme
Private static final ArrayList list = new ArrayList();. Et en dehors de la différence, je l'ai mentionné ci-dessus quelle sera la différence entre les deux suivantes de la déclaration:

1. ArrayList list = new ArrayList()

2. private static final ArrayList list =  new ArrayList();

Il semble que vous êtes visant à obtenir des précisions sur la différence entre une variable d'instance et une variable statique. Si ce n'est pas le cas, veuillez préciser plus.

OriginalL'auteur user553198 | 2010-12-24

java

12

Vous êtes en droit de déclarer la list final signifie que vous ne pouvez pas réaffecter les list variable à un autre objet.

L'autre question (je pense) a été
```
public class SomeClass {
    private static final ArrayList list = new ArrayList();
}
```
vs
```
public class SomeClass {
    ArrayList list = new ArrayList();
}
```
prenons chaque modificateur à son tour.

private Signifie seulement cette classe (SomeClass) peut accéder à list

static Signifie qu'il n'existe qu'une seule instance de la list variable pour toutes les instances de SomeClass à partager. La liste de l'instance est associée à la SomeClass une classe plutôt qu'à chaque nouvelle SomeClass instance. Si une variable est non statique il est dit être une variable d'instance

final comme vous le savez, vous ne pouvez pas réaffecter la liste variable d'une autre valeur.

Dans la deuxième déclaration il n'y a pas de modificateurs, de sorte que la variable est une variable d'instance, et il permet aussi de colis-privé de la protection d'accès (Parfois appelé par défaut de la protection d'accès). Cela signifie que cette classe (SomeClass) et d'autres classes du même package peut accéder à la variable.

Vous pouvez en savoir plus sur public, private, et package-private ici: Contrôle d'accès

Vous pouvez en savoir plus sur final et static ici: Variables de classe

OriginalL'auteur daveb
12

Juste pour "apporter un peu d'eau à votre Moulin" vous permettra de comprendre l'intérêt de final lorsque vous aurez envie de faire votre liste publiquement disponible, mais inmodifiable.

En java, on peut faire une liste inmodifiable avec Les Collections.unmodifiableList(modifiableList).

Ont maintenant un coup d'oeil au code suivant :
```
public class MyClass{
  public static List<String> MY_PUBLIC_LIST;
  static{
    ArrayList<String> tmp = new ArrayList<String>();
    tmp.add("a");
    tmp.add("b");
    tmp.add("c");
    MY_PUBLIC_LIST = tmp;
  }
}
```
Bien, dans anyclass, n'importe où dans votre code, vous pouvez faire quelque chose comme ceci
```
MyClass.MY_PUBLIC_LIST = null;
MyClass.MY_PUBLIC_LIST = new ArrayList<String>();
MyClass.MY_PUBLIC_LIST.clear();
MyClass.MY_PUBLIC_LIST.add("1");
```
Lorsque vous ajoutez le final mot-clé de votre variable, les deux premiers ne seront pas autorisés
```
public static final List<String> MY_PUBLIC_LIST;
```
Mais vous aurez toujours la possibilité de modifier le contenu de la liste :
```
MyClass.MY_PUBLIC_LIST.clear();
MyClass.MY_PUBLIC_LIST.add("1");
```
Par l'ajout d'un Les Collections.unmodifiableList(modifiableList) à la fin de la statique bloc vous prévenir :
```
MY_PUBLIC_LIST = Collections.unmodifiableList(tmp);
```
Ok, nous y sommes presque. Juste pour être sûr que vous obtenez l'ensemble de l'image permet de garder le Les Collections.unmodifiableList(modifiableList) mais permettez-moi de supprimer le dernier modificateur
```
public class MyClass{
  public static List<String> MY_PUBLIC_LIST;
  static{
    ArrayList<String> tmp = new ArrayList<String>();
    tmp.add("a");
    tmp.add("b");
    tmp.add("c");
    MY_PUBLIC_LIST = Collections.unmodifiableList(tmp);
  }
}
```
Que pouvez-vous faire dans ce cas ?

...

...

Eh bien, vous pouvez faire ce que vous voulez comme dans le premier cas (étant donné que vous attribuez à la nouvelle liste de la première) :
```
MyClass.MY_PUBLIC_LIST = null;
MyClass.MY_PUBLIC_LIST = new ArrayList<String>();
MyClass.MY_PUBLIC_LIST.clear();
MyClass.MY_PUBLIC_LIST.add("1");
```
OriginalL'auteur Cerber
8

Quand vous dites
```
final ArrayList list = new ArrayList();
```
cela signifie que la variable list pointe toujours à la même ArrayList objet. Il y a deux situations dans lesquelles cela peut être utile.
1. Vous voulez vous assurer que personne ne réassigne votre list variable une fois qu'il a reçu de sa valeur. Cela permet de réduire la complexité et de l'aide dans la compréhension de la sémantique de votre classe/méthode. Dans ce cas, vous sont généralement mieux en utilisant de bonnes conventions de nommage et de réduction de la méthode de la longueur (la classe/méthode est déjà trop complexe pour être facilement comprise).
2. Lors de l'utilisation de les classes internes vous avez besoin de déclarer les variables en tant que final dans un cadre englobant de sorte que vous pouvez accéder à l'intérieur de la classe. De cette façon, Java pouvez copier votre final variable dans l'intérieur de la classe de l'objet (il ne changera jamais sa valeur) et l'intérieur de la classe de l'objet n'a pas besoin de s'inquiéter de ce qui se passe à l'extérieur de la classe de l'objet, tandis que l'intérieur de la classe de l'objet est vivant et doit accéder à la valeur de cette variable.
La deuxième partie de votre question est à propos de la différence entre
```
ArrayList list = new ArrayList();
```
et
```
private static final ArrayList list = new ArrayList();
```
La différence de cours sont les modificateurs. private signifie pas visibles de l'extérieur de la classe, static signifie qu'elle est définie sur le niveau de la classe et n'a pas besoin d'une instance d'exister, et final est discuté ci-dessus. Pas de modificateurs de moyens colis-privé ou d'accès par défaut.

OriginalL'auteur eljenso
0

Vous dites "je peux ajouter, supprimer (et trouver) des objets", mais qui est je?

La différence entre vos deux cas, des préoccupations de qui code ces opérations sur la liste peut être appelé.

En général, vous devez tenir compte de la portée de la déclaration, vous augmentez considérablement la maintenabilité du code, si vous l'réduire la visibilité de vos variables. Si vous avez une classe:
```
Public Class MyThing {
   public int importantValue;

   //more code
}
```
Important que la valeur peut être modifiée par tout autre code, n'importe où ailleurs dans une application. Si au contraire vous rendre privé et de fournir un accesseur en lecture:
```
Public Class MyThing {
   private int importantValue;

   public int getImportantValue(){
       return importantValue;
   }

   //more code
}
```
vous le savez maintenant, seule la classe elle-même peut changer la valeur pour les grandes applications massivement augmente la facilité de maintenance. Afin de déclarer la liste privée des limites de ce code peut voir et modifier le contenu de la liste.

L'utilisation de la statique à la liste partagée par toutes les instances de la classe, plutôt que chaque instance de l'obtention de son ovn copie.

OriginalL'auteur djna

Vous devez vous connecter pour publier un commentaire.