Pourquoi la méthode toString() fonctionne différemment entre les objets Array et ArrayList en Java

Question

    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);

Para list [a, b, c] est émis alors que pour array une adresse est sortie. Lorsque nous voulons sortir l'adresse array nous pouvons 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 intuitif et plus pratique de procéder ainsi ? Quel est le résultat des différents traitements sur Array y ArrayList ?

Answer 1

La principale différence entre un tableau et une liste de tableaux est qu'une liste de tableaux est une classe écrite en Java et qui possède sa propre mise en œuvre (y compris la décision de remplacer le tableau par un autre). toString ) alors que les tableaux font partie de la spécification du langage lui-même. En particulier, le JLS 10.7 États :

Les membres d'un type de tableau sont tous les éléments suivants :

• Le champ final public longueur
• La méthode publique clone, qui remplace la méthode du même nom dans la classe Object et ne lève aucune exception vérifiée.
• Tous les membres sont hérités de la classe Object ; la seule méthode d'Object qui n'est pas héritée est sa méthode clone.

En d'autres termes, la spécification du langage empêche le toString d'un tableau et utilise donc l'implémentation par défaut définie dans la section Object qui imprime le nom de la classe et le code de hachage.

Pourquoi cette décision a été prise est une question qui devrait probablement être posée aux concepteurs du langage...

Answer 2

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

En fait, toString est appelée sur l'objet tableau. Mais, puisque le type tableau ne surcharge pas toString méthode de Object donc l'implémentation par défaut de la classe toString est invoquée, qui renvoie la représentation du formulaire que vous voyez.

La représentation est de la forme : -

[typeOfArray@hashCode

Dans votre cas, c'est quelque chose comme : -

[Ljava.lang.String;@3e25a5

Considérant que, en cas de ArrayList les instances superposées toString méthode dans ArrayList est invoquée.

Answer 3

La réponse courte est que toString est défini à plusieurs endroits différents, avec des comportements différents.

La classe Arrays définit toString comme une méthode statique, à invoquer de la manière suivante

Arrays.toString(arr_name);

Mais la classe Arrays hérite également de la méthode non statique toString de la classe Object. Ainsi, si elle est appelée sur une instance, elle invoque Object.toString qui renvoie une représentation de l'objet sous forme de chaîne de caractères (par exemple : [Ljava.lang.Object;@4e44ac6a]).

Ainsi, Arrays.toString() et MyObject.toString() appellent des méthodes différentes avec le même nom.

La classe ArrayList hérite de toString de la classe AbstractCollection, où il s'agit d'une méthode non statique, qui peut donc être appelée sur l'objet :

MyArrayList.toString();

Comme il s'agit d'une représentation sous forme de chaîne d'une collection et non d'un objet, le résultat est constitué des valeurs dans un format lisible comme [un, deux].

Answer 4

Parce que lorsque vous imprimez toString() il imprimera par défaut className@HashCode .

Donc, quand vous imprimez array alors le texte ci-dessus sera imprimé.

Mais ArrayList est prolongé par AbstractCollection et où le toString() est remplacée par la méthode suivante

 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 l ArrayList objeto.

Answer 5

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

 /**
 * 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(' ');
    }
}