Bonjour,

J'ai un set d'objet ( arêtes d'un graphe ayant un poid ) que j'aimerai trier dans l'ordre croissant des poids.

J'utilise la méthode g.edgeSet() ce qui me retourne un set avec les aretes de mon graphe g :

[(12 : 15), (15 : 19), (12 : 2), (15 : 2), (2 : 12), (19 : 2)]

(a : b) avec a le sommet où part l'arete et b le sommet ou entre l'arete

Une idée ?

de facon generale un set n'est pas ordonne. donc il faut certainement pousse les aretes dans un truc ordonnable, probablement un array list. et apres trier l'arraylist en passant un comparateur quo va regarder le poids des arretes.

Le 19 mars 2019 à 18:24:53 godrik a écrit :
de facon generale un set n'est pas ordonne. donc il faut certainement pousse les aretes dans un truc ordonnable, probablement un array list. et apres trier l'arraylist en passant un comparateur quo va regarder le poids des arretes.

ok c'est ce que je pensais.

comment transférer un set dans une arraylist du coup ?

Comme indiqué par mon prédécesseur, un set de base n'est pas ordonné (https://stackoverflow.com/questions/10752753/java-set-retain-order ).
Tu peux donc soit passer par un ArrayList, soit utiliser LinkedHashSet qui implémente Set et qui semble conserver un ordre : https://docs.oracle.com/javase/7/docs/api/java/util/LinkedHashSet.html

J'ai testé par curiosité et ça semble fonctionner.

import java.util.Comparator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.stream.Collectors;

class Arrete {
    int poid;

    public Arrete(int poid) {
        this.poid = poid;
    }

    public int getPoid() {
        return poid;
    }

    @Override
    public String toString() {
        return "Poid: " + poid;
    }
}

class Scratch {

    public static void main(String[] args) {
        Set<Arrete> set = new LinkedHashSet<>();
        set.add(new Arrete(5));
        set.add(new Arrete(20));
        set.add(new Arrete(3));

        set.forEach(System.out::println);

        LinkedHashSet<Arrete> orderedSet = set.stream()
                .sorted(Comparator.comparing(Arrete::getPoid))
                .collect(Collectors.toCollection(LinkedHashSet::new));

        System.out.println("**************");

        orderedSet.forEach(System.out::println);
    }
}

Le premier foreach conserve l'ordre d'insertion --> affiche 5 20 3
Le second est ordonné grâce au stream en fonction du poid --> affiche 3 5 20

(Visiblement ca fait longtemps que je n'ai pas fait de java, il a fallu que je google la notation lambda.)

Le 19 mars 2019 à 21:44:36 godrik a écrit :
(Visiblement ca fait longtemps que je n'ai pas fait de java, il a fallu que je google la notation lambda.)

C'est pourtant plus si jeune les lambdas/streams en java

Mais effectivement, malgré les critiques qu'on peut lire sur ce langage, moi je trouve qu'il évolue pas mal, même si ça devient un peu le bordel avec leur nouveau système de release (on est déjà à java12...)

Ouais, c'est arrive en 2014. J'ai appris java a l'epoque ou il n'y avait pas de generic et d'autoboxing.

J'ai appris Java 2 a la fac en 2000. J'ai pas fait beaucoup de JAVA apres mon DEUG. Un peu ici et la, mais pas tant que ca.

Un des projet que j'ai expose une API pour des utilisateur Java et on supporte la compatibilite java 8. Mais le design en lui meme ne necessite pas de lambda. Donc j'ai jamais regarde comme ca marche.

Le 19 mars 2019 à 21:28:03 wouh_pinaise_ a écrit :
Comme indiqué par mon prédécesseur, un set de base n'est pas ordonné (https://stackoverflow.com/questions/10752753/java-set-retain-order ).
Tu peux donc soit passer par un ArrayList, soit utiliser LinkedHashSet qui implémente Set et qui semble conserver un ordre : https://docs.oracle.com/javase/7/docs/api/java/util/LinkedHashSet.html

J'ai testé par curiosité et ça semble fonctionner.

import java.util.Comparator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.stream.Collectors;

class Arrete {
    int poid;

    public Arrete(int poid) {
        this.poid = poid;
    }

    public int getPoid() {
        return poid;
    }

    @Override
    public String toString() {
        return "Poid: " + poid;
    }
}

class Scratch {

    public static void main(String[] args) {
        Set<Arrete> set = new LinkedHashSet<>();
        set.add(new Arrete(5));
        set.add(new Arrete(20));
        set.add(new Arrete(3));

        set.forEach(System.out::println);

        LinkedHashSet<Arrete> orderedSet = set.stream()
                .sorted(Comparator.comparing(Arrete::getPoid))
                .collect(Collectors.toCollection(LinkedHashSet::new));

        System.out.println("**************");

        orderedSet.forEach(System.out::println);
    }
}

Le premier foreach conserve l'ordre d'insertion --> affiche 5 20 3
Le second est ordonné grâce au stream en fonction du poid --> affiche 3 5 20

Le truc c'est que j'utillise la librairy JgraphT et donc je n'ai pas de classe arête, seulement une classe noeud

Bah ca change rien, il va te falloir une representation des aretes si tu veux pouvoir les lister dans l'ordre...

En regardant la javadoc de ta lib. C'est le type parametrique E de ton graph qui represente les arete.