Bonsoir,

Nous étudions actuellement la pile sous forme de tableau, Maillon (liste chaînée), LinkedList et ArrayList avec les méthodes :

• pop() : Retirer les données
• push() : Insertion des données
• top() : pour voir les données 

1) La classe Maillon 

public class Maillon {
    private Object element;
    private Maillon suivant;
    public Maillon (Object obj, Maillon m) {
        element = obj;
        suivant = m;
    }
    public boolean hasNext () {
        return suivant != null;
    }
    public String toString() {
        return element.toString();
    }
    public static void main (String[] args) {
        Maillon m0 = new Maillon ("albert", null);
        Maillon m1 = new Maillon ("emilie", m0);
        Maillon m2 = new Maillon ("zina", m1);
        Maillon m3 = new Maillon ("toto", m2);
        Maillon m4 = new Maillon ("Julie", m3);
        /* Seconde partie du cours sur la liste chaine */
        Maillon p = m4;
        while (p.hasNext()) {
            System.out.println(p);
            p = p.suivant;
        }
    }
}

La classe PileM

public class PileM {
    /*On reutilise la classe maillon qu'on nous a introduit en classe pour l'auto reference*/
    private Maillon sommet;
    public PileM() {
        sommet = null;
    }
    public boolean isEmpty() {
        return sommet == null;
    }
    public void push(Object obj){
        Maillon m = new Maillon (obj.sommet);
        sommet = m;    
    }
    public Object pop() {
        if (isEmpty()) {
            return null;
        }
        Object obj = sommet.getElement();
        sommet = sommet.getSuivant();
        return obj;
    }
    public String toString() {
        if (isEmpty()) {
            return "{}";
        }
        StringBuffer sb = new StringBuffer("{");
        Maillon p;
        for (p = sommet; p.hasNext() ; p = p.getSuivant() ) {
            sb.append(p + ",");
        }    
        sb.append(p + "}");
        return sb.toString();
    }
    public static void main(String[] args){
        
    }
}

2) classe PileA 

public class PileA {
    /* Encapsulation */
    private ArrayList liste;
    public PileA() {
        liste = new ArrayList();
    }
    public String toString() {
        return liste.toString();    
    }
    public boolean isEmpty() {
        return liste.isEmpty();
    }
    public Object top() {
        if (liste.isEmpty())
            return null;
        else
            return liste.get(0); /***************/
    }
    public Object pop() {
        if (liste.isEmpty())
            return null;
        else
            return liste.remove(0);/***************/
    } 
    public void push (Object obj) {
        liste.add(null, obj);
    }
    public static void main(String[] args) {
        PileA arrayL = new PileA();
        
    }
}

3) classe PileL

public class PileL {
    /* Encapsulation */
    private LinkedList liste;
    public PileL() {
        liste = new LinkedList();
    }
    public String toString() {
        return liste.toString();    
    }
    public boolean isEmpty() {
        return liste.isEmpty();
    }
    public Object top() {
        if (liste.isEmpty())
            return null;
        else
            return liste.getFirst();
    }
    public Object pop() {
        if (liste.isEmpty())
            return null;
        else
            return liste.removeFirst();
    } 
    public void push (Object obj) {
        liste.addFirst(obj);
    }
    public static void main(String[] args) {
        PileL linked = new PileL();
    }
}

4) classe Resultat

public class Resultat {
	private String nom;
	private double note;
	public Resultat (String s, double d) {
		nom = s;
		note = d;
	}
	public Resultat(){
		nom = "";
		note = -1;
	}
	public Resultat (String s) {
		this( s, -1);
		/*on peut aussi le faire : nom = s;  note = -1; */
	}
	/*Methode d'observateur : Methodes d'instance */
	public String getNom(){
		return nom;
	}
	public double getNote(){
		return note;
	}
	public String toString() {
		return "[" + nom + ";" + note + "]";
	}
	public int compNom( Resultat res ) {
		return (this.nom.compareTo(res.nom));
	}
	public int compNote(Resultat res) {
		if (this.note < res.note)
			return -1;
		else if (this.note > res.note)
			return 1;
		else
			return 0;
	}
	private static void main (String[] args) {
		/*On alloue de la memoire dans le TAS, l'objet se trouve la pile*/
		Resultat r = new Resultat("toto", 18); 
		/*deux facons d'obtenir toto*/
		System.out.println(r.getNom());
		System.out.println(r.nom);
		/*On obtient du hashCode, mais c'est quoi? Je sais qu'il faut un toString() pour arrange sa*/
		System.out.println(r);

		/*On va compare les noms*/
		Resultat r1 = new Resultat("albertine", 14); 
		System.out.println(r.compNom(r1));

		
	}
}

classe Examen

public class Examen {
	private static int nbTotal = 50;
	/*On va collecter les resultats du tableau*/
	private Resultat[]  tableauResultat;
	private int nombreResultat;
	
	public Examen (){
		tableauResultat = new Resultat[nbTotal];
		nombreResultat = 0;
	}
	public void add( Resultat r) {
		if (tableauResultat < nbTotal) {
			tableauResultat[nombreResultat] = r;
			nombreResultat++;
		}
	}
	public String toString() {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < nombreResultat;i++)
			sb.append(tableauResultat[i] + "\n");
		return sb.toString();
	}
	public boolean isEmpty() {
		return nombreResultat == 0;
	}
	public double getNote( int i) {
		if (i < nombreResultat)
			return tableauResultat[i].getNote();
		return -1;
	}
	public void indexOf (String s) {
		for ( int i = 0; i < nombreResultat; i++)
			if(tableauResultat[i].getNom().equals(s))
				return i;
		return -1;
	}
	public void modifierResultat (String s, double x) {
		int p = indexOf(s);
		if (p != -1)
			tableauResultat[p] = new Resultat( s, x);
	}
	public double moyenne() {
		double moyenne = 0;
		if (this.isEmpty())
			return -1;
		for (int i = 0; i < nombreResultat; i++)
			moyenne += getNote[i];
		return moyenne / nombreResultat;
	}
	public void trialphabetique() {
		int p = 0;
		Resultat ResultatTemporaire;
		if (! isEmpty()) {
			for (int i = 0; i < nombreResultat; i++) {
				//Recherche de l'indice du min sur la zone [i, nombreResultat - 1]
				//Echange de l'element trouve avec tableauResultat[i]
				p = i;
				for (int j = 0; j < nombreResultat; j++) 
					if (tableauResultat[j].getNom().compareTo(tableauResultat[p].getNom()))
						p = j;
						ResultatTemporaire = tableauResultat[p];
						tableauResultat[p] = tableauResultat[i];
						tableauResultat[i] = ResultatTemporaire;
			}
		}
	}
	public static void main( String[] args) {
		Examen ej = new Examen();
		Examen ec = new Examen();

		ej.add(new Resultat("toto", 14));
		ec.add(new Resultat("toto", 13));

		System.out.println(ej.isEmpty()); /*On obtient false*/
		int p = ej.indexOf("toto");
		System.out.println(p); /*Pourquoi obtient-on 0?*/
		ej.modifierResultat("toto", 14.5);
	}
}

Quelle est leur différence? Je ne vois pas comment le faire pour la pile avec LinkedList et ArrayList...

Concrètement si j'ai bien compris l'explication de Wikipedia, le Tas est juste un endroit pour traite les données de la pile en dupliquant deux fois la même variable (1 dans la pile et l'autre dans le tas)? Le professeur nous a fait un schéma de la mémoire :

Peut-on divise par 0 dans le microprocesseur si on a : i / 0 ? Peut-on récupérer l'erreur?

Quelqu'un aurait-il une explication plus simple sur le fonctionnement d'encapsulation et des exemples?

Peut-on faire :

private Maclasse {
    
}

Bonjour,

Pour la différence entre les listes, demande-toi combien de temps ça prend pour enlever le premier élément.

La pile, c'est là où sont stockées les variables. Le tas, c'est là où sont stockés les objets.

Types primitifs : quand tu fais "int i = 5;", la variable i est créée dans la pile et sa valeur vaut 5.

Types objets : quand tu fais "UneClasse monObjet = new UneClasse()", un objet de type UneClasse est créé dans le tas. La variable monObjet est créée dans la pile et sa valeur vaut l'adresse mémoire de l'objet dans le tas (c'est une référence).

L'encapsulation, c'est le fait de cacher l'implémentation. En gros, on n'interagit avec les objets qu'au travers de leur méthodes. Ca a plusieurs avantages dont le fait

-de protéger la cohérence de l'état de l'objet

-de faire abstraction de la façon dont les méthodes sont implémentées pour se concentrer uniquement sur les fonctionnalités (services) qu'elles fournissent