web-dev-qa-db-fra.com

Qu'est-ce que cela signifie que les tableaux Java sont homogènes, mais pas les tableaux ArrayLists?

Si nous avons un Type [], nous ne pouvons y stocker que Type ou ses sous-types. Il en va de même pour ArrayList. Alors pourquoi dit-on que l'un est homogène alors que l'autre ne l'est pas?

javaarraysarraylistdata-structurescollections
13
lfk

Les tableaux ont une vérification d'exécution sur le type de l'élément ajouté. Autrement dit, si un nouvel élément qui n'est pas du même type est ajouté, un ArrayStoreException est lancé au moment de l'exécution. C'est pourquoi ils sont considérés comme "homogènes".

Ce n'est pas vrai pour ArrayLists (Lists en général). En raison de l'effacement du type lors de l'exécution, il peut pratiquement contenir n'importe quel objet.

Ce qui suit lève une exception lors de l'exécution:

Object[] array = new String[3];
array[0] = "a";
array[1] = 1;   // throws Java.lang.ArrayStoreException

contrairement à ce qui suit qui se compile et s'exécute sans problème (bien qu'avec un avertissement du compilateur car il n'utilise pas correctement les génériques):

ArrayList list = new ArrayList<String>();
list.add("a");
list.add(1);    // OK
list.add(new Object());  // OK

Avec une utilisation correcte des génériques, c'est-à-dire en déclarant la variable list ci-dessus de type ArrayList<String> au lieu de ArrayList, le problème est évité au moment de la compilation:

ArrayList<String> list = new ArrayList<String>();
list.add("a");
list.add(1);  // compilation error
list.add(new Object());  // compilation error

Mais même avec une liste déclarée génériquement, vous pouvez avoir quelque chose comme ce travail sans exception au moment de l'exécution:

ArrayList<String> list = new ArrayList<String>();
list.add("a");
Method[] methods = List.class.getMethods();
for(Method m : methods) {
    if(m.getName().equals("add")) {
        m.invoke(list, 1);
        break;
    }
}
System.out.println(list.get(0));
System.out.println((Object) list.get(1));

Sortie:

une

1

18
manouti

Oui .JavaArrays sont homogènes, car lorsque vous déclarez un tableau dans Java vous devez déclarer son type. Par exemple:

int arr[]; //type is int
    String arr[]; //type is String
    float arr[]; //type is float

maintenant, si vous essayez de stocker tout autre type de données dans un tableau déclaré, ce sera une erreur de compilation. par exemple:

 int arr=new int[5];
     arr[0]="I am a String not int"; //compile time error

mais ArrayList sont la partie de Collection, ils contiennent Objects, au lieu de tout data-type [si nous ne parlons pas de generics] , et parce que tout ce qui se trouve dans Java est directement ou indirectement hérité de Objectclass, il ne vous donnera donc pas de vérification de type compile-time error,. être sur run-time.

par exemple:

 ArrayList al=new ArrayList();//type is Object
    al.add("I am a String");  //Bacause String class in inherited from Object Class
    al.add(1);//the int 1 will first autobox into Integer class then stored in al ArrayList.Now bacause Integer class is also inherited from Object class,it will*/ allow you to store
    al.add(UserDefinedClass); //because every User defined class is also inherited from Object class,so it will also allow you.

Maintenant, vous l'avez remarqué, car nous n'avons défini aucun type de données de ArrayList al, Mais nous stockons toujours différentes valeurs de type: c'est pourquoi pourquoi ArrayList stocke Object des données non spécifiques -type, donc ils sont hétérogènes et non homogènes.

2
Mehraj Malik