Discussion :

[®om]

Je me pose 2 questions sur l'API java:

La 1ère: Pourquoi ont-ils fait un constructeur String(String original) (de recopie), vu que String est immutable?

La 2ème: Quel est l'intérêt de l'interface Enumeration, sachant qu'Iterator fait la même chose, et en mieux (car on peut utiliser le foreach)? Au moins Enumeration devrait etendre Iterable...

En fait je pense avoir trouvé tout seul la réponse à la 2e question, c'est sans dout parce qu'Enumeration date de JDK 1.0 et Iterator JDK 1.2...


Mais cela me fait penser à une autre question:
2ème bis: Dans l'interface Iterator, il y a void remove(), ce que je n'avais jamais remarqué et qui peut être très pratique. Est-il possible de l'utiliser avec un foreach, ou faut-il obligatoirement déclarer son Iterator "manuellement"?

[spekal]

Je me pose 2 questions sur l'API java:

La 1ère: Pourquoi ont-ils fait un constructeur String(String original) (de recopie), vu que String est immutable?

Le javadoc répond très clairement à cette question :

Unless an explicit copy of original is needed, use of this constructor is unnecessary since Strings are immutable.

À moins que l'on ait besoin d'une copie explicite de l'original, l'usage de ce constructeur n'est pas nécessaire puisque les Strings sont immuables.

Autrement dit ça ne sert à rien sauf quand ça sert à quelque chose, c'est le javadoc qui le dit.

[adiGuba]

Salut,

La 1ère: Pourquoi ont-ils fait un constructeur String(String original) (de recopie), vu que String est immutable?

Pour allouer de la mémoire inutilement

Peut-être pour les gros parano qui ont peur que la String soit modifié via l'API de reflection (ce qui est possible)...

La 2ème: Quel est l'intérêt de l'interface Enumeration, sachant qu'Iterator fait la même chose, et en mieux (car on peut utiliser le foreach)? Au moins Enumeration devrait etendre Iterable...

En fait je pense avoir trouvé tout seul la réponse à la 2e question, c'est sans dout parce qu'Enumeration date de JDK 1.0 et Iterator JDK 1.2...

C'est tout à fait cela. Enumeration fait partie des premières "classes" de Java, tout comme Vector et Hashtable...

Or avec Java 1.2 est apparut l'API de Collection, avec les interfaces Collection, List, Map, Set etla plupart des implémentations (ArrayList, LinkedList, HashMap, TreeMap, LinkedSet).
L'Iterator a remplacé les Enumeration, mais cette dernière interface n'est pas déprécié car elle est toujours utilisé dans pas mal ce classe de l'API standard (et non-standard d'ailleurs).


Enumeration ne peut pas étendre Iterator car les noms ne sont pas les mêmes ( hasMoreElement() contre hasNext(), etc. ) et qu'elle ne possèdent pas de méthode remove().
Iterator a justement été conçus pour raccourcir les noms des méthodes et permettre la suppression d'élément...

De plus tu ne peux pas rajouter des méthodes dans une interface sans casser la compatibilité !!!


Perso j'utilise une classe conteneur qui "transforme" une Enumeration en Iterable/Iterator selon le besoin, en particulier pour l'utiliser dans un foreach :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class IterableEnumeration<T> implements Iterable<T>, Iterator<T> {
 
    private final Enumeration<T> enumeration;
 
    public IterableEnumeration(Enumeration<T> e) {
        this.enumeration = e;
    }
 
    public Iterator<T> iterator() {
        // Attention : contrairement à un vrai Iterable,
        // rappeller cette méthode ne renvoit pas un nouvel Iterator
        return this;
    }
 
    public boolean hasNext() {
        return IterableEnumeration.this.enumeration.hasMoreElements();
    }
 
    public T next() {
        return IterableEnumeration.this.enumeration.nextElement();
    }
 
    public void remove() {
        throw new UnsupportedOperationException("remove() not supported by Enumeration");
    }
 
}

Mais cela me fait penser à une autre question:
2ème bis: Dans l'interface Iterator, il y a void remove(), ce que je n'avais jamais remarqué et qui peut être très pratique. Est-il possible de l'utiliser avec un foreach, ou faut-il obligatoirement déclarer son Iterator "manuellement"?

Non tu dois utiliser l'Iterator de manière standard... :'(

a++

[®om]

Enumeration ne peut pas étendre Iterator car les noms ne sont pas les mêmes ( hasMoreElement() contre hasNext(), etc. ) et qu'elle ne possèdent pas de méthode remove().

Je parlais d'étendre Iterable (et donc d'avoir une méthode iterator()), mais ça revient à la classe que tu as donné .

De plus tu ne peux pas rajouter des méthodes dans une interface sans casser la compatibilité !!!

Ce qui empêche d'étendre Iterable.

Non tu dois utiliser l'Iterator de manière standard... :'(

OK, merci

[adiGuba]

Au passage je viens de réaliser qu'il y a un moyen plus simple pour transformer une Enumeration en Iterable : c'est de la transformer en List avec Collections.List() :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
        Enumeration<Object> enumeration = UIManager.getDefaults().keys();        
        for (Object o : Collections.list(enumeration)) {
            System.out.println(o);
        }

a++

[bouye]

Pas forcement, ca cree une nouvelle liste et donc on pert tout lien avec la collections pointee par l'Enumeration (en cas de changements dans un envirronement multi-threade par exemple). Je preferre ta classe a toi.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    /**
     * Returns an array list containing the elements returned by the
     * specified enumeration in the order they are returned by the
     * enumeration.  This method provides interoperability between
     * legacy APIs that return enumerations and new APIs that require
     * collections.
     *
     * @param e enumeration providing elements for the returned
     *          array list
     * @return an array list containing the elements returned
     *         by the specified enumeration.
     * @since 1.4
     * @see Enumeration
     * @see ArrayList
     */
    public static <T> ArrayList<T> list(Enumeration<T> e) {
        ArrayList<T> l = new ArrayList<T>();
        while (e.hasMoreElements())
            l.add(e.nextElement());
        return l;
    }

[adiGuba]

Pas forcement, ca cree une nouvelle liste et donc on pert tout lien avec la collections pointee par l'Enumeration (en cas de changements dans un envirronement multi-threade par exemple). Je preferre ta classe a toi.

Ben le problème reste le même puisqu'il me semble que les Enumeration (comme les Iterator) doivent être parcouru de manière exclusive (sans qu'un autre Thread ne modifie le contenu de la collection)...

De plus ma classe ne respectent pas totaltement l'interface Iterable puisque la méthode iterator() ne renvoit pas un nouvel Iterateur à chaque fois...

a++