Discussion :

[alex_pi]

Bonjour à tous

Je voudrais écrire une fonction "map" sur les listes, c'est à dire une fonction qui attends en argument une fonction de A dans B et une liste de A et qui retourne une liste de B. J'ai écris le code suivant

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
28
29
30
31
32
import java.util.*;
 
interface F<A,B>{
    B app(A a);
}
 
class Map {
    static <A,B> LinkedList<B> map(F<A,B> f, LinkedList<A> l){
	LinkedList<B> l2= new LinkedList<B>();
	for (A e : l)
	    l2.add(f.app(e));
	return l2;
    }
 
 
}
 
public class Test{
 
    public static void main(String[] a)
    {
	LinkedList<Integer> l = new LinkedList<Integer>();
	l.add(1);
	l.add(2);
	l.add(3);
	l.add(4);
	LinkedList<Integer> l2 = Map.map(new F<Integer,Integer>(){
		public Integer app(Integer a){return a * a;}}, l);
	System.out.println(l);
	System.out.println(l2);
    }
}

et j'aimerais savoir si c'est acceptable comme façon de faire pour un programmeur Java ou s'il y a plus simple et élégant.

Merci d'avance !

[dinobogan]

et j'aimerais savoir si c'est acceptable comme façon de faire pour un programmeur Java

Non pour au moins une raison : les noms choisis ne permettent pas de comprendre leur utilité !
Il faut être plus explicite dans les noms de classes et de variables.

[adiGuba]

Salut,


Je trouve cela tout à fait acceptable dans les grandes lignes, même si j'aurais quelques remarques :

• Tu n'as spécifié aucun critère de visibilité. Je pense que c'est juste une simplification mais je tenais à le signaler...
• F c'est pas terrible comme nom d'interface Surtout cumuler avec des Generics. En général les termes d'une seule lettre sont réservé pour les Generics...
• De même pour tes noms de variables : l, l2, f, e ! C'est pas très clair tout cela : des noms plus clair rende le tout plus clair même sans documentation
• Même chose pour le nom de la classe : Map Cela risque de poser quelques soucis d'importation si tu utilises en même temps la classe standard java.util.Map. Autant éviter ce genre de soucis dès le début.
• Enfin j'aurais inversé les paramètres de la méthode map(). En effet à l'utilisation il est pratique d'utiliser une classe anonyme pour la fonction, et c'est plus clair lorsqu'il s'agit du dernier paramètre...
• Dernière petite astuce lié au Generics : utiliser LinkedList<? extends A> sur le paramètre. Cela te permet une gestion plus souple car le type "A" de la liste peut être un type fils de ta fonction "F", ce qui permet d'avoir des convertisseurs un peu plus générique...

Perso j'aurais fait cela comme ceci :

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
public interface Function<A,B>{
    public B convert(A a);
}
 
 
public class ListTools {
 
    public static <A,B> LinkedList<B> map(LinkedList<? extends A> list, Function<A,B> function){
    	LinkedList<B> resultList = new LinkedList<B>();
    	for (A a : list) {
    		resultList.add(function.convert(a));
    	}
    	return resultList;
    }
}

Maintenant le gros point noir qui ne gène encore dans ce code, c'est le typeage fort avec LinkedList. L'utilisation de List aurait été à privilégier, même si cela implique un peu de reflection sur la création de la liste :

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
class ListTools {
 
    public static <A,B> List<B> map(List<? extends A> list, Function<A,B> function){
    	List<B> resultList = createList(list.getClass());
    	for (A a : list) {
    		resultList.add(function.convert(a));
    	}
    	return resultList;
    }
 
    /**
     * Crée une Liste du type recu en paramètre (si possible),
     * ou une LinkedList le cas écheant.
     */
	@SuppressWarnings("unchecked")
	private static <T> List<T> createList(Class<? extends List> listClass) {
		try {
			return (List<T>) listClass.newInstance();
		} catch(Exception e) {
			return new LinkedList<T>();
		}
	}
}

La méthode est désormais utilisable avec n'importe quel type de List, et n'est plus arbitrairement limité aux LinkedList



Une autre solution envisageable serait de "sortir" la création de la liste et de se concentrer sur la copie. Bref de faire une méthode addAll(). L'avantage étant qu'on peut alors faire un pas de plus dans l'abstraction :

Code :

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

1
2
3
4
5
	public static <A,B> void addAll(Iterable<? extends A> source, Collection<B> dest, Function<A,B> function){
    	for (A a : source) {
    		dest.add(function.convert(a));
    	}
    }

a++