![Nivel 26. Respuestas a las preguntas de la entrevista sobre el tema del nivel. Parte 1. Preguntas 1-5, 10. - 1]()
El resumen resultó bastante engorroso, así que lo dividí en dos partes. La segunda parte contiene respuestas a preguntas sobre kankarency y multithreading. La primera parte contiene el resto. Escribir fue bastante difícil. Todavía no entiendo mucho, así que como siempre, comentarios, observaciones y adiciones son bienvenidos)
1. ¿Cómo utilizar la interfaz Comparable?
La interfaz
Comparabledeclara solo un método
compareTo(Object obj), diseñado para implementar el orden de los objetos de clase. Es conveniente utilizarlo al ordenar listas ordenadas o matrices de objetos. Este método compara el objeto llamado con
obj. A diferencia del método
equals, que devuelve
verdadero o
falso ,
compareTodevuelve:
- 0 si los valores son iguales;
- Un valor negativo si el destinatario es menor que el parámetro;
- Positivo si el destinatario es mayor que el parámetro.
Es principalmente útil para ordenar listas ordenadas (
java.util.List) y matrices de objetos. Si la lista/matriz contiene elementos que implementan esta interfaz, entonces se pueden ordenar automáticamente por el archivo
java.util.Collections.sort(List)/Arrays.sort(Object[]). El concepto de ordenamiento natural está asociado a una interfaz
Comparable, porque establece un orden natural para las instancias de cualquier clase que implemente esta interfaz. Es decir, el orden (x, y) corresponde al cumplimiento de la condición
x.compareTo(y) <= 0. Las reglas de implementación
Comparable, o mejor dicho, de su método,
compareTo(Object)son las siguientes (x e y son instancias de la clase que implementa
Comparable):
x.compareTo(y)devuelve -1 o 1 si x debe estar antes o después de y, respectivamente. Si el método devuelve 0, entonces los órdenes (x, y) y (y, x) son equivalentes.- Si
sign(a)es una función que devuelve -1,0,1 para a, respectivamente, menor que 0, igual a 0 y mayor que 0, entonces se debe satisfacer la igualdad sign(x.compareTo(y))==-sign(y.compareTo(x)). Lo cual es lógico: si x va antes de y, entonces y debe ir después de x, y viceversa.
- Si
x.compareTo(y) > 0y y.compareTo(z) > 0, entonces x.compareTo(z) > 0– la relación de transitividad de las desigualdades.
- Si
x.compareTo(y) == 0, entonces sign(x.compare(z)) == sign(y.compareTo(z)), para cualquier z.
- La llamada
x.compareTo(null)debe generar una excepción NullPointerException. Esta es una discrepancia con la lógica de implementación equals(déjame recordarte x.equals(null)que devuelve false ).
- Si el tipo de y no se puede comparar con x, entonces la llamada
x.compareTo(y)debe generar una excepción ClassCastException.
(x.compareTo(y) == 0) == x.equals(y), es decir. la llamada x.compareTo(y)debe devolver 0 si y sólo si x.equals(y)devuelve verdadero . Esta es una regla de coherencia y es muy importante tenerla en cuenta.
Fuentes:
2. ¿Cómo utilizar la interfaz del Comparador?
La interfaz
Comparatordeclara dos métodos
compare(Object obj1, Object obj2)y
equals(Object obj). Cuando se utiliza la interfaz
Comparator, la lógica para comparar un par de objetos no está oculta dentro de la clase/objeto, sino que se implementa en una clase separada. El método
compare(x,y)es exactamente el mismo que la llamada
x.compareTo(y). Todas las reglas deben seguirse exactamente de la misma manera que las reglas para implementar un método
compareTo(Object)de interfaz
Comparable.
Comparatorse puede utilizar en cualquier lugar donde sea necesario clasificar. En este caso, en primer lugar, aparece la flexibilidad necesaria: la capacidad de implementar varias reglas de clasificación. Y en segundo lugar, es posible que los objetos que se están clasificando no implementen el
Comparable. Si lo implementan,
Comparatortiene prioridad. La interfaz
Comparatortambién define un método
equals(Object), por paradójico que parezca. Este método compara las instancias de la interfaz en sí
Comparatory solo debe devolver
verdadero si los objetos que se comparan proporcionan el mismo orden de clasificación. Sin embargo, siempre es seguro dejar
Object.equals(Object)intacta la implementación original
. Fuente:
3. ¿Qué métodos tiene la clase Colecciones?
public static <T> boolean addAll(Collection<? super T> c, T... elements) El método agrega elementos de matriz
elementsa la colección
Collection<? super T> c. Los elementos se pueden especificar individualmente o como una matriz. Cuando los elementos se especifican individualmente, este método brinda la capacidad de agregar cómodamente todos los elementos a una colección existente:
Collections.addAll(flavors, "Peaches 'n Plutonium", "Rocky Racoon");
public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) ambos métodos buscan en la lista pasada en el parámetro el objeto pasado en el parámetro utilizando un algoritmo de búsqueda binaria. Devuelve el índice del elemento si existe dicho elemento en la lista; de lo contrario, el índice del primer elemento de la lista mayor que
key, si todos los elementos son menores que
key, devuelve
list.size(). Antes de utilizar estos métodos, se deben ordenar las listas. En el primer caso, se ordenan en orden ascendente en el orden “natural” de los elementos de la lista (igual que cuando se usa
Collections.sort(list)). En el segundo caso, la lista debe ordenarse en orden ascendente en el orden proporcionado por el comparador pasado (el mismo orden que cuando se usa
Collections.sort(list, c)[aquí "con" es un comparador de los parámetros del método descrito])
public static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> type)
Preámbulo: el mecanismo genérico en el lenguaje proporciona verificación de tipos en tiempo de compilación. Normalmente esto es suficiente, pero hay ocasiones en las que no lo es. Por ejemplo, transferimos nuestra colección al código de la biblioteca, en algún lugar desconocido para nosotros, y realmente queremos que el código de esta "biblioteca de terceros" no inserte un elemento del tipo incorrecto en nuestra colección. Este es el posible problema número 1. El posible problema número 2 es el siguiente. Digamos que nuestro programa nos da un mensaje
ClassCastException
que nos notifica que se insertó un elemento del tipo incorrecto en la colección. Desafortunadamente, esta excepción puede producirse en cualquier momento después de que se haya insertado un elemento incorrecto y, por lo general, nos brinda poca o ninguna información sobre el origen del problema. Usando el método método
checkedCollectionpodemos salvarnos de los problemas uno y dos, porque este método crea una colección que es verificable en tiempo de ejecución. Resolviendo el problema número dos usando este método: Por ejemplo, tenemos esto y se cae
ClassCastException.
Collection<String> c = new HashSet<String>();
El código anterior se puede reemplazar temporalmente con:
Collection<String> c = Collections.checkedCollection(
new HashSet<String>(), String.class);
Cuando ejecutamos el programa nuevamente, localizamos la línea de código que inserta un elemento del tipo incorrecto en nuestra colección. En mi opinión, métodos relacionados:
public static <E> List<E> checkedList(List<E> list,Class<E> type)
public static <K,V> Map<K,V> checkedMap(Map<K,V> m, Class<K> keyType,Class<V> valueType)
public static <E> Set<E> checkedSet(Set<E> s,Class<E> type)
public static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m,Class<K> keyType,Class<V> valueType)
public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s,Class<E> type)
public static <T> void copy(List<? super T> dest,List<? extends T> src) el método copia elementos src al destino. los índices de los elementos copiados serán los mismos.
public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
public static <T> T min(Collection<? extends T> coll,Comparator<? super T> comp)
public static <T> T max(Collection<? extends T> coll,Comparator<? super T> comp) Los métodos devuelven el elemento mínimo/máximo de la colección en términos del "orden natural" (interfaz comparable) o el orden del comparador pasado.
public static boolean disjoint(Collection<?> c1,Collection<?> c2) Devuelve
verdadero si las colecciones no tienen elementos idénticos.
<T> List <T> emptyList(), <K,V> Map <K,V> emptyMap(),
<T> Set <T> emptySet()– devolver una lista, un mapa y un conjunto vacíos, respectivamente;
<T> void fill(List<? super T> list, T obj)– llena la lista con el elemento dado;
int frequency(Collection<?> c, Object o)– devuelve el número de apariciones de un elemento determinado en la colección;
<T> List <T> nCopies(int n, T o)– devuelve una lista de
n elementos especificados;
<T> boolean replaceAll(List<T> list, T oldVal, T newVal)– reemplaza todos los elementos especificados por otros nuevos;
void reverse(List<?> list)– “invierte” la lista;
void rotate(List<?> list, int distance)– desplaza la lista cíclicamente en un número específico de elementos;
void shuffle(List<?> list)– baraja los elementos de la lista;
<T> Set <T> singleton(T o), singletonList(T o), singletonMap(K key, V value)– crear un conjunto, una lista y un mapa de visualización que consta de un elemento;
<T extends Comparable<? super T>> void sort(List<T> list),
<T> void sort(List<T> list, Comparator<? super T> c)– ordenar la lista, en orden natural y utilizarla
Comparatoren consecuencia;
void swap(List<?> list, int i, int j)– intercambia elementos de la lista en posiciones específicas.
Fuentes:
4. ¿Qué métodos tiene la clase Arrays?
Se puede ver una lista completa de métodos de la clase Arrays en
la documentación . En este resumen citaré sólo algunos de ellos. [Métodos traducidos de la documentación y desafortunadamente perdí la mayor parte de mi traducción. Es una pena y no quiero perder el tiempo en lo mismo, así que pegaré lo que busqué en Google]
public static <T> List<T> asList(T... a) genera una lista basada en una matriz. La matriz se utiliza para la representación interna de la lista. Esto preserva la conexión entre la lista y la matriz original: los cambios en la matriz se reflejarán en la lista:
String[] a = { "foo", "bar", "baz"};
List<String> list = Arrays.asList(a);
System.out.println(list);
a[0] = "aaa";
System.out.println(list);
Los cambios en la lista se reflejarán en la matriz:
String[] a = { "foo", "bar", "baz"};
List<String> list = Arrays.asList(a);
System.out.println(list);
list.set(0, "bbb");
System.out.println(Arrays.toString(a));
Si la matriz contiene objetos, obviamente tanto la matriz como la lista harán referencia a las mismas instancias:
Object[] a = { new Object(), new Object(), new Object()};
List<Object> list = Arrays.asList(a);
System.out.println(a[0] == list.get(0));
int binarySearch(параметры)– un método sobrecargado para organizar una búsqueda binaria de un valor en matrices de tipos primitivos y de objetos. Devuelve la posición del primer partido;
void fill(параметры)– un método sobrecargado para llenar matrices con valores de varios tipos y primitivos;
void sort(parámetros) : un método sobrecargado para ordenar una matriz o parte de ella usando la interfaz Comparator y sin ella;
static <T> T[] copyOf(T[] original, int newLength)– llena una matriz de cierta longitud, descartando elementos o rellenándola con nulos si es necesario;
static <T> T[] copyOfRange(T[] original, int from, int to)– copia el área especificada de la matriz en una nueva matriz;
<T> List<T> asList(T… a)– un método que copia elementos de una matriz en un objeto de tipo Lista<T>.
Fuente:
5. ¿Cuál es el nombre del tipo utilizado al llamar a Collections.sort()?
De la documentación : La implementación es una adaptación de la clasificación de listas de Python de Tim Peters (TimSort). Esta implementación vuelca la lista en una matriz, ordena la matriz, luego recorre la lista en iteración y recarga cada elemento de la lista desde el elemento de matriz correspondiente. Esto evita la complejidad n*n log(n) que surgiría al intentar ordenar una lista enlazada directamente.
Desde la wiki : Timsort es un algoritmo de clasificación híbrido que combina ordenación por inserción y ordenación por fusión, publicado en 2002 por Tim Peters. Timsort es actualmente el algoritmo de clasificación estándar en Python, OpenJDK 7 e implementado en Android JDK 1.5. La idea principal del algoritmo es que en el mundo real, las matrices de datos ordenables a menudo contienen subarreglos ordenados. Con estos datos, Timsort es significativamente más rápido que muchos algoritmos de clasificación.
10. ¿Qué es un iterador?
La interfaz introducida en la versión JDK 1.2 del lenguaje Java
java.util.Iteratorpermite la iteración de clases de contenedor. Cada iterador implementa métodos
next()y,
hasNext()opcionalmente, puede admitir un archivo
remove(). Los iteradores son creados por las clases de contenedor correspondientes, generalmente por el archivo
iterator(). El método
next()hace avanzar el iterador al siguiente valor y devuelve el valor especificado al iterador. Cuando se crea inicialmente, el iterador apunta a un valor especial antes del primer elemento, por lo que el primer elemento solo se puede recuperar después de la primera llamada a
next(). Para determinar el momento en que se han iterado todos los elementos del contenedor se utiliza el método de prueba
hasNext(). El siguiente ejemplo demuestra el uso simple de iteradores:
Iterator iter = list.iterator();
while (iter.hasNext())
System.out.println(iter.next());
Para una colección de tipos que admite esto, el método iterador
remove()elimina el último elemento "visitado" del contenedor. Casi todos los demás tipos de modificación de contenedores durante la iteración no son seguros. Además, for
java.util.Listexiste
java.util.ListIteratorcon una API similar, pero permite la iteración hacia adelante y hacia atrás, proporcionando la definición del índice actual en la lista y moviéndose al elemento según su posición.
Fuente:
Parte 2
GO TO FULL VERSION