Pause café #167. Choses à revoir avant un entretien Java. Quelle est la différence entre enum et itérateur en Java ?

Choses à revoir avant un entretien Java

Source : Medium Dans cet article, vous trouverez 17 conseils d'un développeur expérimenté qui vous aideront dans un entretien Java. Je travaille dans l'industrie informatique depuis plus de 20 ans et j'ai passé la plupart de ce temps à travailler avec Java. De plus, j'ai acquis une expérience considérable en interviewant des développeurs Java. Bien que le langage Java évolue constamment, les concepts de base restent largement les mêmes. Voici quelques conseils que je souhaite partager avec les futurs développeurs avant de passer un entretien. Si vous les répétez, cela vous évitera de graves erreurs.

1. La classe Object est à la racine de la hiérarchie des classes Java. Toutes les classes Java remontent à Object . Même si une classe n’étend explicitement aucune classe, elle étend Object . Cependant, une classe est libre d’étendre Object explicitement.

2. En Java, vous ne pouvez étendre qu'une seule classe (l'héritage multiple n'est pas autorisé en raison d'ambiguïté). Cependant, une classe peut implémenter n’importe quel nombre d’interfaces en même temps.

3. Une interface étend une autre interface (par opposition à une implémentation).

4. Il existe quatre modificateurs d'accès en Java : public (disponible pour tous), protégé (disponible uniquement pour les sous-classes), privé (disponible uniquement dans une seule classe), par défaut (disponible dans un seul package). Il convient de noter que les sous-classes d’une même classe peuvent se trouver dans des packages différents. La classe parent et les sous-classes ne doivent pas nécessairement faire partie du même package.

5. La chaîne de classe est immuable. L'immuabilité signifie que la classe String elle-même ne fournit aucune méthode pour remplacer la valeur dans une référence String . Si vous souhaitez remplacer la valeur d'une référence de chaîne, vous devez attribuer la valeur explicitement à l'aide de l' opérateur = . Comparez cela aux classes StringBuffer ou StringBuilder , qui ont des méthodes comme append afin que vous n'ayez pas besoin d'utiliser l' opérateur = ici .

6. ConcurrentHashMap est plus efficace que Hashtable . ConcurrentHashMap opère sur des segments de la structure de données sous-jacente, dans laquelle une opération d'écriture verrouille uniquement un segment spécifique (quel que soit le segment auquel appartient la clé). Cependant, dans Hashtable , toute la structure des données sera verrouillée.

7. ConcurrentHashMap est plus lent que HashMap car HashMap n'implémente pas la sécurité des threads. HashMap peut lancer une ConcurrentModificationException si un thread parcourt un HashMap et qu'un autre thread tente de modifier le même HashMap . ConcurrentHashMap ne lèvera pas d'exception ici.

8. Comment implémenter l’égalité de deux objets de la même classe que vous avez défini ? Réponse : Cela peut être fait en remplaçant la méthode hashcode() .

9. Quel est le résultat par défaut de la méthode toString() ? Réponse : C'est la concaténation du nom de la classe, du signe @ et de la valeur hashcode() .

10. Comment implémenter le polymorphisme en Java ? Une façon de procéder consiste à surcharger la méthode. Une autre façon consiste à remplacer la méthode.

11. Comment appeler un constructeur de superclasse à partir d’une classe enfant ? Réponse : Cela peut être fait en utilisant le mot-clé super() . La méthode super() sans arguments est toujours appelée, même si elle n'est pas explicitement spécifiée. La méthode super() avec un argument doit être spécifiée explicitement. Un appel à super() (avec ou sans argument) doit toujours être la première ligne du constructeur de la classe enfant si son appel doit être effectué.

12. Que sont les exceptions cochées et non cochées ? Réponse : Les exceptions vérifiées sont celles qui doivent être déclarées ou interceptées dans la méthode où elles sont censées être levées. Une exception non vérifiée n'a pas cette limitation. java.io.IOException est un exemple d'exception vérifiée. Les exceptions non vérifiées proviennent de la classe RunTimeException .

13. La classe racine de la hiérarchie des exceptions est Throwable (qui à son tour étend implicitement Object ). L'exception et l'erreur proviennent de Throwable .

14. Depuis Java 8, les méthodes peuvent avoir une implémentation dans une interface. Les méthodes par défaut et les méthodes statiques peuvent avoir des implémentations.

15. Une classe qualifiée d’ abstraite ne peut pas être instanciée. Toute classe qui ne fournit de corps pour aucune des méthodes doit être déclarée abstraite. Un développeur peut déclarer une classe abstraite même si toutes les méthodes ont un corps - cependant, cela n'est pas très recommandé car dans ce cas la classe ne peut pas être instanciée.

16. Le cours final ne peut pas être prolongé. Une variable finale ne peut pas se voir attribuer une autre valeur. Une méthode finale ne peut pas être remplacée.

17. Quels mots-clés sont requis dans une construction try-catch-finally ? Cela peut être try-catch , try-finally ou les trois. Dans ce cas, catch n'est pas un mot-clé obligatoire.

Quelle est la différence entre enum et itérateur en Java ?

Source : Rrtutors Cet article qui vous est présenté traite des différences entre l'énumération et l'itération en Java. Le package Java.util fournit deux interfaces pour parcourir les éléments d'un objet Collection : Enumeration et Iterator . Même s’ils passent tous les deux par un objet Collection , il existe quelques différences entre eux.

Différences entre l'énumération et l'itérateur

• Heure ajoutée au JDK : elles sont introduites à des moments différents. Enum a été introduit dans le JDK 1.0, tandis que l'itérateur a été introduit dans le JDK 1.2.

• Suppression d'éléments : c'est la principale différence entre les deux. Dans l' interface Iterator , nous pouvons supprimer un élément lors d'une itération sur un objet Collection , alors que nous ne pouvons pas le modifier lors d'une itération sur un objet Collection à l'aide d'Enumeration . En effet, l' interface Iterator a une méthode remove() , mais pas l' interface Enumeration .

• Type d'opération : l'itérateur a un type d'opération Fail-Fast et l'énumération a un type d'opération Fail-Safe. En conséquence, Iterator lève une ConcurrentModificationException lorsque la collection est modifiée pendant l'itération, à moins que sa propre méthode remove() ne soit utilisée , tandis qu'Enumeration ne lève aucune exception lorsque la collection est modifiée pendant l'itération.

Exemples d'énumération et d'itérateur en Java

Exemple d'énumération

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());

            }

      }

}

Conclusion:

Exemple d'itérateur :

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());

            }

      }

}

Conclusion: