Ejercicio función invertir

Implementa la siguiente función, utilizando un objeto de la clase Stack.

• Nombre y parámetros: List<Point> invertir (Iterator<Point> i , Point p)
• Retorna: List<Point> (realmente será un objeto ArrayList<Point>)
• Tarea: Crea un ArrayList de objetos Point que contenga los puntos obtenidos con el iterador pero en orden inverso, excluyendo los puntos que sean iguales al recibido en el segundo parámetro.
• Si el segundo parámetro es null, se excluyen los puntos (0,0) 
• Excepciones: IllegalArgumentException en caso de que el iterator no nos diera ni un solo Punto o bien fuese null.

Se añade el programa principal con el que se probó la función.

public class EjercicioStack {
    public static void main (String[] args) {
        Point a = new Point(0,0);
        Point b = new Point(1,1);
        Point c = new Point(2,2);
        Point d = null;
        ArrayList<Point> puntos = new ArrayList<Point>();
        ArrayList<Point> puntosInv;
        puntos.add(a);
        puntos.add(b);
        puntos.add(c);
        System.out.println(puntos);
        Iterator<Point> it = puntos.iterator();
        puntosInv = (ArrayList<Point>) invertir(it, d);
        System.out.println(puntosInv);
    }
    public static List<Point> invertir (Iterator<Point> i, Point p) {
        Stack<Point> pila = new Stack<Point>();
        ArrayList<Point> puntos = new ArrayList<Point>();
        Point aux;
        if (i == null || !i.hasNext()) {
            throw new IllegalArgumentException();
        }
        if (p == null) {
            p = new Point(0, 0);
        }
        while (i.hasNext()) {
            aux = i.next();
            if (!aux.equals(p))
                pila.push(aux);
        }
        while (!pila.empty()) {
            puntos.add(pila.pop());
        }
        return puntos;
    }
}

Ejercicio "Pila" con ArrayList

Crear la clase PilaString, que tendrá las siguientes funciones:

• apilar. Recibe el objeto a colocar en la pila (un String).
• desapilar. Elimina el último objeto de la pila y lo retorna como dato.
• vacia. Retorna un boolean indicando si la pila está o no vacía.

Para almacenar los objetos se utilizará la clase ArrayList de Java. El atributo será privado para que no se pueda acceder a él directamente.

public class PilaString {
    private ArrayList<String> pila = new ArrayList<String>();
    public void apilar(String frase) {
        pila.add(frase);
    }
    public String desapilar() {
        return pila.remove(pila.size()-1);
    }
    public boolean vacia() {
        return pila.isEmpty();
    }
}

Ejercicio invertir tabla

Crear una función que invierta el contenido de una tabla de String que recibe como atributo, utilizando un objeto PilaFrase.

public static void invertir (String[] tabla){
    int i;
    PilaFrases aux = new PilaFrases(tabla.length);
    for (i=0; i<tabla.length; i++){
        aux.push(tabla[i]);
    }
    for (i=0; i<tabla.length; i++){
        tabla[i] = aux.pop();
    }
}

Ejercicio "Pila" y "Cola"

Crear las clases "PilaFrases" y "ColaFrases", que permitan crear, como su nombre indica, una pila y una cola, respectivamente, de String. Cada clase tendrá los atributos necesarios y las funciones que permitan trabajar con los objetos PilaFrases y ColaFrases, modificándolos o, simplemente, consultando determinados datos.

PilaFrases

public class PilaFrases {
    private String[] frases;
    private int cima;
    PilaFrases(){
        frases = new String[10];
        cima = -1;
    }
    PilaFrases(int numero){
        frases = new String[numero];
        cima = -1;
    }
    public void push (String frase){
        if (cima < frases.length){
            cima++;
            frases[cima] = frase;
        }
    }
    public String pop (){
        cima--;
        return frases[cima+1];
    }
    public boolean empty(){
        /*boolean vacia;
        if (cima == -1)
            vacia = true;
        else
            vacia = false;*/
        return cima == -1;
    }
    public boolean full(){
        /*boolean llena;
        if (cima == (frases.length-1))
            llena = true;
        else
            llena = false;*/
        return cima == (frases.length-1);
    }
}

ColaFrases

public class ColaFrases {
    private String[] tabla;
    private int primero, ultimo;
    ColaFrases(){
        this(10);
    }
    ColaFrases(int tamaño){
        tabla = new String[tamaño+1];
        primero = 0;
        ultimo = -1;
    }
    public boolean llena(){
        return sig(sig(ultimo)) == primero;
    }
    public boolean vacia(){
        return sig(ultimo) == primero;
    }
    private int sig(int actual){
        return (actual+1)%tabla.length;
    }
    public void acolar(String frase){
        if (this.llena())
            throw new IndexOutOfBoundsException("La cola está llena");
        ultimo = sig(ultimo);
        tabla[ultimo] = frase;
    }
    public String desacolar(){
        String aux;
        if (this.vacia())
            throw new IndexOutOfBoundsException("La cola está vacía");
        
        aux = tabla[primero];
        primero = sig(primero);
        return aux;
    }
}