Ejercicio con figuras

En este ejercicio se utilizan las figuras creadas anteriormente. Se fabricarán varias figuras, que se almacenarán en un fichero utilizando la clase ObjectOutputStream, que nos permite serializar objetos (para ello la clase figura debe implementar Serializable).

Posteriormente se recuperarán las figuras y calcularemos el área media.

public class GuardarFiguras3 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //FABRICAR VARIAS FIGURAS Y GUARDARLAS EN UN FICHERO
        FileOutputStream fos = new FileOutputStream("figuras3");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        LinkedList listado = new LinkedList();
        ListIterator it = listado.listIterator();
        Figura aux;
        float sup=0;
        it.add(new Rectangulo(1, 3, 5, 6));
        sup+=it.previous().area();
        it.next();
        it.add(new Coche(3, 2, 6, 9));
        sup+=it.previous().area();
        it.next();
        it.add(new Circulo(4, 4, 4));
        sup+=it.previous().area();
        it.next();
        it.add(new Rectangulo(1, 3, 5, 5));
        sup+=it.previous().area();
        it.next();
        it.add(new Triangulo(2, 4, 3, 4, 5));
        sup+=it.previous().area();
        sup = sup/5;
        System.out.println("Área media inicial: "+sup);
        ListIterator it2 = listado.listIterator();
        while (it2.hasNext()) {
            oos.writeObject(it2.next());
        }
        oos.close();
        fos.close();
        //RECUPERAR FIGURAS Y CALCULAR LA MEDIA (DEBE COINCIDIR CON LA INICIAL)
        FileInputStream fis = new FileInputStream("figuras3");
        ObjectInputStream ois = new ObjectInputStream(fis);
        float media = 0;
        int contador = 0;
        try {
            while (true) {
                aux = (Figura) ois.readObject();
                media += aux.area();
                contador++;
            }
        } catch (EOFException e) {
        }
        ois.close();
        fis.close();
        media = media / contador;
        System.out.println("Área media final: " + media);
    }
}

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 funciones insertar

Realizar las funciones:

• int insertar (List<Comparable> l, Comparable d). La función recibe una lista de datos comparables, que debe estar ordenada, y un dato comparable que es el que se quiere insertar en la lista anterior. Como resultado se retorna la posición en la que ha sido insertado el dato.
• void insertar (List<Comparable> l, Collection<Comparable> c). Recibe una lista de datos comparables, que estarán ordenados, y una colección de datos que se insertarán en el lugar correspondiente de la lista anterior. No retorna nada.

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

public class Insertar {
    public static void main (String[] args) {
        LinkedList<String> nombres = new LinkedList<String>();
        LinkedList<String> nombres2 = new LinkedList<String>();
        int pos;
        pos = insertar((List)nombres, "Juan");
        System.out.println(nombres);
        System.out.println(pos);
        pos = insertar((List)nombres, "Antonio");
        System.out.println(nombres);
        System.out.println(pos);
        pos = insertar((List)nombres, "Manuela");
        System.out.println(nombres);
        System.out.println(pos);
        nombres2.add("Julia");
        nombres2.add("Angel");
        nombres2.add("Carlos");
        nombres2.add("Verónica");
        insertar((List)nombres, (Collection)nombres2);
        System.out.println(nombres);
    }
    public static int insertar(List<Comparable> l, Comparable d) {
        int i=0;
        ListIterator<Comparable> it = l.listIterator();
        while (i < l.size() && d.compareTo(it.next()) > 0) {
            i++;
        }
        if (i < l.size())
            it.previous();
        it.add(d);
        return i;
    }
    public static void insertar(List<Comparable> l, Collection<Comparable> c) {
        Iterator<Comparable> itC = c.iterator();
        while (itC.hasNext()) {
            insertar(l, itC.next());
        }
    }
}

Ejercicio "ListaEnlazada"

Para conocer un poco mejor el funcionamiento de la clase LinkedList<T>, realizar el siguiente ejercicio:

1. Crear un LinkedList de Integer: LinkedList<Integer>.
2. Añadir los números del 1 al 5.
3. Eliminar los números 2, 3 y 4.
1. En primer lugar con la función remove (int index) propia de los objetos LinkedList.
2. En segundo lugar, utilizando un objeto Iterator.

NOTA: se imprime en pantalla a menudo para comprobar que todo va funcionando bien en cada paso.

public class ListaEnlazada {
    public static void main (String[] args) {
        LinkedList<Integer> lista = new LinkedList<Integer>();
        int i, j=1;
        for (i=0; i<5; i++){
            lista.add(i+1);
        }
        System.out.println(lista.toString());
        for (i=0; i<3; i++){
            lista.remove(j);
        }
        System.out.println(lista.toString());
        lista.add(1, 2);
        lista.add(2, 3);
        lista.add(3, 4);
        System.out.println(lista.toString());
        Iterator<Integer> it = lista.iterator();
        it.next();
        it.next();
        for (i=0; i<2; i++){
            it.remove();
            it.next();
        }
        it.remove();
        System.out.println(lista.toString());
    }
}

Ejercicio "Conjunto"

Crear la clase Conjunto<T>, que implementará la interfaz Set<T>. No se pondrá código a todas las funciones de Set<T>, tan sólo aquellas que nos interesan de momento.

Para almacenar todos los objetos que forman parte del conjunto, se empleará un ArrayList. Además, se creará la clase privada ParaRecorrerMiConjunto, alojada dentro de la clase Conjunto<T>, que implementa Iterator<T> y nos permite recorrer todos los elementos que forman parte del conjunto.

public class Conjunto<T> implements Set<T> {
    private ArrayList<T> datos;
    private class ParaRecorrerMiConjunto implements Iterator<T> {
        private int actual = -1;
        public boolean hasNext() {
            return actual < datos.size() - 1;
        }
        public T next() {
            if (!hasNext()) {
                throw new java.util.NoSuchElementException();
            }
            actual++;
            return datos.get(actual);
        }
        public void remove() {
            throw new UnsupportedOperationException("Not supported yet.");
        }
    }
    public Conjunto() {
        datos = new ArrayList<T>();
    }
    public void clear() {
        datos.clear();
    }
    @SuppressWarnings("element-type-mismatch")
    public boolean contains(Object o) {
        return datos.contains(o);
    }
    public int size() {
        return datos.size();
    }
    public boolean isEmpty() {
        return datos.isEmpty();
    }
    public boolean add(T e) {
        if (!datos.contains(e)) {
            return datos.add(e);
        }
        return false;
    }
    @SuppressWarnings("element-type-mismatch")
    public boolean remove(Object o) {
        return datos.remove(o);
    }
    @Override
    public String toString() {
        return datos.toString();
    }
    @Override
    public boolean equals(Object o) throws ClassCastException {
        Conjunto<T> aux = (Conjunto<T>) o;
        return this.datos.containsAll(aux.datos) & aux.datos.containsAll(this.datos);
    }
    public Iterator<T> iterator() {
        return new ParaRecorrerMiConjunto();
    }
    public Object[] toArray() {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public Object[] toArray(Object[] a) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean containsAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean addAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean retainAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean removeAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
}

MODIFICACIÓN

Para que funcione realmente como un conjunto de cosas, modificaremos la clase ParaRecorrerMiConjunto, de manera que cada vez que se instancie un iterador para recorrer los elementos del conjunto, lo haga en orden aleatorio.

public class Conjunto3<T> implements Set<T> {
    private ArrayList<T> datos;
    private class ParaRecorrerMiConjunto implements Iterator<T>{
        private int actual=-1;
        private ArrayList<T> aux;
        ParaRecorrerMiConjunto(){
            aux = new ArrayList<T>(datos);
            Collections.shuffle(aux);
        }
        public boolean hasNext() {
            return !aux.isEmpty();
        }
        public T next() {
            if(!hasNext())
                throw new java.util.NoSuchElementException();
            actual++;
            return aux.get(actual);
        }
        public void remove() {
            throw new UnsupportedOperationException("Not supported yet.");
        }
    }
    public Conjunto3() {
        datos = new ArrayList<T>();
    }
    public void clear() {
        datos.clear();
    }
    @SuppressWarnings("element-type-mismatch")
    public boolean contains(Object o) {
        return datos.contains(o);
    }
    public int size() {
        return datos.size();
    }
    public boolean isEmpty() {
        return datos.isEmpty();
    }
    public boolean add(T e) {
        if (!datos.contains(e)) {
            return datos.add(e);
        }
        return false;
    }
    @SuppressWarnings("element-type-mismatch")
    public boolean remove(Object o) {
        return datos.remove(o);
    }
    @Override
    public String toString() {
        return datos.toString();
    }
    @Override
    public boolean equals(Object o) throws ClassCastException {
        Conjunto3<T> aux = (Conjunto3<T>) o;
        return this.datos.containsAll(aux.datos) & aux.datos.containsAll(this.datos);
    }
    public Iterator<T> iterator() {
        return new ParaRecorrerMiConjunto();
    }
    public Object[] toArray() {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public Object[] toArray(Object[] a) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean containsAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean addAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean retainAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean removeAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
}