En PC Resumen hablaremos de los algoritmos reverse, fill, copy, max, min en Java. El algoritmo reverse invierte el orden de los elementos en un objeto List y el algoritmo fill sobrescribe los elementos con un valor especificado. El algoritmo copy recibe dos argumentos List, el origen y el destino y hace una copia. Si el objeto destino es más largo, los elementos que no se sobrescriban quedarán sin cambios.

Todos los algoritmos que hemos visto hasta ahora trabajan con objetos List. Los algoritmos min y max operan en cualquier objeto Collection y devuelven respectivamente el elemento más pequeño y el más grande. Ambos algoritmos pueden llamarse con un objeto Comparator como segundo argumento para realizar comparaciones personalizadas.

En PC Resumen vamos a hablar del algoritmo Shuffle y os vamos a enseñar como funciona. Este algoritmo ordena al azar los elementos de un objeto List. En el programa siguiente utilizaremos este algoritmo para remover una baraja de objetos Carta.

import java.util.List;
import java.util.Arrays;
import java.util.Collections;

class Carta {
    public static enum Cara {As, Dos, Tres, Cuatro, Cinco, Seis, Siete, Ocho, Nueve, Bajo, Caballo, Rey};
    public static enum Pal {Cannes, Oros, Copas, Espadas};
    private final Cara cara;
    private final Palo palo;
    
    public Carta(Cara caraCarta, Palo paloCarta) {
        cara = caraCarta;
        palo = paloCarta;
    }

    public Cara obtenerCara() {
        return cara;
    }

    public Pal obtenerPalo() {
        return palo;
    }

    public String toString () {
        return String.format ("%s %s", cara, palo);
    }
}

public class BarajaDeCartas {
    private List<Carta> lista;
   
    public BarajaDeCartas() {
        Carta[] baraja = new Carta[48];
        int cuenta = 0; // número de cartas
        for (Carta.Pal palo: Carta.Pal.values()) {
            for (Carta.Cara cara: Carta.Cara.values()) {
                baraja[cuenta] = new Carta(cara, palo);
                cuenta ++;
            }
        }
        lista = Arrays.asList(baraja);
        Collections.shuffle(lista); // baraja
    }

    public void imprimirCartas() {
        // muestra las cartas en dos columnas
        for (int i = 0; i < llista.size(); i ++) {
            System.out.printf("% - 20s %s", lista.get(i), ((i + 1) % 2 == 0) ? "\n" : "");
        }
    }

    public static void main(String args[]) {
        BarajaDeCartas cartas = new BarajaDeCartas();
        cartas.imprimirCartas();
    }
}

En PC Resumen vamos a hablar de los diferentes tipos de algoritmos que existen en Java para las colecciones, en concreto del algoritmo sort. El marco de trabajo de colecciones cuenta con varios algoritmos de alto rendimiento para manipular los elementos de una colección. Estos algoritmos se implementan como métodos estáticos de la clase Collections. Los algoritmos min, max, addAll, frequency y disjoint operan con objetos Collection. Los algoritmos sort, binarySearch, reverse, shuffle, fill y copy operan con objetos List.

En PC Resumen vamos a hablar de como funciona la Clase Vector en Java y poner algún ejemplo práctico. Esta clase es prácticamente igual a ArrayList y es ésta la que se utiliza normalmente, excepto cuando queremos sincronización.

En cualquier momento, un objeto Vector contiene un número de elementos que es menor o igual que su capacidad. Si un Vector requiere más capacidad el programador puede incrementarla o se incrementa de forma predeterminada. Si no especificamos un incremento de capacidad o si especificamos uno que sea menor o igual que cero, el sistema duplica el tamaño del objeto cada vez que se necesite capacidad adicional.

  • Insertar un elemento en un Vector que tenga espacio es operación relativamente rápida.
  • Insertar un elemento en un Vector que no tenga espacio es operación relativamente lenta.
  • Si el almacenamiento es fundamental, utilice el método trimToSize para recortar la capacidad a su medida exacta. Lógicamente cuando se agregue otro elemento, éste se verá forzado a crecer de forma dinámica.

En PC Resumen vamos a ver como funcionan las LinkedList en el lenguaje de programación Java. En el programa siguiente se muestran operaciones con objetos LinkedList. El programa crea dos objetos que contienen String. Los elementos de una lista se agregan a otra. Después todos los objetos String se convierten a mayúsculas y elimina un rango de elementos.

import java.util.List;
import java.util.LinkedList;
import java.util.ListIterator;

public class PruebaList {
    private static final String colores[] = {"negro", "amarillo", "Verde", "azul", "violeta", "plateado"};
    private static final String colores2[] = {"dorado", "blanco", "Café", "azul", "gris", "plateado"};

    public PruebaList() {
        List <String> lista1 = new LinkedList <String> ();
        List <String> lista2 = new LinkedList <String> ();
        for (String color: colores) {
            lista1.add (color);
        }
        for (String color: colores2) {
            lista2.add (color);
        }
        lista1.addAll(lista2); // concatena las listas
        lista2 = null; // libera recursos
        imprimirLista(lista1);
        convertirCadenesAMajuscules(lista1);
        imprimirLista(lista1);
        System.out.print("\nEliminando elementos 4 a 6 ...");
        eliminarElementos(lista1, 4, 7);
        imprimirLista(lista1);
        imprimirListaInversa(lista1);
    }

    public void imprimirLista(List <String> lista) {
        System.out.println ("\ nllista:");
        for (String color: lista) {
            System.out.printf ("% s", color);
        }
        System.out.println();
    }

    private void convertirCadenasAMajusculas (List <String> lista) {
        ListIterator<String> iterador = lista.listIterator();
        while (iterador.hasNext()) {
            String color = iterador.next ();
            iterador.set(color.toUpperCase());
        }
    }

    private void eliminarElementos(List<String> lista, int inicio, int fin) {
        lista.subList (inicio, fin).clear();
    }
    
    private void imprimirListaInversa(List <String> lista) {
        ListIterator<String> iterador = lista.listIterator(lista.size());
        System.out.println("\nLista inversa:");
        while (iterador.hasPrevious()) {
            System.out.printf("%s", iterador.previous());
        }
    }

    public static void main(String args[]) {
        new PruebaList();
    }
}