Pourquoi la méthode toString() fonctionne différemment entre le Tableau et l'objet de liste de tableaux en Java

    String[] array = {"a","c","b"};
    ArrayList<String> list = new ArrayList<String>();
    list.add("a");
    list.add("b");
    list.add("c");
    System.out.println(array);
    System.out.println(list);

Pour list [a, b, c] est sortie alors que pour array certaines adresses est de sortie. Lorsque nous voulons à la sortie de la array des valeurs, on peut utiliser Arrays.toString(array);, qui fonctionne exactement comme list.

Je me demande juste pourquoi on ne peut pas appeler toString() directement sur array pour obtenir les valeurs. N'est-il pas plus intuitive et pratique de le faire? Quels sont les résultats sur les différents traitements sur Array et ArrayList?

OriginalL'auteur Terry Li | 2012-12-08

13

La principale différence entre un tableau et une liste de tableaux est qu'une arraylist est une classe qui est écrit en Java et a sa propre mise en œuvre (y compris la décision de remplacer toString) alors que les tableaux font partie de la spécification du langage lui-même. En particulier, la JLS 10.7 états:
Les membres d'un type tableau sont les suivantes:
- Le public final de la longueur de champ
- Le public de la méthode clone, qui remplace la méthode du même nom dans la classe de l'Objet et le jette pas vérifié exceptions.
- Tous les membres hérités de la classe de l'Objet; la seule méthode de l'Objet qui n'est pas héréditaire, c'est sa méthode clone.
En d'autres mots, le langage de spécification empêche la toString méthode d'un tableau à être surchargée et il utilise donc la valeur par défaut de mise en œuvre définies dans Object qui imprime le nom de la classe et hashcode.

Pourquoi cette décision a été faite est une question qui devrait probablement être demandé aux concepteurs de la langue...

Voir aussi cette réponse.

OriginalL'auteur assylias
4

Je me demande juste pourquoi on ne peut pas appeler toString() directement sur le tableau pour obtenir
les valeurs.

Fait toString méthode est appelée sur l'objet array. Mais, depuis le type de tableau ne remplace pas toString méthode de Object classe, donc par défaut la mise en œuvre de toString est invoquée, qui renvoie à la représentation de la forme que vous voyez.

La représentation est de la forme: -
```
[typeOfArray@hashCode
```
Dans votre cas, c'est quelque chose comme: -
```
[Ljava.lang.String;@3e25a5
```
Alors que, dans le cas de ArrayList cas, le remplacé toString méthode dans ArrayList classe est appelée.

OriginalL'auteur Rohit Jain
2

La réponse courte est parce que toString est définie dans un peu d'endroits différents, avec des comportements différents.

Les Tableaux de classe définit toString comme une méthode statique, être invoquée comme
```
Arrays.toString(arr_name);
```
Mais les Tableaux de classe hérite également de la non-statique méthode toString de la classe Object. Donc, si elle est appelée sur une instance, il appelle l'Objet.toString qui retourne une chaîne de caractères de la représentation de l'objet (par exemple: [Ljava.lang.Objet;@4e44ac6a)

Donc Des Tableaux.toString() et MyObject.toString() font appel à différentes méthodes avec le même nom.

La classe ArrayList hérite toString de la AbstractCollection classe, où il est un non méthode statique, donc peut être appelée sur l'objet comme:
```
MyArrayList.toString();
```
Parce que c'est une représentation de chaîne de la collection, et non un objet, le résultat est à valeurs dans un format lisible comme [un, deux].

OriginalL'auteur danf

Parce que lorsque vous imprimez toString(), il sera par défaut de l'impression className@HashCode.

Donc, lorsque vous imprimez array ci-dessus sera imprimé.

Mais ArrayList est extened par AbstractCollection classe et où le toString() méthode est surchargée comme ci-dessous

 public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }

qui imprime le format lisible de la ArrayList objet.

OriginalL'auteur Bhavik Ambani

C'est l'appel de la méthode toString pour ArrayList. Mais pour les Tableaux, vous ne pouvez pas trouver une telle.

 /**
 * Returns a string representation of this collection.  The string
 * representation consists of a list of the collection's elements in the
 * order they are returned by its iterator, enclosed in square brackets
 * (<tt>"[]"</tt>).  Adjacent elements are separated by the characters
 * <tt>", "</tt> (comma and space).  Elements are converted to strings as
 * by {@link String#valueOf(Object)}.
 *
 * @return a string representation of this collection
 */
public String toString() {
    Iterator<E> it = iterator();
    if (! it.hasNext())
        return "[]";

    StringBuilder sb = new StringBuilder();
    sb.append('[');
    for (;;) {
        E e = it.next();
        sb.append(e == this ? "(this Collection)" : e);
        if (! it.hasNext())
            return sb.append(']').toString();
        sb.append(',').append(' ');
    }
}

OriginalL'auteur Suranga

-1

Pour array toString() méthode qu'il imprime l'adresse de la mémoire. Mais dans ArrayList cette classe remplace Object toString() méthode .

toString() de la mise en œuvre de ArrayList

   public String toString() {
    Iterator<E> i = iterator();
    if (! i.hasNext())
        return "[]";

    StringBuilder sb = new StringBuilder();
    sb.append('[');
    for (;;) {
        E e = i.next();
        sb.append(e == this ? "(this Collection)" : e);
        if (! i.hasNext())
        return sb.append(']').toString();
        sb.append(", ");
    }
}

OriginalL'auteur kannanrbk

Vous devez vous connecter pour publier un commentaire.