IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Collection et Stream Java Discussion :

Comment trier des cartes, tri d'array


Sujet :

Collection et Stream Java

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Décembre 2014
    Messages
    3
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Décembre 2014
    Messages : 3
    Par défaut Comment trier des cartes, tri d'array
    Bonjour les Developpezeurs, Voici mon tout premier post
    J'ai commencé Java il y a une semaine ( ou peut etre deux...), j'ai appris le C/C++ quand j'étais plus jeune, puis jai eu la chance de retomber dessus en cours et donc je connais (un peu) la programmation (je m etais arrêté aux fonctions).

    Je me suis lancé dans Java et apres plusieurs exercices j'ai eu envi de faire quelque chose d'un peu personnel.
    Un jeu a boire :

    Donc le concept est repris d'un jeu de carte, vous tirez chacun votre tour une carte et celle-ci correspond à un acte à faire ou un truc à boire enfin ca on s'en fiche.

    Je ne suis pas encore bon en POO donc ce que je vais demander c'est:
    - Est-ce que je m'y prend bien (ma création de classe est elle bonne) ?
    - Ma methode de tri est elle bonne (j'en doute) ?
    - J'ai un problème avec le return d'array dans une fonction et l'utilisation de cet array retourné pour une autre fonction.

    STRUCTURE :
    drinkgame (Main)
    Cartes (class)

    drinkgame : s'occupe de lancer Cartes et de faire passer les tours
    Cartes : s'occupe d'initialiser un tas de carte (array) de le trier et de le basculer dans un autre array (est ce une bonne idée?)
    Cartes aura egalement une fonction piocherUneCarte pour chaque tours.

    CODE :
    Donc moin Main :
    Celui-ci n'est pas fini mais je pense qu'il appelera juste ma class carte pour l'initialiser et ensuite piocher des cartes
    Etant aussi peu utile... est ce vraiment interressant de faire une class Carte ou ne devrais je pas plutot tout mettre dans le main ?

    drinkgame MAIN :
    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
     
    import java.util.Scanner;
    public class drinkgame {
     
    	public static void main(String[] args) {
     
     
    		int numOfCard = 30;                                      // nombre de carte 30 Pour tester
    		int i,y;                                                        // en cas de besoin pour les boucles :)
    		Scanner sc  = new Scanner(System.in);
                     String reponse = new String();
     
                    Cartes cards = new Cartes(numOfCard);         // on creer un packet
                        for (i = 0; i < numOfCard ; i++) {              
                                piocherUneCarte(carte[i]);                              // on pioche une carte                      ************************** Est ce une bonne facon de faire ? **********************
                                System.out.println("Voulez vous repiocher une carte ? Entrer" )
                                reponse = sc.nextline();
     
    	}
     
    }

    Classe Cartes :

    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
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
     
     
    public class Cartes {
    	public int numOfCard; // Valeur d initiation des cartes
    	public int i =0;
     
     
    	//****************************************** CONSTRUCTEUR **************************************************************
    	public Cartes(int numOfCard){
    		this.numOfCard = numOfCard;
    		this.inititPacket();               //                             JE NE SUIS PAS DU TOUT SURE DE
    		trierCartes(carte);              //                               CES DEUX LIGNES Là
    	}
     
     
    	// ***************************************** INITIALISATION DU PACKET **************************************************
    	public int[] inititPacket(){
            int carte[] = {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};            // J'ai fais ce pacquet juste pour exemple je voulais voir si mon code tirait deux fois la meme carte
    		return carte;
    	}
     
     
    	// ***************************************** TRIAGE DU PACKET **********************************************************
    	public int[] trierCartes(int[] carte){                                                //                     QUE PENSEZ VOUS DE CETTE LIGNE ?
    		boolean tirage[] = new boolean[numOfCard]; 
    		int carteTrie[] = new int[numOfCard];
    		Random rn = new Random();
     
    		for(i=0; i < numOfCard ; i++){                                        //                                       LE PB DE CE FOR c'est que il ne tombera pas sur toutes les cartes et il reste donc des cases vide dans mon packettrier...
     
    			int aleatoir = rn.nextInt(numOfCard);
     
    			if (tirage[aleatoir])
    			{
    		    System.out.println(carte[aleatoir]); // test pour visionner (A SUPPRIMER QUAND PROGRAMME FINI)
    			tirage[aleatoir]=false;
    			carteTrie[i] = carte[aleatoir]; // NOUVEAU TAS TRIER
    			}
     
    		}
     
    		for(int z = 0; z < carteTrie.length ; z++){   // AFFICHER LE TAS (A SUPPRIMER QUAND PROGRAMMME FINI)
    			System.out.print(carteTrie[z] +",");
    		}
    	return carteTrie; // On retourne la packet trier
    	}
     
     
    	// **********************************************  PIOCHER UNE CARTE *********************************************
    	public int piocherUneCarte(int[] carte){
    		return null;  // PAS ENCORE FAIT
    	}
     
    	// FIN 
    }

    Bon il n'y a pas de caractere d'urgence donc si quelqu'un a le temps de jeter un oeil, un grand merci. J'espere avoir posté au bon endroit. J'ai cherché sur plusieurs sites comment faire et j'ai fini par me dire que finalement je devrais trouver la réponse, je pense avoir une bonne piste mais je pense qu'il suffit d'un petit quelque chose pour débloquer mon triage.

    Puis pour la structure de mon programme, je débute la POO donc si vous pouviez me conseiller...

    Merci les developpezeurs

  2. #2
    Membre confirmé Avatar de maelstrom
    Homme Profil pro
    Développeur Java
    Inscrit en
    Mars 2014
    Messages
    108
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : France, Haute Savoie (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : Finance

    Informations forums :
    Inscription : Mars 2014
    Messages : 108
    Par défaut
    Salut,

    Alors je vais prendre un a un les petits problèmes que je vois comme ça me vient à l'esprit, donc pas forcément dans l'ordre.

    Tout d'abord la déclaration de tes variables int i et y. Pas besoin de les déclarer si tu as besoin d'une variable pour une boucle for fait comme ceci :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    for(int i=0; i < numcard; i++)
    {}
    Tu as le droit de déclarer ta variable dans le for, celle-ci ne sera disponible que pendant la boucle, et donc si tu as un autre for il faudra la re déclarer. Comme ça pas besoin d'avoir au début de chaque programme la déclaration de 36000 variables pour les boucles.

    Ensuite concernant la POO, personnellement j'aurais plutôt vu quelque chose comme ceci :

    -Une classe Carte dans laquelle il y a un constructeur Carte avec son numéro et sa couleur.
    -Une classe PaquetCarte qui est une classe composé de carte, donc un constructeur avec un tableau ou une liste de carte. (Je pense qu'une liste serait mieux ici).
    -Et ta classe DrinkGame qui sera ton main.

    Ce qui nous donnerait quelque chose comme ceci :

    class Carte
    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
    public class Carte
    {
    	private int numOfCard; //Valeur allant de 1 à 13 (11, 12, 13 = valet, dame, roi)
    	private int color; //Oui un int pour la couleur (allant de 1 à 4, 1=coeur, 2=pique, 3=carreau, 4=trefle, par exemple)
    	//int car plus rapide à tester qu'un String, il faut juste bien écrire dans les commentaires quoi correspond à quoi
     
    	public Carte(int numOfCard, int color)
    	{
    		this.setNumOfCard(numOfCard);
    		this.setColor(color);
    	}
     
    	public int getNumOfCard() {
    		return numOfCard;
    	}
     
    	public void setNumOfCard(int numOfCard) {
    		this.numOfCard = numOfCard;
    	}
     
    	public int getColor() {
    		return color;
    	}
     
    	public void setColor(int color) {
    		this.color = color;
    	}
    }
    Tu remarqueras que j'ai privilégié des private plutôt que public, je fais cela pour contrôler l'accès à mes variables.

    class PaquetCarte :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    import java.util.ArrayList;
     
    public class PaquetCarte
    {
    	public ArrayList <Carte> carte = new  ArrayList <Carte>();
     
    	public PaquetCarte(ArrayList <Carte> carte)
    	{
    		this.carte = carte;
    	}
     
    	//Après tu peux créer des fonction comme ajouterCartePaquet, retirerCartePaquet, creerPaquet30Carte, creerPaquet54Carte
    	//Enfin ce que tu veux qui agit sur le paquet
    }
    ta class DrinkGame :
    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
    import java.util.ArrayList;
     
    public class DrinkGame
    {	
    	public static void main(String[] args)
    	{
    		// TODO Auto-generated method stub
    		ArrayList <Carte> paquet = new  ArrayList <Carte>();
    		PaquetCarte paquetCarte = new PaquetCarte(paquet);
     
    		/*Bon après ici tu fais ce que tu veux
    		 * Tu peux utiliser les fonctions que tu auras créer dans ta classe sur ton paquetCarte
    		 * Comme par exemple si tu as crer une fonction qui met 54 cartes dans ton paquet tu n'auras qu'à appeler cette fonction en faisant
    		 * paquetCarte.NomDeLaFonction();
    		 * Et ton paquet aura 54cartes
    		 * Après tu peux créer fonction piocher une carte enfin tout ce que tu veux*/
    	}
    }
    Voilà j'ai mis des commentaires pour t'aider un peu, mais en gros toutes tes fonctions doivent se trouver dans la classe PaquetCarte. C'est pareil pour le trie des cartes, il faut créer une fonction dans la classe PaquetCarte dans laquelle tu envoies une liste et elle te renvoie une liste trié (le tri sera facilité par l'utilisation des list, des fonctions existes il me semble).

    Je ne sais pas si je suis très clair dans mes explications, si jamais tu as une question n'hésite pas, et puis n'oublie pas que c'est une façon de faire, il peut y en avoir d'autre

  3. #3
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    Septembre 2009
    Messages
    12 430
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 55
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2009
    Messages : 12 430
    Billets dans le blog
    2
    Par défaut
    Salut,

    A noter que pour mélanger les cartes (parce que vu ta fonction de tri, il semblerait qu'il s'agit plus de les mélanger), tu peux utiliser directement la méthode utilitaire Collections.shuffle(taliste).

    Par contre, pour les couleurs, j'aurais utilisé plutôt une enum (ça évite déjà d'avoir à mettre des commentaires pour dire que 1 c'est cela, 2 c'est ceci...et ça évite d'avoir à se souvenir (parce que ces commentaires, on va pas les mettre partout)) :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    public enum Couleur {
    PIQUE, 
    COEUR,
    TREFLE,
    CARREAU
    }
    et
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    private Couleur couleur;
    Pour initialiser le jeu de carte :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public List<Carte> creerPaquetDeCarteMelangees() { 
       List<Carte> cartes = new ArrayList<>();
       for(Couleur couleur : Couleur.values()) {
     
          for(int i=0; i<MAX_VALEUR_DE_CARTE; i++) {
     
            cartes.add( new Carte( i, couleur) );
     
          }
     
       }
       Collections.shuffle(cartes);
       return cartes;
    }
    A noter, qu'il vaut mieux manipuler un List<Carte>, même si on l'initialise par un ArrayList<> : ceci permet ensuite, de ne plus s'attacher à son implémentation concrète, mais uniquement aux méthodes qui nous intéressent, celles de liste. Par la suite, on peut changer ArrayList par un autre type de List, qu'on pourrait trouver plus adapté, sans tout changer dans le code, y compris à un endroit particulier du code (par exemple, par la classe Stack, qui pourrait être utilisée pour simuler un tas dans lequel on pioche, par sa méthode pop()).
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

  4. #4
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Décembre 2014
    Messages
    3
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Décembre 2014
    Messages : 3
    Par défaut Bonjour et merci :)
    Helloo merci pour les infos !

    J'ai bien suivi vos indications, par contre je n'ai pas encore vu les énumérations alors je ne vais pas les utiliser.

    J'ai bien fais 2 classes, une pour les cartes et une pour les paquets et j'ai bien compris pourquoi et l'idée.
    j'ai mis la fonction creerPaquetDeCarteMelangee(); dans la class PaquetCarte

    Collections.shuffle(cartes);
    return cartes;
    }

    Ma question est, comment je récuperes le "return cartes;" dans mon main.
    J'ai essayé ca:
    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
    33
     
    public class drinkgame {
     
    	public static void main(String[] args) {
     
     
    		int numOfCard = 54;
     
    		ArrayList <Cartes> paquet = new ArrayList <Cartes>();
    		PaquetCartes paquetCarte = new PaquetCartes(paquet);
     
    		paquetCarte.creerPaquetDeCarteMelangees();
     
     
    		   for(int y =1; y <= 4; y++) {
     
    			      for(int i=0; i< 54; i++) {
     
    			       System.out.printlnt(cartes[i][y]); // Afficher mon joli paquet
     
    			      }
     
    			   }
     
    			}
     
     
     
     
    	}
     
     
    }
    mais eclipse me dit que je dois déclarer la variable cartes.
    j'ai essayé paquetCarte.cartes[i][y] et PaquetCartes.cartes[i][y]; ....

    PS: Merci pour l'astuce du INT dans la boucle.

  5. #5
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    Septembre 2009
    Messages
    12 430
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 55
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2009
    Messages : 12 430
    Billets dans le blog
    2
    Par défaut
    Si tu utilises une ArrayList pour modéliser un paquets de cartes, tu ne peux plus y accèder comme un tableau à 2 dimensions comme tu fais dans System.out.printlnt(cartes[i][y]);. On pourrait convertir la liste en tableau, mais la liste est plus simple pour gérer un paquet de cartes, en particulier, si tu vas en enlever du paquet.

    Pour accéder à un élément de List, on utilise la méthode get(index) au lieu de tableau[index].

    Par contre, je ne vois pas pourquoi tu as un tableau à 2 dimensions, dont l'une fait 54 de longueur : tu as 4 jeux de 54 cartes à afficher ?

    Ensuite pour récupérer le résultat de creerPaquetDeCarteMelangees(), il suffit d'écrire :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    ArrayList<Cartes> cartes = paquet.creerPaquetDeCarteMelangees();
    D'autre part, l'idée de la classe de @maelstrom, était, je suppose de construire la liste des cartes en dehors de la classe puis de la passer au constructeur de la classe :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    List<Cartes> cartes = new ArrayList<Cartes>();
     
    for(int couleur=0; couleur<4; couleur++) { // pour chaque couleur
        for( int valeur=0; valeur<14; valeur++ ) { // pour chaque valeur
            cartes.add( new Carte(valeur, couleur) );
        }
    }
    Attention, ceci donne un jeu de 52 cartes. Pour avoir 54, il faudrait ajouter 2 jokers, qui n'ont pas vraiment de couleur : mais tu peux utiliser la couleur 5 pour te simplifier la chose, mais ce n'est pas forcément le plus simple à gérer ensuite (pour associer une image par exemple) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    cartes.add( new Carte(0, 5) ); // ajoute un joker
    cartes.add( new Carte(1, 5) ); // ajoute un second joker
    Si ta classe Paquet n'a pour but que d'avoir la méthode createPaquetDeCarteMelangees(), elle ne sert pas à grand chose : autant la supprimer, et mélanger directement les cartes après les avoir créées :

    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
    List<Cartes> cartes = new ArrayList<Cartes>();
     
    for(int couleur=0; couleur<4; couleur++) { // pour chaque couleur
        for( int valeur=0; valeur<14; valeur++ ) { // pour chaque valeur
            cartes.add( new Carte(valeur, couleur) );
        }
    }
    cartes.add( new Carte(0, 5) ); // ajoute un joker
    cartes.add( new Carte(1, 5) ); // ajoute un second joker
     
    // avant l'ordre des cartes correspond à leur ordre de création, donc 14 cartes de couleur 0, suivis de 14 cartes de couleur 1, etc.
    Collections.shuffle(cartes);
    // maintenant les cartes sont mélangées
     
    // on peut pour les afficher, par exemple faire :
     
    for(Carte carte : cartes) { // signifie parcourir toute la liste de cartes, et pour chaque carte avoir une variable "carte" de type Carte.
     
       System.out.println(carte); // on affiche la carte
     
    }
    Si tu désires conserver la classe Paquet, pour lui ajouter des méthodes, du type piocherUneCarte() par exemple, autant mettre directement le code de création dans son constructeur :

    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
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    public class Paquet {
     
         private List<Carte> cartes;
     
        public Paquet() {
             cartes = new ArrayList<Cartes>();
     
             for(int couleur=0; couleur<4; couleur++) { // pour chaque couleur
                 for( int valeur=0; valeur<14; valeur++ ) { // pour chaque valeur
                    cartes.add( new Carte(valeur, couleur) );
                 }
             }
             cartes.add( new Carte(0, 5) ); // ajoute un joker
              cartes.add( new Carte(1, 5) ); // ajoute un second joker
        }
     
        public List<Carte> getCartes() {
             return cartes;
        }
     
         public void melanger() {
             Collections.shuffle(cartes);
         }
     
         public int getTailleDuJeu() {
             return nombre;
         }
     
         public int getNombreDeCarteDansLePaquet() {
             return cartes.size();
         }
     
         public boolean estVide() {
              return cartes.isEmpty();
         }
     
         public Carte piocher() {
              if ( cartes.isEmpty() ) { // si cartes est vide
                  throw new NoSuchElementException("Plus de cartes disponible");
              }
              return cartes.remove(0); // on retire la première et on la retourne à l'appelant
         }
     
    }
    Et pour l'appeler :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    Paquet paquet = new Paquet();
    paquet.melanger();
    List<Carte> cartes = paquet.getCartes();
    // ou :
    Carte carte = paquet.piocher();
    // ou :
    while( !paquet.isEmpty() ) {
        Carte pioche = paquet.piocher();
        ...
    }
    Avec cette classe, tu peux par exemple envisager une variante comme ça :
    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
    33
    34
    35
    36
    37
    38
    39
    40
    41
    public class Paquet {
     
        private int nombre;
        private List<Carte> cartes;
     
        public Paquet(int nombre) {
            if (nombre==54 || nombre==52 ) {
               this.nombre=nombre;
               creer();
            }
            else {
               throw new IllegalArgumentException("Je ne sais gérer que des jeux de 52 ou 54 cartes");
            }
        }
     
        // recréer un jeu tout neuf, pas mélangé
        public void creer() { 
     
             cartes = new ArrayList<Cartes>();
     
             for(int couleur=0; couleur<4; couleur++) { // pour chaque couleur
                 for( int valeur=0; valeur<14; valeur++ ) { // pour chaque valeur
                    cartes.add( new Carte(valeur, couleur) );
                 }
             }
             if ( nombre==54 ) {
                cartes.add( new Carte(0, 5) ); // ajoute un joker
                cartes.add( new Carte(1, 5) ); // ajoute un second joker
             }
     
        }
     
        public List<Carte> getCartes() { 
             return cartes;
        }
     
         public void melanger() {
             Collections.shuffle(cartes);
         }
     
    }
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

  6. #6
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Décembre 2014
    Messages
    3
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Décembre 2014
    Messages : 3
    Par défaut Merciii
    Merci pour toutes ces infos, je vais me mettre au boulot :p

Discussions similaires

  1. Réponses: 11
    Dernier message: 18/02/2009, 16h39
  2. Comment trier des dates au format 22/11/2008?
    Par jolzeviking dans le forum Macros et VBA Excel
    Réponses: 9
    Dernier message: 30/06/2008, 16h06
  3. Réponses: 7
    Dernier message: 31/10/2007, 16h42
  4. [C#] Comment trier des items d'un TreeView
    Par sorcer1 dans le forum C#
    Réponses: 2
    Dernier message: 21/03/2007, 10h53
  5. [C#] Comment trier des des ListViewGroup
    Par sorcer1 dans le forum Windows Forms
    Réponses: 1
    Dernier message: 08/02/2007, 18h11

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo