Pile

Merci pour ton aide KX,
par rapport à ma manipulation de la pile, ceci est du au fait que j'ai lu quelque part que la pile héritait des méthodes des vecteurs et aussi que pop retirait l'objet au sommet d'une pile et le retournait coe une variable (ce que je n'ai pas compris d'ailleurs).
Mais mon soucis actuel c'est: comment utiliser cette méthode dans mon main pour afficher le nombres d'employé?
Thnks in advance!!!

"la pile héritait des méthodes des vecteurs"
C'est parce que tu utilises la classe Stack qui hérite effectivement de Vector, mais du coup ce n'est pas vraiment une pile, c'est un tableau que l'on utilise comme une pile. Mais toi ce que tu fais c'est que tu l'utilises comme un tableau, du coup tu as un tableau utilisé comme un tableau, et tu fais complètement disparaître l'aspect pile de ton problème.
Remarque : Stack n'est certainement pas la meilleure classe pile à utiliser en terme de performance, à cause justement du fait que c'est en fait un Vector.

"pop retirait l'objet au sommet d'une pile et le retournait coe une variable"
C'est le principe même d'une pile. Sur une pile (d'assiettes par exemple) tu ne peux accéder qu'à l'élément le plus au dessus. Si tu veux accéder aux éléments qui sont en dessous tu dois d'abord enlever un à un les éléments du dessus. C'est pour ça que des méthodes comme get(i) ne correspondent pas du tout à la structure d'une pile, puisque sur une pile on ne peut pas accéder à l'élément i sans avoir au préalable enlever les (i-1) éléments d'avant !

"comment utiliser cette méthode dans mon main"
Il faudrait déjà que tu ais une pile dans ton main, or tu n'en as aucune pour l'instant !
Une manière simple de faire, ce serait de changer demoPile (pour l'instant elle se contente de l'afficher) afin qu'elle fournisse une pile en retour au lieu d'avoir juste void.
Tant qu'on y est, on remplace les "add" pour les remplacer par des "push" qui est une opération de pile alors que "add" non.... Remarque : au final ces deux méthodes font exactement la même chose dans la classe Stack, mais dans des classes de piles qui ne sont pas basé sur des tableau le comportement pourrait être différent (sur des listes par exemples).

public static Stack<Employe> demoPile()
{
    Stack<Employe> s = new Stack<Employe>();
    s.push(new Permanent("123 456 789", "Charbonneau Hélène", 10, false));
    s.push(new Permanent("222 333 444", "Tremblay Jacques", 23, true));
    s.push(new Contractuel("987 654 123", "Chester Thompson", 19, 25, 92.25));
    s.push(new Contractuel("333 123 189", "Laplante Lise", 3, 58, 25.50));
    return s;
}

Dans ton main tu n'as alors plus qu'à faire ceci :

public static void main (String[] args)
{
    System.out.println("--------************************--------------\n");
     
    Stack<Employe> stack = demoPile();
    afficher(stack, " après la création");
    
    int n = nbrNAS123(stack);
    afficher(stack, " après le compte des NAS 123");
    
    System.out.println("-----Nombres de pays dont le NAS contient 123----------\n");
    System.out.println(n);
}

Merci encore KX,
Mais j'ai encore un soucis et là je pense avoir bien suivi ce que tu m'as appris. Mais j'ai tjrs des erreurs à la compilation. Voici donc mon code qui me donne des erreurs au niveau des methodes afficher
import java.util.*;

//Cette classe est abstraite car elle coontient une methode abstraite
abstract class Employe {

public String NAS;
public String nomprenom;
int anciennete;


public Employe (String NAS, String nomprenom, int anciennete){
this.NAS = NAS;
this.nomprenom = nomprenom;
this.anciennete = anciennete;
}


public abstract double salMensuel();//Methode abstraite

public String toString(){
return String.format("\n NAS : %-10s\n Nom et Prénom : %-15s\n Années d'anciènneté :%5d ans\n Salaire Mensuel: %7.2f $", NAS, nomprenom, anciennete, salMensuel());
}

}

//Cette classe est concrète car ses methodes sont implémenteés
class Permanent extends Employe{
private boolean responsabilite;
private double salaire;
public Permanent(String NAS, String nomprenom, int anciennete, boolean responsabilite){
super(NAS, nomprenom, anciennete);
this.responsabilite = responsabilite;
this.salaire = salaire;
}
public double salMensuel(){
double salaire;
if (responsabilite == true)
{
salaire = (1987 + (150*anciennete) + 200);
return salaire;
}
else
{
salaire = (1987 + (150*anciennete));
return salaire;
}
}

public String toString(){
return "Employé Permanent : "+ super.toString();
}

}

//Cette classe est concrète car ses methodes sont implémenteés
class Contractuel extends Employe{
private int nbrHeures;
private double taux;
private double salaire;


public Contractuel(String NAS, String nomprenom, int anciennete, int nbrHeures, double taux){
super(NAS, nomprenom, anciennete);
this.nbrHeures = nbrHeures;
this.taux = taux;
this.salaire = salaire;
}

public double salMensuel(){
double salaire;
salaire = ((taux + (1.5 * anciennete)) * nbrHeures);
return salaire;
}
public String toString(){
return "Pour un Employé Contractuel avec: " +nbrHeures + "h/mois au taux de: " +taux +"$" + super.toString();
}
}

public class NumeroC{



public static void main (String[] args){

System.out.println("--------************************--------------\n");

Stack<Employe> s = demoPile();
afficher(s, " après la création");

int n = nbrNAS123(s);
afficher(s, " après le compte des NAS 123");

System.out.println("-----Nombres de pays dont le NAS contient 123----------\n");
System.out.println(n);


}
static Stack<Employe> demoPile(){
Stack<Employe> s = new Stack<Employe>();
s.push( new Permanent("123 456 789", "Charbonneau Hélène", 10, false));
s.push( new Permanent("222 333 444", "Tremblay Jacques", 23, true));
s.push( new Contractuel("987 654 123", "Chester Thompson", 19, 25, 92.25));
s.push( new Contractuel("333 123 189", "Laplante Lise", 3, 58, 25.50));
return s;
}
/**
* @param stack une pile d'Employe
* @return le nombre d'Employe dans la pile qui ont un NAS contenant "123"
*/
public static int nbrNAS123(Stack<Employe> s)
{
if (s.empty())
return 0;
else
{
Employe e = s.pop();

int n = nbrNAS123(s);

if (e.NAS.contains("123"))
n++;

s.push(e);

return n;
}
}


}

Quand tu compiles, il faut comprendre le message d'erreur qui t'es donné, ici c'est évident, tu n'as pas remis la méthode afficher qui était dans ton premier code !

Remarque : il serait bon de la refaire aussi car elle utilise des méthodes qui ne sont pas des méthodes de piles (size et get)

D'ailleurs d'un point de vue plus pédagogique, il serait peut-être intéressant pour comprendre les piles de faire toi même une classe pile (c'est très simple) et l'utiliser en remplacement de la classe Stack qui est trop complète et te pousse à la facilité...

Voici l'interface d'une pile, normalement aucune autre méthode que ces quatre là ne devrait être utilisée dans le traitement d'une pile :

import java.util.EmptyStackException;

public interface Stack<E>
{
    /**
     * Tests if this stack is empty.
     * @return true if and only if this stack contains no items; false otherwise
     */
    public boolean empty();
    
    /**
     * Looks at the object at the top of this stack without removing it from the stack.
     * @return the object at the top of this stack
     * @throws EmptyStackException if this stack is empty
     */
    public E peek() throws EmptyStackException;
    
    /**
     * Removes the object at the top of this stack and returns that object as the value of this function.
     * @return the object at the top of this stack
     * @throws EmptyStackException if this stack is empty
     */
    public E pop() throws EmptyStackException;
    
    /**
     * Pushes an item onto the top of this stack.
     * @param item the item to be pushed onto this stack
     * @return the item argument
     */
    public E push(E item);
}

Merci pour les enseignements, j'ai un rusé à certains endroits notamment pour récupérer la taille de la pile et ça marche merci encore. voici ma classe principale
public class Abstraite{



public static void main (String[] args){



Stack<Employe> s = demoPile();
afficher(s, " après la création");

int n = nbrNAS123(s);

System.out.println("-----Nombre de pays dont le NAS contient 123----------\n");
System.out.println(n);

System.out.println("------Employé ayant le salaire le plus bas----------\n");
System.out.println(s.pop());
}
static void afficher(Stack<Employe> s, String message){
System.out.println("Contenu de la pile de " +s.size() +" éléments" +message);
for (int i = 0; i<s.size(); i++)
System.out.println(i+1 +")\t" +s.get(i));
System.out.println();
}
static Stack<Employe> demoPile(){
Stack<Employe> s = new Stack<Employe>();
s.push( new Permanent("123 456 789", "Charbonneau Hélène", 10, false));
s.push( new Permanent("222 333 444", "Tremblay Jacques", 23, true));
s.push( new Contractuel("987 654 123", "Chester Thompson", 19, 25, 92.25));
s.push( new Contractuel("333 123 189", "Laplante Lise", 3, 58, 25.50));
return s;
}
/**
* @param stack une pile d'Employe
* @return le nombre d'Employe dans la pile qui ont un NAS contenant "123"
*/
public static int nbrNAS123(Stack<Employe> s)
{
if (s.empty())
return 0;
else
{
Employe e = s.pop();

int n = nbrNAS123(s);

if (e.NAS.contains("123"))
n++;

s.push(e);

return n;
}
}
public static double basSalaire(Stack<Employe> s){

double plusBasSalaire = 0;
int k = 0;

for(int i = 0; i < s.size(); i++){
Employe e = s.pop();

if(plusBasSalaire < e.salMensuel()){
plusBasSalaire = e.salMensuel();
k = i;
}
}
return k;
}






}

Ton format de fichier tout en binaire est très risqué, en particulier à cause de ton booléen finFichier qui ne contrôle rien du tout...

public static Stack<Nation> relire(String nomALire) throws IOException
{
    Stack<Nation> unePile = new Stack<Nation> (); 
    
    DataInputStream aLire = new DataInputStream(new FileInputStream(nomALire)); 
    
    int sz_str = 45;
    char[] buf = new char[sz_str];
    
    try 
    {
        while (true)
        {
            int nbrMedailleAr = aLire.readInt(); // 4 bytes
            int nbrMedailleBr = aLire.readInt(); // 4 bytes
            int nbrMedailleOr = aLire.readInt(); // 4 bytes
            
            for (int i=0; i<sz_str; i++)
                buf[i] = aLire.readChar(); // 2 bytes
            
            String nom = new String(buf);
            
            Nation paysOr = new Nation(nom, nbrMedailleOr, nbrMedailleAr, nbrMedailleBr);
            
            unePile.push(paysOr); 
        }
    }
    catch (EOFException e)
    {
        aLire.close(); 
        return unePile; 
    }
}

Si tu veux un format binaire propre, regarde du côté des ObjectInputStream/ObjectOutputStream et de la sérialisation, ce sera beaucoup plus fiable que ton format actuel.

Bonjour, j'ai essayé avec ta méthode et inutile de te dire que ça m'affiche lorque je lis le nom tout d'abord constitué de caractère illisible et les int erroné. Ma question est donc: Si j'ai utilisé PrintWriter pour créer le fichier .Bin comment j'utilise ObjectInputStream pour lire le fichier(si c'est possible).
thks you in advance!!

Il faut toujours faire correspondre les flux de lecture et d'écriture pour correspondre au format du fichier.

Tu dois donc utiliser un ObjectInputStream en lecture que si ton fichier a été écrit avec un ObjectOutputStream, de même tu ne dois utiliser un DataInputStream que si tu as écrit tes données avec un DataOutputStream...

Si tu as utilisé un PrintWriter ça veut dire que tu obtiens un fichier texte, et non un fichier binaire, il faut donc lire ce fichier en mode texte (avec un Scanner par exemple) afin de récupérer correctement les données enregistrées.

Voici un exemple d'utilisation des ObjectOutputStream/ObjectInputStream en sérialisant les objets Nation :

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Stack;

class Nation implements Serializable
{
    private static final long serialVersionUID = -1336612944663291732L;
    
    private String nm;
    private int or, ar, br;
    
    public Nation(String nom, int nbrMedailleOr, int nbrMedailleAr, int nbrMedailleBr) 
    {
        nm=nom;
        or=nbrMedailleOr;
        ar=nbrMedailleAr;
        br=nbrMedailleBr;
    }
    
    public String toString()
    {
        return String.format("%s[%d,%d,%d]",nm,or,ar,br);
    }
    
    private void writeObject(ObjectOutputStream out) throws IOException
    {
        out.writeUTF(nm);
        out.writeInt(or);
        out.writeInt(ar);
        out.writeInt(br);
    }
    
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
    {
         nm=in.readUTF();
         or=in.readInt();
         ar=in.readInt();
         br=in.readInt();
    }
}

public class Test
{
    private static void write(Stack<Nation> stack, ObjectOutputStream oos) throws IOException
    {
        if (stack.empty())
        {
            oos.writeObject(null);            
        }
        else
        {
            Nation n = stack.pop();
            oos.writeObject(n);
            write(stack,oos);
            stack.push(n);
        }
    }
    
    public static void write(Stack<Nation> stack, String fileName) throws FileNotFoundException, IOException
    {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(fileName));
        write(stack,oos);
        oos.close();
    }
    
    private static void read(Stack<Nation> stack, ObjectInputStream ois) throws IOException, ClassNotFoundException
    {
        Nation n = (Nation) ois.readObject();
        if (n!=null)
        {
            read(stack,ois);
            stack.push(n);
        }
    }
    
    public static Stack<Nation> read(String fileName) throws FileNotFoundException, IOException, ClassNotFoundException
    {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fileName));
        Stack<Nation> stack = new Stack<Nation>();
        read(stack,ois);
        ois.close();
        return stack;
    }
        
    public static void main(String[] args) throws Exception
    {
        Stack<Nation> stack = new Stack<Nation>();
            stack.push(new Nation("France",1,2,3));
            stack.push(new Nation("USA",4,5,6));
            stack.push(new Nation("Chine",7,8,9));
            stack.push(new Nation("Russie",10,11,12));
        
        System.out.println(stack);
        write(stack,"C:/nations.ser");
        System.out.println(stack);
        
        Stack<Nation> stack2 = read("C:/nations.ser");
        System.out.println(stack2);
    }
}

Remarque : en pratique on sérialiserait aussi l'objet pile c'est à dire que l'on remplacerait les méthode read et write par des readObject et writeObject directement dans la classe pile (ce que fait d'ailleurs la classe Stack) mais ça ne te ferait pas manipuler les piles...

Merci pour ton exemple qui m'a beaucoup aider. Voici mon code, tu remarquera que j'ai utilisé BufferedReader pour lire le fichier texte du départ. Et maintenant le problème que j'ai c'est que je veux récupérer dans mon fichier que j'ai écris uniquement les pays qui ont au min une médaille en or et que quand je met ma condition je n'arrive pas à récupérer la variable nbrMedailleOr de Nation dans ma pile. j'ai essayé if (nat.nbrMedailleOr > 0)

import java.util.*;
import java.io.*;


class Nation implements Serializable{

private static final long serialVersionUID = -1336612944663291732L;


private String nom;
private int nbrMedailleOr, nbrMedailleAr, nbrMedailleBr;


public Nation (String nom, int nbrMedailleOr, int nbrMedailleAr, int nbrMedailleBr){
this.nom = nom;
this.nbrMedailleOr = nbrMedailleOr;
this.nbrMedailleAr = nbrMedailleAr;
this.nbrMedailleBr = nbrMedailleBr;
}

//public Nation (String ligneLue){


public String getNom(){
return this.nom;

}

public int getNbrMedailleOr(){
return this.nbrMedailleOr;
}

public int getNbrMedailleAr(){
return this.nbrMedailleAr;
}

public int getNbrMedailleBr(){
return this.getNbrMedailleBr();
}
//surcharge de toString pour obtenir un affichage personnalisé sur l'objet nation
public String toString(){
return String.format("%30s %-3d %-3d %-3d\n", nom, nbrMedailleOr, nbrMedailleAr, nbrMedailleBr);

}

//surcharge de la methode equals (pour mieux comparer les nations)
public boolean equals(Object obj){
if (! (obj instanceof Nation))
return false;
else
if (this == obj)
return true;
else{
Nation autre = (Nation) obj;
return nom.trim().equalsIgnoreCase(autre.nom.trim());
}
}

public void writeObject(ObjectOutputStream aCreer) throws IOException{

aCreer.writeUTF(nom);
aCreer.writeInt(nbrMedailleOr);
aCreer.writeInt(nbrMedailleAr);
aCreer.writeInt(nbrMedailleBr);
}

public void readObject(ObjectInputStream aLire) throws IOException, ClassNotFoundException {

nom = aLire.readUTF();
nbrMedailleOr = aLire.readInt();
nbrMedailleAr = aLire.readInt();
nbrMedailleBr = aLire.readInt();

}


}

public class NumeroB {




//On lit le fichier, on créer et on remplit une pile des pays

public static Stack<Nation> lireCreer(String nomFichier) throws IOException{
Stack<Nation> stack = new Stack<Nation>(); //pile vide au debut
boolean existeFichier = true; //à ajuster après

FileReader fr = null; //initialiser pour Java

//essayer de localiser le fichier à partir de son nom
try{
fr = new FileReader (nomFichier);
}
//interception de l'erreur si le fichier n'existe pas
catch (java.io.FileNotFoundException erreur){
System.out.println("Problème d'ouvrir le fichier " +nomFichier);
existeFichier = false;//ajuster
}

if(existeFichier){
//construction de l'objet d'entrée qui va permettre d'appliquer la lecture d'une ligne de texte

BufferedReader entree = new BufferedReader(fr);
boolean finFichier = false;


while ( !finFichier){

//lire une ligne
String uneLigne = entree.readLine();

if(uneLigne == null)
finFichier = true;
else{

String nom = uneLigne.substring(0,32).trim();
String Me = uneLigne.substring(32).trim();
StringTokenizer st = new StringTokenizer(Me, " ");
int nbrMedailleOr = Integer.parseInt(st.nextToken());
int nbrMedailleAr = Integer.parseInt(st.nextToken());
int nbrMedailleBr = Integer.parseInt(st.nextToken());

stack.push(new Nation(nom, nbrMedailleOr, nbrMedailleAr, nbrMedailleBr));
}
}

entree.close();//Fermeture du fichier

}
return stack;

}
private static void creerBinaire(Stack<Nation> stack, ObjectOutputStream oos) throws IOException
{

if (stack.empty())
{
oos.writeObject(null);
}
else
{
Nation nat = stack.pop();
if(nat.nbrMedailleOr > 0)
oos.writeObject(nat);
creerBinaire(stack, oos);
stack.push(nat);
}
}
public static void creerBinaire(Stack<Nation> stack, String nomACreer) throws FileNotFoundException, IOException
{
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(nomACreer));

creerBinaire(stack,oos);
oos.close();
}



public static void main(String[] args) throws IOException
{

Stack<Nation> stack = lireCreer("Olym_ete.txt");

System.out.println("-------------------------- Contenu de la pile ----------------------");
System.out.println(stack);
System.out.println();

System.out.println("-------------------------- Création de la pile -----------------------");

creerBinaire(stack, "Pays_en_Or.Bin");
System.out.println("Fichier Pays_en_Or.Bin créer. ");
System.out.println();


System.out.println("------------- Pile de pays ayant eu l'or ----------------------");
System.out.println(stack);

}
}

Je ne sais pas si c'est à ce niveau aussi que je dois mettre cette condition pour creer un fichier de pays ayant obtenu l'or.

Merci à toi.

Tu ne peux pas faire if(nat.nbrMedailleOr > 0) car nbrMedailleOr est un attribut privé, c'est d'ailleurs pour cela que l'on fait des getters. Tu dois faire if(nat.getNbrMedailleOr() > 0)