Concatenar arrays

Por razones de rendimiento es mejor usar arrays que colecciones, siempre que sea posible o conveniente.

Sin embargo, el JDK no contiene métodos para realizar operaciones usuales con arrays, como concatenar.

Siguen dos ejemplos que permiten concatenar dos o varios arrays.

public static <T> T[] concat(final T[] first, final T[] second) {

   final T[] result = Arrays.copyOf(first, first.length + second.length);

   System.arraycopy(second, 0, result, first.length, second.length);

   return result;

}

Click to read more ...

Problema con iteración

Se sabe que los iteradores no son thread-safe. Lo mismo pueden lanzar una ConcurrentModificationException, que mostrar resultados inconsistentes, en un entorno multitarea.

Me he encontrado con el siguiente problema: 

   @Override

    public List<String> getCovers(final List<Release> releases) {

        final List<String> coversURL = new ArrayList<>(2 * releases.size());

        for (final Iterator<Release> it = releases.iterator(); it.hasNext();) {

            coversURL.add(it.next().getThumb());

        }

        return coversURL;

    }

Este método forma parte de una clase que funciona como Service Provider, y al que se accede mediante un interface.

Click to read more ...

Recorrer un Map<K,V>

Puesto que Map<K,V> al igual que List<E> suelen ser dos de las estructuras de datos más usadas, propongo una discusión sobre la manera más eficiente de recorrer un Map<K,V> en función del resultado que queramos obtener.

1.- Hallar una clave determinada

2.- Hallar un valor determinado

3.- Hallar una combinación de clave y valor determinados.

Bucle infinito en WeakHashMap no sincronizado

Acabo de leer un artículo en el blog de Adam Bien, donde asegura que se puede producir un bucle infinito en el método get(Object key) de java.util.WeakHashMap

Ya se sabe que esa clase no es thread-safe; sin embargo que pueda producir un bucle infinito, si no está sincronizada, me suena extraño, como poco.

Aunque asegura que es un caso raro, proporciona datos de casos reales en los que se ha producido.

¡Habrá que tenerlo en cuenta, por si acaso!

Clases y tipos genéricos

En Java, cuando definimos una nueva clase, debemos conocer el tipo de dato con el que trabajaremos. Si queremos realizar una operación específica dentro de esta nueva clase, sea cual sea el tipo de datos que va a recibir, podemos hacer uso de los tipos genéricos. Este tipo genérico asumirá el tipo de dato que realmente le pasaremos a la clase.

Click to read more ...

Crear un Singleton

Pocos temas en Java han creado tanta controversia sobre la mejor manera de crear un Singleton.

En el siguiente artículo Singleton design in Java el autor muestra todas las maneras de crearlo, con ejemplos prácticos, señalando sus ventajas en inconvenientes, para concluir con dos alternativas seguras, desde todos los puntos de vista.

Sobre el uso de enum como Singleton, el artículo Why enum Singleton are better arroja más luz a la cuestión.

1.- Usar una clase estática interna

public class BiilPughSingleton {
private BiilPughSingleton() {
}
private static class LazyHolder {
private static final BiilPughSingleton INSTANCE = new BiilPughSingleton();
}
public static BiilPughSingleton getInstance() {
return LazyHolder.INSTANCE;
}
}

2.- Usar una clase enum

public enum EnumSingleton {
INSTANCE;
public static void someMethod (String param) {
//some class member
}
}

Inicialización de arrays bidimensionales

Aunque no se usan con tanta frecuencia como los arrays de una única dimensión, el JDK no proporciona métodos para inicializar estos arrays con un valor determinado.

Se trata de encontrar la manera más eficiente de construir métodos como los que siguen: 

  public <T> void fill(T[][] array, T element) {

      // código que realiza la inicialización del array con el elemento

    }

 public void fill(int[][] array, int element) {

     // código que realiza la inicialización del array con el elemento

    }

  public void fill(double[][] array, double element) {

     // código que realiza la inicialización del array con el elemento

    }

   public static void fill(float[][] array, float element) {

     // código que realiza la inicialización del array con el elemento

    }

e incorporarlos a una clase que podamos añadir a nuestra "caja de herramientas".

División de Arrays

La principal característica del nuevo Fork/Join de JavaSE 1.7 consiste en dividir una estructura de datos en partes, más o menos iguales, para ejecutar operaciones en paralelo con cada parte, y agregar los resultados obtenidos al final. Sigue la idea "Divide y vencerás".

La mayoría, por no decir todos, los ejemplos que se encuentran se limitan a dividir por la mitad, cuando lo más eficiente sería dividir en función del número de procesadores existentes.

Por eso quiero proponer un problema (que no tiene nada que ver con el uso de Fork/Join), que consiste en encontrar una manera eficiente y clara de dividir un array en partes, aproximadamente iguales.

Dada una clase como la siguiente: 

public class SplitArray<T> {

    private final T[] array;

    public SplitArray(final T[] array) {

    if (array == null || array.length == 0) {

            throw new IllegalArgumentException("array cannot be null or empty");

        }

    this.array = Arrays.copyOf(array, array.length);

    }  

    public List<T[]> splitArray(final int divisions) {

        final List<T[]> result;

        // aquí va el código que se busca

        return result;

    }

}

se trata de encontrar un código que devuelva el resultado deseado.

El parámetro divisions indica el número de divisiones deseadas.

Seguimos con el paso de parámetros... ¿cómo resolverías el siguiente problema?

Tenemos:

-Lista 1 = Lista de Strings con valores.

-Método 1: tiene visibilidad sobre la vista y llama al método 2.

-Método 2: recibe la lista, realiza modificaciones sobre la misma, agregando, eliminando y modificando.

-Método 1: tiene visibilidad sobre la lista modificada y prosigue la ejecución del programa.

Se pide código, por favor.

Refactorización de un POJO

Puestos a plantear cuestiones que sugieran un debate, a la par que ayuden a mejorar el dominio del lenguaje, y la calidad del código, propongo un asunto bastante habitual.

Supongamos que tenemos una clase como la que sigue:

public class Lista<T> {

    private List<T> lista;

    public List<T> getLista() {

        return lista;

    }

    public void setLista(List<T> lista) {

        this.lista = lista;

    }

}

Con una refactorización del campo que es habitual en los IDE.

Se pretende refactorizar la clase, de manera que sea thread-safe, y que sea segura en todos los aspectos.