![Livello 26. Risposte alle domande dell'intervista sull'argomento del livello. Parte 1. Domande 1-5, 10. - 1]()
Il riassunto si è rivelato piuttosto macchinoso, quindi l'ho diviso in due parti. La seconda parte contiene le risposte a domande riguardanti kankarency e multithreading. La prima parte contiene il resto. Scrivere è stato piuttosto difficile. Ancora non capisco molto, quindi come sempre ben vengano commenti, osservazioni, integrazioni)
1. Come utilizzare l'interfaccia Comparable?
L'interfaccia
Comparabledichiara un solo metodo
compareTo(Object obj), progettato per implementare l'ordinamento degli oggetti della classe. È comodo da usare quando si ordinano elenchi ordinati o matrici di oggetti. Questo metodo confronta l'oggetto chiamato con
ogg. A differenza del metodo
equals, che restituisce
true o
false ,
compareTorestituisce:
- 0 se i valori sono uguali;
- Un valore negativo se il chiamato è inferiore al parametro;
- Positivo se il chiamato è maggiore del parametro.
È utile principalmente per ordinare elenchi ordinati (
java.util.List) e array di oggetti. Se l'elenco/array contiene elementi che implementano questa interfaccia, possono essere ordinati automaticamente dal file
java.util.Collections.sort(List)/Arrays.sort(Object[]). Il concetto di ordinamento naturale è associato a un'interfaccia
Comparable, poiché stabilisce un ordine naturale per le istanze di qualsiasi classe che implementa questa interfaccia. In altre parole, l'ordine (x, y) corrisponde al soddisfacimento della condizione
x.compareTo(y) <= 0. Le regole dell'implementazione
Comparable, o meglio, del suo metodo,
compareTo(Object)sono le seguenti (xey sono istanze della classe che implementa
Comparable):
x.compareTo(y)restituisce -1 o 1 se x deve essere rispettivamente prima o dopo y. Se il metodo restituisce 0, gli ordini (x, y) e (y, x) sono equivalenti.- Se
sign(a)è una funzione che restituisce -1,0,1 per a, rispettivamente, minore di 0, uguale a 0 e maggiore di 0, allora l'uguaglianza deve essere soddisfatta sign(x.compareTo(y))==-sign(y.compareTo(x)). Il che è logico: se x viene prima di y, allora y deve venire dopo x e viceversa.
- Se
x.compareTo(y) > 0e y.compareTo(z) > 0, allora x.compareTo(z) > 0– la relazione di transitività delle disuguaglianze.
- Se
x.compareTo(y) == 0, allora sign(x.compare(z)) == sign(y.compareTo(z)), per qualsiasi z.
- La chiamata
x.compareTo(null)deve generare un'eccezione NullPointerException. Questa è una discrepanza con la logica di implementazione equals(lascia che te lo ricordi, x.equals(null)restituisce false ).
- Se il tipo di y non può essere confrontato con x, la chiamata
x.compareTo(y)deve generare un'eccezione ClassCastException.
(x.compareTo(y) == 0) == x.equals(y), cioè. la chiamata x.compareTo(y)deve restituire 0 se e solo se x.equals(y)restituisce true . Questa è una regola di coerenza ed è molto importante da considerare.
Fonti:
2. Come utilizzare l'interfaccia del Comparatore?
L'interfaccia
Comparatordichiara due metodi
compare(Object obj1, Object obj2)e
equals(Object obj). Quando si utilizza l'interfaccia
Comparator, la logica per confrontare una coppia di oggetti non è nascosta all'interno della classe/oggetto, ma è implementata in una classe separata. Il metodo
compare(x,y)è esattamente lo stesso della chiamata
x.compareTo(y). Tutte le regole devono essere seguite esattamente allo stesso modo delle regole per implementare un metodo
compareTo(Object)di interfaccia
Comparable.
Comparatorpuò essere utilizzato ovunque sia necessario lo smistamento. In questo caso, in primo luogo, appare la flessibilità necessaria: la capacità di implementare diverse regole di ordinamento. In secondo luogo, gli oggetti da ordinare potrebbero non implementare il formato
Comparable. Se lo implementano,
Comparatorha la priorità. L'interfaccia
Comparatordefinisce anche un metodo
equals(Object), per quanto paradossale possa sembrare. Questo metodo confronta le istanze dell'interfaccia stesse
Comparatore dovrebbe restituire
true solo se gli oggetti confrontati forniscono lo stesso ordinamento. Tuttavia, è sempre sicuro lasciare
Object.equals(Object)intatta l'implementazione originale
Fonte:
3. Quali metodi ha la classe Collections?
public static <T> boolean addAll(Collection<? super T> c, T... elements) Il metodo aggiunge elementi dell'array
elementsalla raccolta
Collection<? super T> c. Gli elementi possono essere specificati singolarmente o come array. Quando gli elementi vengono specificati singolarmente, questo metodo offre la possibilità di aggiungere comodamente tutti gli elementi a una raccolta esistente:
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) entrambi i metodi cercano nell'elenco passato nel parametro l'oggetto passato nel parametro utilizzando un algoritmo di ricerca binaria. Restituisce l'indice dell'elemento se esiste tale elemento nella lista, altrimenti l'indice del primo elemento della lista maggiore di
key, se tutti gli elementi sono minori di
key, restituisce
list.size(). Prima di utilizzare questi metodi, gli elenchi devono essere ordinati. Nel primo caso vengono ordinati in ordine crescente secondo l'ordine “naturale” degli elementi della lista (lo stesso di quando si utilizza
Collections.sort(list)). Nel secondo caso, l'elenco deve essere ordinato in ordine crescente secondo l'ordine fornito dal comparatore passato (lo stesso ordine di quando si utilizza
Collections.sort(list, c)[qui "con" è un comparatore dai parametri del metodo descritto])
public static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> type)
Preambolo: il meccanismo dei generici nel linguaggio fornisce il controllo del tipo in fase di compilazione. Di solito questo è sufficiente, ma ci sono momenti in cui non lo è. Ad esempio, trasferiamo la nostra collezione nel codice della libreria, da qualche parte a noi sconosciuta, e vogliamo davvero che il codice di questa “libreria di terze parti” non inserisca un elemento del tipo sbagliato nella nostra collezione. Questo è il possibile problema numero 1. Il possibile problema numero 2 è il seguente. Diciamo che il nostro programma ci dà un messaggio
ClassCastException
che ci avvisa che nella collezione è stato inserito un elemento di tipo sbagliato. Sfortunatamente, questa eccezione può essere lanciata in qualsiasi momento dopo che è stato inserito un elemento errato e di solito ci fornisce poche o nessuna informazione sull'origine del problema. Usando il metodo del metodo
checkedCollectionpossiamo salvarci dai problemi uno e due, perché questo metodo crea una raccolta verificabile in fase di esecuzione. Risolvere il problema numero due utilizzando questo metodo: ad esempio, abbiamo questo e cade
ClassCastException.
Collection<String> c = new HashSet<String>();
Il codice sopra può essere temporaneamente sostituito con:
Collection<String> c = Collections.checkedCollection(
new HashSet<String>(), String.class);
Quando eseguiamo nuovamente il programma, localizziamo la riga di codice che inserisce nella nostra collezione un elemento del tipo sbagliato. Metodi correlati secondo me:
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) il metodo copia gli elementi src in dest. gli indici degli elementi copiati saranno gli stessi.
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) i metodi restituiscono l'elemento minimo/massimo nella raccolta in termini di “ordine naturale” (interfaccia comparabile) o dell'ordine del comparatore passato.
public static boolean disjoint(Collection<?> c1,Collection<?> c2) Restituisce
vero se le raccolte non hanno elementi identici.
<T> List <T> emptyList(), <K,V> Map <K,V> emptyMap(),
<T> Set <T> emptySet()– restituisce rispettivamente una lista, una mappa e un set vuoti;
<T> void fill(List<? super T> list, T obj)– riempie la lista con l'elemento indicato;
int frequency(Collection<?> c, Object o)– restituisce il numero di occorrenze di un dato elemento nella raccolta;
<T> List <T> nCopies(int n, T o)– restituisce una lista di
n elementi specificati;
<T> boolean replaceAll(List<T> list, T oldVal, T newVal)– sostituisce tutti gli elementi specificati con altri nuovi;
void reverse(List<?> list)– “inverte” la lista;
void rotate(List<?> list, int distance)– sposta ciclicamente la lista di un numero specificato di elementi;
void shuffle(List<?> list)– mescola gli elementi dell'elenco;
<T> Set <T> singleton(T o), singletonList(T o), singletonMap(K key, V value)– creare un insieme, un elenco e una mappa di visualizzazione composta da un elemento;
<T extends Comparable<? super T>> void sort(List<T> list),
<T> void sort(List<T> list, Comparator<? super T> c)– ordinare l'elenco, in ordine naturale e utilizzarlo
Comparatordi conseguenza;
void swap(List<?> list, int i, int j)– scambia gli elementi dell'elenco nelle posizioni specificate.
Fonti:
4. Quali metodi ha la classe Arrays?
Un elenco completo dei metodi della classe Arrays può essere visto nella
documentazione . In questa sintesi ne citerò solo alcuni. [metodi tradotti dalla documentazione e sfortunatamente ho perso la maggior parte della mia traduzione. È un peccato e non voglio perdere tempo con la stessa cosa, quindi incollo quello che ho cercato su Google]
public static <T> List<T> asList(T... a) genera un elenco basato su un array. L'array viene utilizzato per la rappresentazione interna della lista. Ciò preserva la connessione tra l'elenco e l'array originale: le modifiche nell'array si rifletteranno nell'elenco:
String[] a = { "foo", "bar", "baz"};
List<String> list = Arrays.asList(a);
System.out.println(list);
a[0] = "aaa";
System.out.println(list);
le modifiche nell'elenco si rifletteranno nell'array:
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));
Se l'array contiene oggetti, ovviamente sia l'array che la lista faranno riferimento alle stesse istanze:
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 metodo sovraccarico per organizzare una ricerca binaria di un valore in array di tipi primitivi e di oggetti. Restituisce la posizione della prima corrispondenza;
void fill(параметры)– un metodo sovraccaricato per riempire gli array con valori di vario tipo e primitive;
void sort(parametri) – un metodo sovraccaricato per ordinare un array o parte di esso utilizzando l'interfaccia Comparator e senza di essa;
static <T> T[] copyOf(T[] original, int newLength)– riempie un array di una certa lunghezza, scartando elementi o riempiendoli con null se necessario;
static <T> T[] copyOfRange(T[] original, int from, int to)– copia l'area specificata dell'array in un nuovo array;
<T> List<T> asList(T… a)– un metodo che copia gli elementi dell'array in un oggetto di tipo List<T>.
Fonte:
5. Qual è il nome dell'ordinamento utilizzato quando si chiama Collections.sort()?
Dalla documentazione : l'implementazione è un adattamento dell'ordinamento di elenchi Python di Tim Peters (TimSort). Questa implementazione scarica l'elenco in un array, ordina l'array, quindi scorre l'elenco e ricarica ogni elemento dell'elenco dall'elemento dell'array corrispondente. Ciò evita la complessità n*n log(n) che deriverebbe dal tentativo di ordinare direttamente un elenco collegato
Dal wiki : Timsort è un algoritmo di ordinamento ibrido che combina l'ordinamento per inserzione e l'ordinamento per unione, pubblicato nel 2002 da Tim Peters. Timsort è attualmente l'algoritmo di ordinamento standard in Python, OpenJDK 7 e implementato in Android JDK 1.5. L'idea principale dell'algoritmo è che nel mondo reale gli array di dati ordinabili spesso contengono sottoarray ordinati. Su tali dati, Timsort è significativamente più veloce di molti algoritmi di ordinamento.
10. Cos'è un iteratore?
L'interfaccia introdotta nella versione JDK 1.2 del linguaggio Java
java.util.Iteratorconsente l'iterazione delle classi contenitore. Ogni Iterator implementa metodi
next()e
hasNext()può facoltativamente supportare un file
remove(). Gli iteratori vengono creati dalle classi contenitore corrispondenti, solitamente da
iterator(). Il metodo
next()fa avanzare l'iteratore al valore successivo e restituisce il valore specificato all'iteratore. Quando creato inizialmente, l'iteratore punta a un valore speciale prima del primo elemento, quindi il primo elemento può essere recuperato solo dopo la prima chiamata a
next(). Per determinare il momento in cui tutti gli elementi nel contenitore sono stati iterati, viene utilizzato il metodo test
hasNext(). L'esempio seguente dimostra il semplice utilizzo degli iteratori:
Iterator iter = list.iterator();
while (iter.hasNext())
System.out.println(iter.next());
Per una raccolta di tipi che lo supporta, il metodo iteratore
remove()rimuove l'ultimo elemento "visitato" dal contenitore. Quasi tutti gli altri tipi di modifica del contenitore durante l'iterazione non sono sicuri. Inoltre, for
java.util.Listesiste
java.util.ListIteratorcon un'API simile, ma consente l'iterazione in avanti e all'indietro, fornendo la definizione dell'indice corrente nell'elenco e spostandosi all'elemento in base alla sua posizione.
Fonte:
Parte 2
GO TO FULL VERSION