Pause café #151. Implémentation d'une file d'attente en Java. 10 questions incontournables pour tout entretien d'embauche pour un poste de développeur backend Java

10 questions incontournables pour tout entretien d'embauche pour un poste de développeur backend Java

Source : Medium L'auteur de l'article partage son expérience personnelle en passant plusieurs entretiens pour le poste de développeur Java Backend. Les entretiens sont souvent difficiles. Il serait donc judicieux de connaître les questions avant de passer l’entretien. Après avoir participé à de nombreux entretiens au cours des derniers mois, je peux désormais partager avec vous certaines des questions que j'ai rencontrées le plus souvent. J'ai postulé pour un poste de développeur Java backend avec 1 à 3 ans d'expérience.

1. Java et ses fonctionnalités

L'intervieweur vous posera généralement des questions sur la dernière version de Java que vous utilisez et ses fonctionnalités. J'ai principalement utilisé Java 8 et on m'a posé des questions sur les flux API, les expressions lambda, l'interface fonctionnelle, etc. L'intervieweur a généralement posé des questions sur ces fonctionnalités et les applications basées sur celles-ci.

2. Fonctionnement interne de HashMap

La plupart des entretiens auxquels j'ai assisté portaient cette question. Après avoir expliqué comment cela fonctionne, certains ont posé des questions sur la taille par défaut du HashMap, d'autres ont demandé davantage sur les collections Java.

3. Erreurs et exceptions

La différence entre erreur et exception est une question très fréquemment posée lors des entretiens. J'ai également demandé quelles sont les exceptions cochées et non cochées.

4. Multithreading

Le multithreading est un concept très important pour les entretiens, des questions sont généralement posées sur les classes Thread, Runnable, les différences entre elles et les cas d'utilisation des deux. Je vous conseille également d’étudier le framework Executor.

5. Chaînes et immuabilité

La plupart des enquêteurs ont posé des questions sur l'immuabilité de la classe de chaînes, puis parfois sur le générateur de chaînes et le tampon de chaînes (si vous avez dit qu'il s'agissait de chaînes alternatives mutables). Parfois, ils demandaient comment créer une classe immuable.

6. Collecte des déchets

Le garbage collection en Java est un sujet très important pour préparer les entretiens. Des questions sont parfois posées sur le cycle de vie du garbage collection et les différentes méthodes de garbage collection.

7. Comparateur et comparable en Java

Les questions fréquemment posées sont de savoir quand utiliser Comparator et Comparable en Java et quelle est la différence entre eux.

8. Modèles de conception Java

Lorsqu'il s'agit de modèles de conception Java, les questions commencent généralement par les différents modèles utilisés dans le projet en cours. Parfois, des questions sont posées sur le moment où utiliser chacun d’eux. A également posé des questions sur la création d'une classe immuable en Java.

9. Final, Enfin et Finaliser

La différence entre les mots-clés final, enfin et finaliser est une question très fréquemment posée lors des entretiens. Comme question supplémentaire, ils posent des questions sur les options d'utilisation de chaque mot-clé.

10. Sérialisation et désérialisation en Java

La sérialisation et la désérialisation sont un sujet très important pour préparer les entretiens. Généralement interrogé sur les cas d'utilisation, parfois interrogé sur l'hibernation et JPA. Espérons que si vous êtes bientôt confronté à un entretien pour un poste de développeur côté serveur Java, préparer les questions mentionnées ici vous aidera.

Implémentation d'une file d'attente en Java

Source : Faun.pub Grâce à cette publication, vous apprendrez comment implémenter une Queue en Java.

Qu'est-ce qu'une file d'attente ?

Une Queue est une structure de données linéaire sous la forme d'une séquence d'accès aux éléments selon le principe du « premier entré, premier sorti ». Cela signifie que l'élément inséré en premier sera supprimé en premier. Autrement dit, les éléments sont supprimés dans l’ordre dans lequel ils ont été insérés. La file d'attente se compose de deux parties : Front (avant, où les éléments sont supprimés) et Back (arrière, où les éléments sont insérés). Opérations courantes de file d'attente : les opérations suivantes sont couramment utilisées dans une file d'attente :

• Enqueue - Ajoute un élément à la fin de la file d'attente.
• Dequeue - Supprime un élément de la tête de la file d'attente.
• Front/Peek - renvoie la valeur de l'élément devant la file d'attente, sans exclure (supprimer) l'élément de la file d'attente.
• IsEmpty - vérifie si la file d'attente est vide.
• IsFull - vérifie si la file d'attente est pleine.
• Afficher - Imprime tous les éléments de la file d'attente.

Implémentation du code :

public class Example {
public static void main(String[] args) {
    Queue myQueue = new Queue();
    myQueue.enQueue(3);
    myQueue.enQueue(2);
    myQueue.enQueue(1);
    myQueue.display();
    myQueue.deQueue();
    myQueue.peak();
}
}
class Queue {
  int queueLength = 3;
  int items[] = new int[queueLength];
  int front = -1;
  int back = -1;
  boolean isFull(){
      if(back == queueLength - 1){
          return true;
      } else {
          return false;
      }
  }
  boolean isEmpty(){
      if(front == -1 && back == -1){
          return true;
      } else {
          return false;
      }
  }
   void enQueue(int itemValue) {
      if(isFull()){
          System.out.println("Queue is full");
      } else if(front == -1 && back == -1){
          front = back = 0;
          items[back] = itemValue;
      } else{
          back++;
          items[back] = itemValue;
      }
  }
   void deQueue(){
      if(isEmpty()){
          System.out.println("Queue is empty. Nothing to dequeue");
      } else if (front == back){
          front = back = -1;
      } else {
          front++;
      }
  }
  void display(){
      int i;
      if(isEmpty()){
          System.out.println("Queue is empty");
      } else {
          for(i = front; i <= back; i++){
              System.out.println(items[i]);
          }
      }
  }
  void peak(){
      System.out.println("Front value is: " + items[front]);
  }
}

Explication:

• Nous avons d’abord créé nos variables et leurs paramètres. Nous utilisons 3 comme nombre maximum d'éléments pouvant être mis en file d'attente dans le tableau. Nous fixons l'index initial du recto (Front) et du verso (Back) à -1.

• Nous définirons ensuite les fonctionnalités de isEmpty et isFull .

• La méthode isEmpty() est assez simple, pour la méthode isFull() notre nombre maximum d'éléments autorisés dans un tableau est de 3, mais trois éléments du tableau ne sont pas notés par l'index 3 mais par 2 puisque le premier index est 0. Donc la longueur maximale est de moins 1 nous donne l'index 2, qui est la troisième cellule du tableau. Lorsque toutes les cellules sont mises en file d'attente avec une valeur allant jusqu'à la troisième cellule, le tableau est plein.

• enQueue - si le tableau est plein, nous recevons un message indiquant qu'il est plein. Si les parties Front et Back sont -1, alors l'élément est affecté à la première cellule à l'index 0 - sinon la valeur est insérée et la position arrière est incrémentée.

• deQueue - si le tableau est vide, nous recevons le message correspondant. Si la partie Front rencontre la partie Back, alors nous réinitialisons leur index à -1. Si les deux dernières conditions ne s’appliquent pas, alors Front est augmenté.

• display - si le tableau n'est pas vide, nous itérons et imprimons tous les éléments.

• Peak - Ceci imprime simplement la valeur de l'élément principal.