Pausa caffè #167. Cose da rivedere prima di un colloquio Java. Qual è la differenza tra enum e iteratore in Java?

Cose da rivedere prima di un colloquio Java

Fonte: Medium In questo articolo troverai 17 suggerimenti di uno sviluppatore esperto che ti aiuteranno in un colloquio Java. Lavoro nel settore IT da oltre 20 anni e ho trascorso la maggior parte del tempo lavorando con Java. Inoltre, ho acquisito una notevole esperienza intervistando sviluppatori Java. Sebbene il linguaggio Java sia in continua evoluzione, i concetti fondamentali rimangono sostanzialmente gli stessi. Ecco alcuni suggerimenti che voglio condividere con gli aspiranti sviluppatori prima che vadano a fare un colloquio. Se li ripeti, ti salverai da errori gravi.

1. La classe Object è alla radice della gerarchia delle classi Java. Tutte le classi Java risalgono a Object . Anche se una classe non estende esplicitamente alcuna classe, estende Object . Tuttavia, una classe è libera di estendere Object in modo esplicito.

2. In Java è possibile estendere solo una classe (l'ereditarietà multipla non è consentita a causa dell'ambiguità). Tuttavia, una classe può implementare un numero qualsiasi di interfacce contemporaneamente.

3. Un'interfaccia estende un'altra interfaccia (al contrario di un'implementazione).

4. Esistono quattro modificatori di accesso in Java: public (disponibile a tutti), protected (disponibile solo per le sottoclassi), private (disponibile solo all'interno di una singola classe), default (disponibile all'interno di un singolo pacchetto). Va notato che le sottoclassi della stessa classe possono trovarsi in pacchetti diversi. La classe genitore e le sottoclassi non devono necessariamente far parte dello stesso pacchetto.

5. La stringa della classe è immutabile. Immutabilità significa che la classe String stessa non fornisce alcun metodo per sostituire il valore in un riferimento String . Se si desidera sostituire il valore di un riferimento a una stringa, è necessario assegnare il valore in modo esplicito utilizzando l' operatore = . Confrontalo con le classi StringBuffer o StringBuilder , che hanno metodi come append in modo da non dover utilizzare l' operatore = lì .

6. ConcurrentHashMap è più efficiente di Hashtable . ConcurrentHashMap opera su segmenti della struttura dati sottostante, in cui un'operazione di scrittura blocca solo un segmento specifico (indipendentemente dal segmento a cui appartiene la chiave). Tuttavia, in Hashtable l'intera struttura dei dati verrà bloccata.

7. ConcurrentHashMap è più lento di HashMap perché HashMap non implementa la sicurezza del thread. HashMap può lanciare una ConcurrentModificationException se un thread esegue un'iterazione su una HashMap e un altro thread tenta di modificare la stessa HashMap . ConcurrentHashMap non genererà un'eccezione qui.

8. Come implementare l'uguaglianza di due oggetti della stessa classe che hai definito? Risposta: questo può essere fatto sovrascrivendo il metodo hashcode() .

9. Qual è il risultato predefinito del metodo toString() ? Risposta: è la concatenazione del nome della classe, del segno @ e del valore hashcode() .

10. Come implementare il polimorfismo in Java? Un modo per farlo è sovraccaricare il metodo. Un altro modo è sovrascrivere il metodo.

11. Come si chiama un costruttore di superclasse da una classe figlia? Risposta: questo può essere fatto utilizzando la parola chiave super() . Il metodo super() senza argomenti viene sempre chiamato, anche se non è specificato esplicitamente. Il metodo super() con un argomento deve essere specificato esplicitamente. Una chiamata a super() (con o senza argomento) deve sempre essere la prima riga nel costruttore della classe figlia se è necessario chiamarla.

12. Cosa sono le eccezioni verificate e non verificate? Risposta: le eccezioni controllate sono quelle che devono essere dichiarate o catturate nel metodo in cui si prevede che vengano lanciate. Un'eccezione non controllata non presenta questa limitazione. java.io.IOException è un esempio di eccezione verificata. Le eccezioni non controllate provengono dalla classe RunTimeException .

13. La classe radice della gerarchia delle eccezioni è Throwable (che a sua volta estende implicitamente Object ). L'eccezione e l'errore provengono da Throwable .

14. A partire da Java 8, i metodi possono avere un'implementazione in un'interfaccia. I metodi predefiniti e i metodi statici possono avere implementazioni.

15. Non è possibile istanziare una classe qualificata come astratta . Qualsiasi classe che non fornisce un corpo per nessuno dei metodi deve essere dichiarata astratta. Uno sviluppatore può dichiarare una classe astratta anche se tutti i metodi hanno un corpo - tuttavia, questo non è molto consigliato perché in questo caso la classe non può essere istanziata.

16. La lezione finale non può essere prolungata. A una variabile finale non può essere assegnato un altro valore. Non è possibile sovrascrivere un metodo finale .

17. Quali parole chiave sono richieste in un costrutto try-catch-finally ? Potrebbe essere try-catch , try-finally o tutti e tre. In questo caso, catch non è una parola chiave obbligatoria.

Qual è la differenza tra enum e iteratore in Java?

Fonte: Rrtutors Questo post presentato discute le differenze tra enumerazione e iterazione in Java. Il pacchetto Java.util fornisce due interfacce per attraversare gli elementi di un oggetto Collection : Enumerazione e Iterator . Anche se entrambi passano attraverso un oggetto Collection , esistono alcune differenze tra loro.

Differenze tra enum e iteratore

• Tempo aggiunto a JDK: vengono introdotti in momenti diversi. Enum è stato introdotto in JDK 1.0, mentre iterator è stato introdotto in JDK 1.2.

• Rimozione di elementi: questa è la differenza principale tra i due. Nell'interfaccia Iterator , possiamo rimuovere un elemento durante l'iterazione su un oggetto Collection , mentre non possiamo modificarlo durante l'iterazione su un oggetto Collection utilizzando Enumeration . Questo perché l' interfaccia Iterator ha un metodo Remove() , ma l' interfaccia Enumeration no.

• Tipo di operazione: l'iteratore ha il tipo di operazione fail-fast e l'enumerazione ha il tipo di operazione fail-safe. Di conseguenza, Iterator lancia una ConcurrentModificationException quando la raccolta viene modificata durante l'iterazione a meno che non venga utilizzato il proprio metodo delete() , mentre Enumeration non genera alcuna eccezione quando la raccolta viene modificata durante l'iterazione.

Esempi di enumerazione ed iteratori in Java

Esempio di enumerazione

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Enumeration;

import java.util.List;

import java.util.Vector;

public class Enumeration_Example {

      public static void main(String[] args) {

                  List laptoplist = new ArrayList(Arrays.asList( new String[] {"Samsung", "Lenovo", "Apple", "HP"}));

            Vector vectali = new Vector(laptoplist);

            delete(vectali, "Samsung");

        }

        private static void delete(Vector vectali, String laptop) {

            Enumeration lapi = vectali.elements();

            while (lapi.hasMoreElements()) {

              String s = (String) lapi.nextElement();

              if (s.equals(laptop)) {

                  vectali.remove(laptop);

              }

            }

            System.out.println("The Laptop brands includes:");

            lapi = vectali.elements();

            while (lapi.hasMoreElements()) {

              System.out.println(lapi.nextElement());

            }

      }

}

Conclusione:

Esempio di iteratore:

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import java.util.Vector;

public class Iterator_example {

      public static void main(String[] args) {

                  List laptoplist = new ArrayList(Arrays.asList( new String[] {"Samsung", "Lenovo", "HP", "Apple"}));

            Vector vectali = new Vector(laptoplist);

            delete(vectali, "HP");

        }

        private static void delete(Vector vectali, String name) {

            Iterator a = vectali.iterator();

            while (a.hasNext()) {

              String s = (String) a.next();

              if (s.equals(name)) {

                  a.remove();

              }

            }

            // Display the names

            System.out.println("The laptop brand includes:");

            a = vectali.iterator();

            while (a.hasNext()) {

              System.out.println(a.next());

            }

      }

}

Conclusione: