Cours CNAM par J. Laforgue

Exercice16_Ensemble

Retour

Télécharger

Implémentation d'un ensemble de chaine par héritage de ListeString

Exercice16.pdf

EnsembleString.java
Exercice16.java

// Implémentation d'un ensemble de chaine par héritage de ListeString

public class Exercice16
{
    public static void main(String args[]) 
    {
        // Pour finir le programme
        boolean fini = false;

// Creation de l'ensemble
        EnsembleString ensemble = new EnsembleString(); 
        
        // Activation des traces de la classe
        EnsembleString.trace = true;

// Traitement qui affiche un menu pour chacun des cas de test
        //
        while (!fini){

// Le mnenu est affiche
            Terminal.ecrireStringln("-----------------");
            Terminal.ecrireStringln("1 : void add(String s)");
            Terminal.ecrireStringln("2 : int size()");
            Terminal.ecrireStringln("3 : String get(int indice)");
            Terminal.ecrireStringln("4 : void set(int indice, String valeur)");
            Terminal.ecrireStringln("5 : int indexOf(String occurrence)");
            Terminal.ecrireStringln("6 : indexOf(int debut, String occurrence)");
            Terminal.ecrireStringln("7 : boolean remove(int indice)");
            Terminal.ecrireStringln("8 : initialisation de l'ensemble");
            Terminal.ecrireStringln("9 : afficher l'ensemble");
            Terminal.ecrireStringln("0 : exit");
            Terminal.ecrireStringln("-----------------");
            afficherEnsemble(ensemble);
            Terminal.ecrireStringln("-----------------");

// Saisir le choix
            Terminal.ecrireString("Choix: ");
            int choix = Terminal.lireInt();
            
            // Les cas de test
            switch(choix)
                {
                case 0 : 
                    {
                        // Sortir du programme
                        fini=true;
                        break;
                    }

case 1:
                    {
                        // Ajout d'un element
                        Terminal.ecrireString("s = ");
                        String s = Terminal.lireString();
                        ensemble.add(s);
                        break;
                    }
                case 2:
                    {
                        // Taille de la ensemble
                        int taille = ensemble.size();
                        Terminal.ecrireStringln("Taille = "+taille);
                        break;
                    }
                case 3:
                    {
                        // Acces a un element de la ensemble
                        Terminal.ecrireString("indice = ");
                        int indice = Terminal.lireInt();
                        //
                        String valeur = ensemble.get(indice);
                        if (valeur!=null) Terminal.ecrireStringln("get = "+valeur);
                        else Terminal.ecrireStringln("Incorrect");
                        break;
                    }

case 4:
                    {
                        // Changer un element de la ensemble
                        Terminal.ecrireString("indice = ");
                        int indice = Terminal.lireInt();
                        Terminal.ecrireString("valeur = ");
                        String valeur = Terminal.lireString();
                        //
                        boolean res = ensemble.set(indice,valeur);
                        if (res) Terminal.ecrireStringln("Correct");
                        else Terminal.ecrireStringln("Incorrect");
                        break;
                    }
                case 5:
                    {
                        // Rechercher un element a partir d'un indice
                        Terminal.ecrireString("valeur = ");
                        String valeur = Terminal.lireString();
                        //
                        int index = ensemble.indexOf(valeur);
                        Terminal.ecrireStringln("index = "+index);
                        break;
                    }
                case 6:
                    {
                        // Rechercher un element a partir d'un indice
                        Terminal.ecrireString("debut = ");
                        int debut = Terminal.lireInt();

Terminal.ecrireString("valeur = ");
                        String valeur = Terminal.lireString();
                        //
                        int index = ensemble.indexOf(debut,valeur);
                        Terminal.ecrireStringln("index = "+index);
                        break;
                    }
                case 7:
                    {
                        // Suppression d'un element
                        Terminal.ecrireString("indice = ");
                        int indice = Terminal.lireInt();
                        //
                        boolean res = ensemble.remove(indice);
                        if (res) Terminal.ecrireStringln("Correct");
                        else Terminal.ecrireStringln("Incorrect");
                        break;
                    }
                case 8:
                    {
                        // Initialisation de la ensemble avec des valeurs fixes
                        //  (afin d'alleger le travail du testeur)
                        //
                        ensemble = new EnsembleString();
                        ensemble.add("Zoe");
                        ensemble.add("Lafont");
                        ensemble.add("Dupont");
                        ensemble.add("Flament");
                        ensemble.add("Durand");
                        break;
                    }
                case 9:
                    {
                        for(int i=0;i<ensemble.size();i++)
                            {
                                Terminal.ecrireStringln(i + ":" + ensemble.get(i));
                            }
                    }
                }
        }

}

/** Methode interne qui affiche le contenu de la ensemble 
        @param l la ensemble à afficher
    */
    static void afficherEnsemble(EnsembleString l)
    {
        Terminal.ecrireStringln("L'ensemble:");
        if (l==null) return;
        for(int i=0;i<l.size();i++)
            Terminal.ecrireStringln(i + ":" + l.get(i));
    }
}

ListeString.java

/** Classe de définition d'une liste de String. 
    Cette classe permet d'ajouter des éléments (qui sont des String) sans limite de capacité. 
    Elle utilise un tableau tab[] en interne dont la dimension est de MAX. 
    Lors d'un ajout d'élément, si le tableau est saturé alors tab[] est redimensionné à sa taille + MAX.
 */
public class ListeString
{
    /** Tableau de chaine contenant les éléments de la liste */
    private String[] tab ;

/** Nombre d'élément de la liste (taille de la liste) */
    private int nb;

/** Nombre max d'éléments alloués à chaque tranche. MAX = 5*/
    private final static int MAX = 5;

/** Taille physique du tableau */
    private int taillePhysique;

/** Pour activer les traces (Faire ListeString.trace = true).  Par defaut est à false */
    static public boolean trace = false;

/**
       Constructeur qui crée une liste de chaine vide. 
       Le tableau interne de la liste est dimensionné à MAX.
    */
    public ListeString()
    {
        tab = new String[MAX];
        nb = 0;
        taillePhysique = MAX;
    }

/**
       ajout d'un élément dans la liste
       @param s chaine ajoutée dans la liste
    */
    public void add(String s)
    {
        if (nb==taillePhysique)
            {
                // Il faut allouee une nouvelle tranche
                taillePhysique = tab.length+MAX;
                //
                String[] tmp = new String[taillePhysique];
                for(int i=0;i<nb;i++) tmp[i]=tab[i];
                tab = tmp;
                //
                // ou un code plus court:
                // tab = Arrays.copyOf(tab,taillePhysique);
                // Ne pas oublier d'ajouter le import java.util.* dans ce cas;
                //
                // Trace
                if (trace)
                    System.out.println("Nouvelle taille physique : "+tab.length);

// Ajout du nouvel element
                tab[nb] = s;
                nb++;
            }
        else
            {
                // Ajout du nouvel element
                tab[nb] = s;
                nb++;
            }
    }

/**
       Retourne la taille de la liste (nombre d'élément)
    */
    public int size()
    {
        return nb;
    }

/**
       Retourne l'élément à l'indice donné
       @param indice indice de l'élément retourné
       @return l'élément se trouvant à l'indice donné. null si indice incorrect
    */
    public String get(int indice)
    {
        if (indice <0) return null;
        if (indice > nb-1) return null;
        return tab[indice];
    }

/**
       Change un élément de la liste
       @param indice indice de l'element (de 0 a size()-1)
       @param valeur valeur de changement de l'element
       @return false si indice incorrect sinon true
    */
    public boolean set(int indice, String valeur)
    {
        if (indice <0) return false;
        if (indice > nb-1) return false;
        tab[indice] = valeur;
        return true;
    }

/**
       Recherche un element dans la liste
       @param occurence valeur à rechercher
       @return retourn l'indice de l'element trouvé sinon retourne -1
    */
    public int indexOf(String occurence)
    {
        for(int i=0;i<size();i++) {
            if (tab[i].equals(occurence))
                return i;
        }
        return -1;
    }

/**
       Recherche un element dans la liste à partir d'un indice
       @param debut indice de début de la recherche
       @param occurence valeur à rechercher
       @return retourn l'indice de l'element trouve sinon retourne -1
    */
    public int indexOf(int debut,String occurence)
    {
        if (debut <0) return -1;
        if (debut > nb-1) return -1;
        for(int i=debut;i<size();i++) {
            if (tab[i].equals(occurence))
                return i;
        }
        return -1;
    }        
        
    /**
       Supprimer un element
       @param indice indice de l'element à supprimer
       @return false si indice incorrect sinon true
    */
    public boolean remove(int indice)
    {
        if (indice <0) return false;
        if (indice > nb-1) return false;
        for(int i=indice;i<=nb-2;i++) {
            tab[i]=tab[i+1];
        }
        nb=nb-1;
        return true;
    }

}

Terminal.java

import java.io.*;

public class Terminal{    
    static BufferedReader in =
        new BufferedReader(new InputStreamReader(System.in));

public static String lireString() // Lire un String
    {
        String tmp="";
        char C='\0';
        try {
            tmp = in.readLine();
        }
        catch (IOException e)
            {
                exceptionHandler(e);
            }
        return tmp;
    } // fin de lireString()
    public static int lireInt()  // Lire un entier
    {
        int x=0;
        try {
            x=Integer.parseInt(lireString());
        }
        catch (NumberFormatException e) {
            exceptionHandler(e);
        }    
        return x ;
    }
    public static boolean lireBoolean()  // Lire un entier
    {
        boolean b = true;
        try {
            b = Boolean.valueOf(lireString()).booleanValue();
        }
        catch (NumberFormatException e) {
            exceptionHandler(e);
        }    
        return b;
    }
    public  static double lireDouble()  // Lire un double
    {
        double x=0.0;
        try {
            x=Double.valueOf(lireString()).doubleValue();
        }
        catch (NumberFormatException e) {
            exceptionHandler(e);
        }    
        return x ;
    }
    public  static char lireChar()  // Lire un caractere
    {
        String tmp=lireString();
        if (tmp.length()==0)
            return '\n';
        else 
            {
                return tmp.charAt(0);
            }
    }
    public static void ecrireString(String s){ // Afficher un String
        try{
            System.out.print(s);
        } catch (Exception ex){
            exceptionHandler(ex);
        }
    }
    public static void ecrireStringln(String s) // Afficher un String
    {
        ecrireString(s);
        sautDeLigne();
    } // fin de ecrireStringln()
    public static void ecrireInt(int i)  // Afficher un entier
    {
        ecrireString(""+i);
    }
    public static void ecrireIntln(int i)  // Afficher un entier
    {
        ecrireString(""+i);
        sautDeLigne();
    }
    public static void ecrireBoolean(boolean b){
        ecrireString(""+b);
    }
    public static void ecrireBooleanln(boolean b){
        ecrireString(""+b);
        sautDeLigne();
    }
    public  static void ecrireDouble(double d)  // Afficher un double
    {
        ecrireString(""+d);
    }
    public  static void ecrireDoubleln(double d)  // Afficher un double
    {
        ecrireDouble(d);
        sautDeLigne();
    }
    public  static void ecrireChar(char c)  // Afficher un caractere
    {
        ecrireString(""+c);
    }  
    public  static void ecrireCharln(char c)  // Afficher un caractere
    {
        ecrireChar(c);
        sautDeLigne();
    }
    public static void sautDeLigne(){
        try{
            System.out.println();
        }catch(Exception ex){
            exceptionHandler(ex);
        }
    }
    protected static void exceptionHandler(Exception ex){
        TerminalException err = new TerminalException(ex);
        throw err;
    }
    public static void ecrireException(Throwable ex){
        ecrireString(ex.toString());
        ex.printStackTrace(System.err);
    }
}  
class TerminalException extends RuntimeException{
    Exception ex;
    TerminalException(Exception e){
        ex = e;
    }
}

compil.bat
run.bat

Cours d'Informatique par Jacques LAFORGUE

Retour

Télécharger

Cours d'Informatique
par Jacques LAFORGUE