generics class<t> - Genéricos de Java:Comparando la clase del Objeto o con<E>





metodos genericos (5)


Una instancia de Test no tiene información sobre qué E es en tiempo de ejecución. Por lo tanto, debe pasar una Class<E> al constructor de Prueba.

public class Test<E> {
    private final Class<E> clazz;
    public Test(Class<E> clazz) {
        if (clazz == null) {
            throw new NullPointerException();
        }
        this.clazz = clazz;
    }
    // To make things easier on clients:
    public static <T> Test<T> create(Class<T> clazz) {
        return new Test<T>(clazz);
    }
    public boolean sameClassAs(Object o) {
        return o != null && o.getClass() == clazz;
    }
}

Si desea una relación de "instancia de", use Class.isAssignableFrom lugar de la comparación de Class . Tenga en cuenta que E tendrá que ser un tipo no genérico, por la misma razón por la que Test necesita el objeto Class .

Para ver ejemplos en la API de Java, consulte java.util.Collections.checkedSet y similares.

Digamos que tengo la siguiente clase:

public class Test<E> {
    public boolean sameClassAs(Object o) {
        // TODO help!
    }
}

¿Cómo verificaría que o es la misma clase que E ?

Test<String> test = new Test<String>();
test.sameClassAs("a string"); // returns true;
test.sameClassAs(4); // returns false;

No puedo cambiar la firma del método de (Object o) ya que estoy redefiniendo una superclase y no puedo elegir la firma de mi método.

También preferiría no ir por el camino de intentar un elenco y luego atrapar la excepción resultante si falla.




Solo estaba tratando de hacer lo mismo, y un truco ingenioso que acabo de darme cuenta es que puedes probar un yeso, y si el lanzamiento falla, se lanzará ClassCastException. Puedes atrapar eso y hacer lo que sea.

por lo que su método sameClassAs debería ser similar a:

public boolean sameClassAs(Object o) {
    boolean same = false;
    try {
        E t = (E)o;
        same = true;
    } catch (ClassCastException e) {
        // same is false, nothing else to do
    } finally {
        return same;
    }
}



El método que siempre he usado está a continuación. Es un dolor y un poco feo, pero no he encontrado uno mejor. Debe pasar el tipo de clase en la construcción, ya que cuando se compila Generics, la información de la clase se pierde.

public class Test<E> {
    private Class<E> clazz;
    public Test(Class<E> clazz) {
       this.clazz = clazz;
    }
    public boolean sameClassAs(Object o) {
        return this.clazz.isInstance(o);
    }
}



Solo podría hacerlo funcionar así:

public class Test<E> {  

    private E e;  

    public void setE(E e) {  
        this.e = e;  
    }

    public boolean sameClassAs(Object o) {  

        return (o.getClass().equals(e.getClass()));  
    }

    public boolean sameClassAs2(Object o) {  
        return e.getClass().isInstance(o);  
    }
}



ThreadLocalRandom equivalente de la clase java.util.Random para un entorno multiproceso. La generación de un número aleatorio se lleva a cabo localmente en cada uno de los hilos. Así que tenemos un mejor desempeño al reducir los conflictos.

int rand = ThreadLocalRandom.current().nextInt(x,y);

x, y - intervalos por ejemplo (1,10)





java generics