Coffee break #151. Pagpapatupad ng isang Queue sa Java. 10 Kailangang May Mga Tanong para sa Anumang Pakikipanayam sa Trabaho para sa Posisyon ng Developer sa Backend ng Java

10 Kailangang May Mga Tanong para sa Anumang Pakikipanayam sa Trabaho para sa Posisyon ng Developer sa Backend ng Java

Source: Medium Ibinahagi ng may-akda ng artikulo ang kanyang personal na karanasan sa pagpasa ng ilang panayam para sa posisyon ng Java Backend Developer. Ang mga panayam ay kadalasang mahirap. Samakatuwid, magandang ideya na malaman ang mga tanong bago kumuha ng panayam. Dahil dumaan ako sa ilang mga panayam sa nakalipas na dalawang buwan, maaari ko na ngayong ibahagi sa iyo ang ilan sa mga tanong na pinakamadalas kong nakatagpo. Nag-apply ako para sa isang posisyon bilang backend Java developer na may 1-3 taong karanasan.

1. Java at mga tampok nito

Karaniwang magtatanong ang tagapanayam tungkol sa pinakabagong bersyon ng Java na iyong ginagamit at mga tampok nito. Madalas akong gumamit ng Java 8 at tinanong ako tungkol sa mga stream ng API, mga expression ng lambda, functional interface at iba pa. Karaniwang nagtatanong ang tagapanayam tungkol sa mga feature at application na ito batay sa mga ito.

2. Panloob na pagtatrabaho ng HashMap

Karamihan sa mga panayam na dinaluhan ko ay may ganitong tanong. Pagkatapos ipaliwanag kung paano ito gumagana, ang ilan ay nagtanong tungkol sa default na laki ng HashMap, ang iba ay nagtanong ng higit pa tungkol sa mga koleksyon ng Java.

3. Mga error at exception

Ang pagkakaiba sa pagitan ng Error at Exception ay isang pangkaraniwang tanong na itinatanong sa mga panayam. Tinanong din kung ano ang mga naka-check at hindi naka-check na mga exception.

4. Multithreading

Ang multithreading ay isang napakahalagang konsepto para sa mga panayam, kadalasang nagtatanong tungkol sa Thread, Runnable na mga klase, mga pagkakaiba sa pagitan ng mga ito at mga kaso ng paggamit ng pareho. Pinapayuhan din kita na pag-aralan ang balangkas ng Tagapagpatupad.

5. Strings at immutability

Karamihan sa mga tagapanayam ay nagtanong tungkol sa immutability sa string class, at kung minsan ay nagtatanong tungkol sa string builder at string buffer (kung sinabi mong ang mga ito ay nababago na mga alternatibong string). Minsan nagtanong sila kung paano lumikha ng isang hindi nababagong klase.

6. Pagkolekta ng basura

Ang pangongolekta ng basura sa Java ay isang napakahalagang paksa upang maghanda para sa mga panayam. Minsan tinatanong ang mga tanong tungkol sa lifecycle ng koleksyon ng basura at ang iba't ibang paraan ng pangongolekta ng basura.

7. Comparator at Comparable sa Java

Ang mga karaniwang itinatanong ay kung kailan gagamitin ang Comparator at Comparable sa Java at ano ang pagkakaiba ng mga ito.

8. Mga Pattern ng Disenyo ng Java

Pagdating sa mga pattern ng disenyo ng Java, karaniwang nagsisimula ang mga tanong sa iba't ibang pattern na ginagamit sa kasalukuyang proyekto. Minsan ay nagtatanong kung kailan gagamitin ang bawat isa sa kanila. Nagtanong din tungkol sa paglikha ng isang hindi nababagong klase sa Java.

9. Pangwakas, Panghuli at Pagtatapos

Ang pagkakaiba sa pagitan ng mga keyword na pangwakas, sa wakas at tinatapos ay isang napakakaraniwang tanong na itinatanong sa mga panayam. Bilang karagdagang tanong, nagtatanong sila tungkol sa mga opsyon para sa paggamit ng bawat keyword.

10. Serialization at Deserialization sa Java

Ang serialization at deserialization ay isang napakahalagang paksa upang maghanda para sa mga panayam. Karaniwang tinatanong tungkol sa mga kaso ng paggamit, kung minsan ay tinatanong tungkol sa hibernation at JPA. Sana, kung ikaw ay nahaharap sa isang panayam para sa isang Java Server Side Developer na posisyon sa lalong madaling panahon, ang paghahanda ng mga tanong na binanggit dito ay makakatulong sa iyo.

Pagpapatupad ng Queue sa Java

Pinagmulan: Faun.pub Salamat sa publikasyong ito, matututunan mo kung paano magpatupad ng Queue sa Java.

Ano ang isang pila?

Ang Queue ay isang linear na istraktura ng data sa anyo ng isang pagkakasunud-sunod ng pag-access sa mga elemento ayon sa prinsipyong "first in, first out". Nangangahulugan ito na ang elemento na unang ipinasok ay aalisin muna. Iyon ay, ang mga elemento ay tinanggal sa pagkakasunud-sunod kung saan sila ipinasok. Ang pila ay binubuo ng dalawang bahagi: Harap (harap, kung saan ang mga elemento ay tinanggal) at Likod (likod, kung saan ang mga elemento ay ipinasok). Mga Karaniwang Operasyon ng Queue: Ang mga sumusunod na operasyon ay karaniwang ginagamit sa isang queue:

• Enqueue - Nagdaragdag ng elemento mula sa dulo ng pila.
• Dequeue - Tinatanggal ang isang elemento mula sa ulo ng pila.
• Front/Peek - ibinabalik ang halaga ng elemento sa harap ng queue, nang hindi ibinubukod (tinatanggal) ang elemento mula sa queue.
• IsEmpty - sinusuri kung walang laman ang pila.
• IsFull - sinusuri kung puno na ang pila.
• Display - Ini-print ang lahat ng mga item sa queue.

Pagpapatupad ng 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]);
  }
}

Paliwanag:

• Una naming ginawa ang aming mga variable at ang kanilang mga parameter. Ginagamit namin ang 3 bilang ang maximum na bilang ng mga elemento na maaaring i-queue sa array. Itinakda namin ang paunang index ng harap (Front) at likod (Back) sa -1.

• Susunod ay tutukuyin natin ang functionality ng isEmpty at isFull .

• Ang isEmpty() method ay medyo simple, para sa isFull() method ang aming maximum na bilang ng mga elementong pinapayagan sa isang array ay 3, ngunit tatlong elemento sa array ay hindi tinutukoy ng index 3 ngunit ng 2 dahil ang unang index ay 0. Kaya ang maximum na haba ay minus 1 ay nagbibigay sa amin ng index 2, na siyang ikatlong cell sa array. Kapag ang lahat ng mga cell ay nakapila na may halaga hanggang sa ikatlong cell, ang array ay puno na.

• enQueue - kung puno na ang array, nakakakuha kami ng mensahe na puno na ito. Kung ang mga bahagi sa Harap at Likod ay -1, kung gayon ang elemento ay itinalaga sa unang cell sa index 0 - kung hindi, ang halaga ay ipinasok at ang likod na posisyon ay dagdagan.

• deQueue - kung ang array ay walang laman, natatanggap namin ang kaukulang mensahe. Kung ang Front na bahagi ay nakakatugon sa Likod na bahagi, pagkatapos ay i-reset namin ang kanilang index pabalik sa -1. Kung ang huling dalawang kundisyon ay hindi nalalapat, ang Harap ay nadagdagan.

• display - kung ang array ay walang laman, inuulit namin at i-print ang lahat ng mga elemento.

• peak - Ito ay nagpi-print lamang ng halaga ng nangungunang elemento.