Générifier du code

Version imprimable

Générifier du code

Salut,

je voudrais générifier ce code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
public static List listLength(List list) {
       ArrayList length=new ArrayList();
       for(int i=0;i<list.size();i++) {
         CharSequence seq=(CharSequence)list.get(i);
         length.add(seq.length());
       }
       return length;
     }
     public static void main(String[] args) {
       List l=Arrays.asList(args);
       System.out.println(listLength(l));
     }

J'ai fait ceci mais ça ne fonctionne pas

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.*;
 
public class Test<T>{
    public static List<T> listLength(List<T> list) {
	ArrayList<T> length=new ArrayList<T>();
	for(int i=0;i<list.size();i++) {
	    CharSequence seq=(CharSequence)list.get(i);
	    length.add(seq.length());
	}
	return length;
    }
 
    public static void main(String[] args) {
	List<String> l=Arrays.asList(args);
	System.out.println(listLength(l));
    }	    
}

Je voudrais aussi savoir comment ça se fait avec les wilcard

Merci

Code:

1
2
3
4
5
6
7
8
9
10
public static List<Integer> listLength(List<? extends CharSequence> list) {
    List<Integer> result = new ArrayList<Integer>();
    for(CharSequence seq : list)
        result.add(seq.length());
    return result;
}
 
public static void main(String... args) {
    System.out.println(listLength(Arrays.asList(args)));
}

Citation:

Envoyé par ®om

Code:

1
2
3
4
5
6
7
8
9
10
public static List<Integer> listLength(List<? extends CharSequence> list) {
    List<Integer> result = new ArrayList<Integer>();
    for(CharSequence seq : list)
        result.add(seq.length());
    return result;
}
 
public static void main(String... args) {
    System.out.println(listLength(Arrays.asList(args)));
}

Merci
En utilisant un type T, ça se passe comment ?

Salut,

Je n'ai rien à dire sur la solution de ®om qui est tout à fait correct, mais je voudrais juste signaler une implémentation différente qu'il est possible d'adopter pour ce style de méthode.

Au lieu de créer une nouvelle liste qui correspond à une image à un temps t de celle en paramètre, et qui comporte autant d'objet que la liste initial, on peut créer une simple List qui sert de "façade" pour accéder à la première.

C'est un peu plus "complexe" à écrire mais cela apporte un avantage certain : la seconde liste est toujours à jour par rapport au contenu de la première.

Pour cela il suffit de faire une inner-classe qui étend AbstractList en implémentant les méthode size() et get() :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public static List<Integer> listLength(final List<? extends CharSequence> list) { return new AbstractList<Integer>() { @Override public Integer get(int index) { return list.get(index).length(); } @Override public int size() { return list.size(); } }; }
Ces deux méthodes ne font quasiment que déléguer les appels vers la liste initial, ce qui fait que les données sont toujours à jour ;)

a++

08/11/2006, 13h50
adiGuba
Citation:

Envoyé par Premium

En utilisant un type T, ça se passe comment ?

Sinon comme il s'agit d'une méthode static, elle ne prend pas en compte les types paramétrées de la classe mais seulement ceux que tu définis dans la déclaration de la méthode :
Code:

1 2 3 4 class Test { public static <T extends CharSequence> List<Integer> listLength(List<T> list) { ...
Mais ici cela n'a aucun intérêt puisque la valeur de retour n'utilise pas le type T... donc la déclaration de ®om est bien meilleur (et plus lisible).

a++
15/11/2006, 16h23
Premium

Merci pour les réponses.
ESt-ce que quelqu'un pourrait me dire à quoi sert la constante Collections.EMPTY_LIST et comment l'utiliser dans la méthode listLength ?