[List] l'élément récurent

Version imprimable

24/07/2010, 15h58
Invité

[List] l'élément récurent

Bonjour Je voudrais trier ma list par éléments les plus fréquent.

exemple: pour des modèle de voiture, si la couleur la plus récurente de ma liste est le rouge puis le vert classer tout mes string qui ont une valeur rouge puis tout les string ayant une valeur verte.

Il y a t'il une méthode prédéfinie, sinon comment en crée une ?
24/07/2010, 16h07
tchize_

tu as Collections.sort(List,Comparator), a toi d'écrire ton Comparator qui correspond à tes critères ;)
24/07/2010, 16h58
Invité

d'accord je voudrais bien le faire, mais comment je m'y prend ?
24/07/2010, 17h18
tchize_

tu écrit un comparator qui correspond à tes critères et tu appelle cette méthode. Le comparator n'a qu'une seule méthode, ça devrais pas être bien dur.
24/07/2010, 18h48
divxdede

Les objets peuvent être comparables entre eux de 2 façons:
- Un tri naturel en implémentant l'interface Comparable
- Un tri délégué en injectant un Comparator donnant l'intelligence du tri au moment de l'effectuer.

Pour effectuer un tri naturel de tes objets au sein d'une collection, il suffit d'appeler la méthode Collections.sort(taCollection);

Pour effectuer un tri spécifique de tes objets au sein d'une collection, il faut donc plutôt appeler la méthode Collections.sort(taCollection,tonComparator);

Maintenant, que ce soit le tri naturel ou tri spécifique, l'implémentation doit être capable de donner un résultat de comparaison entre 2 objets sans connaitre les autres objets a comparer.

C'est pourquoi dans ton cas, je commencerais par échantillonnage de ta collection afin de mémoriser la distribution de la caractéristique (frequence de chaque couleurs de tes voitures) au sein de ta liste.
Puis il suffit d'écrire un Comparator utilisant cette distribution afin de comparer deux voitures.

Voilà j'ai fait autrement, en utilisant des listes classé par ordre alphabétique, dont une sans les doublons.

Malheureusement, j'ai du mal implémenté mes boucle donc j'ai pas le résultat souhaité, qui est l(es) élément(s) le plus récurent:
Si vous pouvez m'aidez pour mes boucles:

Code:

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
            int topCompteur=0;
            int nouveau =0;
 
 
            for(int i=0; i<listSet.size();i++){ //Boucle de la liste sans double
            	for(int j=0; j< color.size(); j++){ //Boucle de la liste Brut
            		boolean condition = color.get(j).equals(listSet.get(i));
            		if(color.get(j).equals(listSet.get(i))){
            			topCompteur++;
               		}
            		if(condition == false){
            			String actuel=color.get(j);
            			nouveau++;
            			boolean condition2 = color.get(j).equals(actuel);
            			if(condition2 == false)
            				break; //Je suppose que c'est ici que ca bloque
            		}
            	}   
            	if (topCompteur<nouveau){
            		topCompteur = nouveau;
            		top.clear();
            		top.add(color.get(i));
            	}
          	  if(topCompteur == nouveau)                                          
        		  top.add(color.get(i));   
 
            }

Voici un exemple vite fais:

Code:

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
public class Exemple {
 
    /** Interface permettant de récuperer la valeur d'un attribut d'un objet
     *  E = Type de l'objet sur lequel on récupere un attribut
     *  A = ype de l'attribut
     */
    public interface AttributeFetcher<E,A> {
 
        public A getAttribute(E element);
 
    }
 
    /** Comparator de collections permettant de trier sur la frequence d'apparition d'un attribut au sein des objets
     * @param <E> Type des objets triés au sein de la liste
     * @param <A> Type de l'attribut supporter l'analyse de la frequence d'apparition
     */
    public static class FrequencyAttributeComparator<E,A> implements Comparator<E> {
 
        private AttributeFetcher<E,A> fetcher      = null;
        private Map<A,Integer>        distribution = null;
 
        /** Constructeur
         * @param fetcher Implémentation deleguant l'intelligence de recuperer l'attribut d'un objet
         * @param list List utilisée pour calculer les frequences d'apparition
         */
        public FrequencyAttributeComparator(AttributeFetcher<E,A> fetcher , Collection<E> list ) {
            this.fetcher = fetcher;
 
            /** Création de la distribution
             */
            this.distribution = new HashMap<A,Integer>();
            for(E element : list ) {
                A attribute = element == null ? null : this.fetcher.getAttribute(element);
 
                Integer count = this.distribution.get(attribute);
                if( count == null ) count = 1;
                else                count = count + 1;
                this.distribution.put(attribute,count);
            }
        }
 
        /** Tri
         */
        public int compare(E o1, E o2) {
            if( o1 == o2 ) return 0;
            if( o1 == null ) return 1;
            if( o2 == null ) return 1;
 
            A a1 = fetcher.getAttribute(o1);
            A a2 = fetcher.getAttribute(o2);
 
            Integer i1 = this.distribution.get(a1);
            Integer i2 = this.distribution.get(a2);
            if( i1 == null || i2 == null )
                throw new IllegalStateException("Undistributed attribute value");
 
            return i1.compareTo(i2) * -1;
        }
    }
 
    /** Classe pour faire un exemple
     */
    public static class Car {
 
        Color   color = null;
        boolean withClimatisation = false;
 
        public Car(Color color , boolean withClimatisation ) {
            this.color = color;
            this.withClimatisation = withClimatisation;
        }
 
        public String toString() {
            return "Car[color=" + color + ", climatisation=" + withClimatisation + "]";
        }
    }
 
 
    /** Exemple
     */
    public static void main(String[] args) {
 
        List<Car> listATrier = new ArrayList<Car>();
        listATrier.add( new Car( Color.RED , true) );
        listATrier.add( new Car( Color.BLUE , true ) );
        listATrier.add( new Car( Color.WHITE , false ) );
        listATrier.add( new Car( Color.BLACK , false ) );
        listATrier.add( new Car( Color.BLACK , true ) );
        listATrier.add( new Car( Color.RED , true ) );
        listATrier.add( new Car( Color.YELLOW , false ) );
        listATrier.add( new Car( Color.RED , true ) );
 
        AttributeFetcher<Car,Color> colorFetcher = new AttributeFetcher<Car, Color>() {
 
            public Color getAttribute(Car element) {
                if( element == null ) return null;
                return element.color;
            }
        };
 
        Comparator<Car> comp = new FrequencyAttributeComparator<Car,Color>( colorFetcher , listATrier );
        Collections.sort( listATrier , comp );
 
        for(Car car : listATrier ) {
            System.out.println( car );
        }
    }
}

Ce qui donne le résultat suivant dans la console:

Code:

1
2
3
4
5
6
7
8
Car[color=java.awt.Color[r=255,g=0,b=0], climatisation=true]
Car[color=java.awt.Color[r=255,g=0,b=0], climatisation=true]
Car[color=java.awt.Color[r=255,g=0,b=0], climatisation=true]
Car[color=java.awt.Color[r=0,g=0,b=0], climatisation=false]
Car[color=java.awt.Color[r=0,g=0,b=0], climatisation=true]
Car[color=java.awt.Color[r=0,g=0,b=255], climatisation=true]
Car[color=java.awt.Color[r=255,g=255,b=255], climatisation=false]
Car[color=java.awt.Color[r=255,g=255,b=0], climatisation=false]

Le tri a donc donné les voitures rouges en 1er (il y en a 3) puis les voitures noir (il y en a 2)

Oula,...
Merci mais c'est pas vraiment mon objectif.
Mon objectif est beaucoups plus simple il consiste seulement a prendre la valeur ou les valeurs les plus récurentes.

Voilà mon code (entier) et j'aimerais que la valeur de retour soit rouge, vu que rouge apparait 5fois.
Le problème se trouve dans mes boucles mais je vois pas trop où.

Code:

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
 
 
 
public class StatisticsTest {
 
    public static void main(String[] args) {
 
    		HashSet<String> Set = new HashSet<String>();
    	    ArrayList<String> color = new ArrayList<String>();
    	    ArrayList<String> listSet = new ArrayList<String>();
    	    ArrayList<String> top = new ArrayList<String>();
    	    ArrayList<String> temp = new ArrayList<String>();
 
            color.add("Rouge"); //5Rouge
            color.add("Rouge");//4Bleu
            color.add("Rouge");//3Vert
            color.add("Vert");//2Jaune
            color.add("Bleu");
            color.add("Bleu");
            color.add("Jaune");
            color.add("Vert");
            color.add("Vert");
            color.add("Rouge");
            color.add("Rouge");
            color.add("Jaune");
            color.add("Bleu");
            color.add("Bleu");
 
            Set.addAll(color);
            listSet.addAll(Set);//On efface les doublon et on les remet sous forme de liste
 
            Collections.sort(listSet);
            Collections.sort(color);
 
            int topCompteur=0;
            int nouveau =0;
            int compteur = 0;
 
 
 
 
            for(int i=0; i<listSet.size();i++){ 	//Boucle de la liste sans doublons
 
            	for(int j=0; j< color.size(); j++){										//Boucle de la liste Brut
            		//System.out.println(listSet.get(i));
            		boolean nouveauElement = color.get(j).equals(listSet.get(i));
 
            		if(color.get(j).equals(listSet.get(i))){ 													//Si la list est égale au Set
            			compteur++;
            		}	
 
            			if (topCompteur==nouveau || topCompteur==compteur)
            				top.add(listSet.get(i));
 
            		if(nouveauElement == false){ 										//Si la liste n'est pas égale au Set
              			String suivant= color.get((i+1)); 								// on enregistre le suivant de la liste 
            			nouveau++;														
 
            			boolean condition2 = color.get(j).equals(suivant); 				// Si la liste est toujours égale a son suivant
 
            			if(condition2 == true)											//Si on passe à un 3éme élément : on sort de la boucle
            				break;
 
            	  }
            		if (topCompteur<nouveau || topCompteur<compteur){
 
            			topCompteur = (nouveau < compteur) ? compteur : nouveau;
            				top.clear();
            				top.add(listSet.get(i));
            			}
            	}   
            	  // System.out.println(color.get(i));
 
            }
 
            for(int j = 0; j < top.size(); j++){
            	System.out.println(top.get(j));
 
            }
 
    }
 
}