Coffee break #167. Mga bagay na susuriin bago ang isang panayam sa Java. Ano ang pagkakaiba sa pagitan ng enum at iterator sa Java?

Mga bagay na susuriin bago ang isang panayam sa Java

Source: Medium Sa artikulong ito, makakahanap ka ng 17 tip mula sa isang karanasang developer na tutulong sa iyo sa isang panayam sa Java. Nagtrabaho ako sa industriya ng IT nang higit sa 20 taon at ginugol ko ang halos lahat ng oras na iyon sa pagtatrabaho sa Java. Bilang karagdagan, nakakuha ako ng malaking karanasan sa pakikipanayam sa mga developer ng Java. Bagama't ang wikang Java ay patuloy na umuunlad, ang mga pangunahing konsepto ay nananatiling halos pareho. Narito ang ilang tip na gusto kong ibahagi sa mga naghahangad na developer bago sila pumunta para sa isang panayam. Kung uulitin mo ang mga ito, maililigtas ka nito mula sa mga malubhang pagkakamali.

1. Ang klase ng Bagay ay nasa ugat ng hierarchy ng klase ng Java. Lahat ng mga klase ng Java ay sumusubaybay pabalik sa Object . Kahit na ang isang klase ay hindi tahasang nagpapalawak ng anumang klase, pinapalawak nito ang Object . Gayunpaman, ang isang klase ay libre na pahabain ang Object nang tahasan.

2. Sa Java, maaari mo lamang i-extend ang isang klase (hindi pinapayagan ang maramihang pamana dahil sa kalabuan). Gayunpaman, ang isang klase ay maaaring magpatupad ng anumang bilang ng mga interface sa parehong oras.

3. Ang isang interface ay nagpapalawak ng isa pang interface (kumpara sa isang pagpapatupad).

4. Mayroong apat na access modifier sa Java: pampubliko (available sa lahat), protektado (available lang sa mga subclass), pribado (available lang sa loob ng iisang klase), default (available sa loob ng iisang package). Dapat tandaan na ang mga subclass ng parehong klase ay maaaring nasa iba't ibang mga pakete. Ang parent class at mga subclass ay hindi kailangang maging bahagi ng parehong package.

5. Ang string ng klase ay hindi nababago. Ang kawalan ng pagbabago ay nangangahulugan na ang String class mismo ay hindi nagbibigay ng anumang mga pamamaraan para sa pagpapalit ng halaga sa isang String reference . Kung gusto mong palitan ang value ng isang string reference, dapat mong italaga ang value nang tahasan gamit ang = operator . Ihambing ito sa mga klase ng StringBuffer o StringBuilder , na may mga pamamaraan tulad ng append para hindi mo na kailangang gamitin ang = operator doon .

6. Ang ConcurrentHashMap ay mas mahusay kaysa sa Hashtable . Gumagana ang ConcurrentHashMap sa mga segment ng pinagbabatayan na istruktura ng data, kung saan ang isang write operation ay nagla-lock lamang ng isang partikular na segment (anuman ang segment na kinabibilangan ng key). Gayunpaman, sa Hashtable ang buong istraktura ng data ay mai-lock.

7. Ang ConcurrentHashMap ay mas mabagal kaysa sa HashMap dahil ang HashMap ay hindi nagpapatupad ng kaligtasan ng thread. Maaaring magtapon ng ConcurrentModificationException ang HashMap kung umuulit ang isang thread sa isang HashMap at sinubukan ng isa pang thread na baguhin ang parehong HashMap . Ang ConcurrentHashMap ay hindi magtapon ng exception dito.

8. Paano ipatupad ang pagkakapantay-pantay ng dalawang bagay ng parehong klase na iyong tinukoy? Sagot: Magagawa ito sa pamamagitan ng pag-override sa hashcode() method .

9. Ano ang default na resulta ng toString() na pamamaraan? Sagot: Ito ay ang pagsasama-sama ng pangalan ng klase, ang @ sign at ang hashcode() value .

10. Paano ipatupad ang polymorphism sa Java? Ang isang paraan upang gawin ito ay ang labis na karga ng pamamaraan. Ang isa pang paraan ay ang pag-override sa pamamaraan.

11. Paano mo tatawagin ang isang superclass constructor mula sa isang klase ng bata? Sagot: Magagawa ito gamit ang super() na keyword . Ang super() na pamamaraan na walang mga argumento ay palaging tinatawag, kahit na ito ay hindi tahasang tinukoy. Ang super() na pamamaraan na may argumento ay dapat na tahasang tukuyin. Ang isang tawag sa super() (mayroon o walang argumento) ay dapat palaging ang unang linya sa constructor ng klase ng bata kung kinakailangan itong tawagan.

12. Ano ang mga naka-check at hindi naka-check na mga exception? Sagot: Ang mga naka-check na exception ay ang mga dapat ideklara o mahuli sa paraang inaasahang itatapon. Ang isang hindi naka-check na exception ay walang ganitong limitasyon. Ang java.io.IOException ay isang halimbawa ng isang may check na exception. Ang mga hindi naka-check na exception ay nagmula sa RunTimeException class .

13. Ang root class ng exception hierarchy ay Throwable (na kung saan ay implicitly extend Object ). Ang Exception at Error ay nagmula sa Throwable .

14. Mula sa Java 8, ang mga pamamaraan ay maaaring magkaroon ng pagpapatupad sa isang interface. Maaaring magkaroon ng mga pagpapatupad ang mga default na pamamaraan at static na pamamaraan.

15. Ang isang klase na kwalipikado bilang abstract ay hindi maaaring i-instantiate. Ang anumang klase na hindi nagbibigay ng katawan para sa alinman sa mga pamamaraan ay dapat ideklarang abstract. Ang isang developer ay maaaring magdeklara ng isang klase na abstract kahit na ang lahat ng mga pamamaraan ay may katawan - gayunpaman, ito ay hindi masyadong inirerekomenda dahil sa kasong ito ang klase ay hindi maaaring instantiated.

16. Ang huling klase ay hindi maaaring palawigin. Ang isang panghuling variable ay hindi maaaring magtalaga ng isa pang halaga. Ang isang pangwakas na paraan ay hindi maaaring i-override.

17. Anong mga keyword ang kinakailangan sa isang try-catch-finally construct ? Maaaring ito ay try-catch , try-finally , o lahat ng tatlo. Sa kasong ito, ang catch ay hindi isang kinakailangang keyword.

Ano ang pagkakaiba sa pagitan ng enum at iterator sa Java?

Pinagmulan: Rrtutors Tinatalakay ng post na ito ang mga pagkakaiba sa pagitan ng enumeration at iteration sa Java. Ang Java.util package ay nagbibigay ng dalawang interface para sa pagtawid sa mga elemento ng isang Collection object : Enumeration at Iterator . Kahit na pareho silang dumaan sa isang Collection object , may ilang pagkakaiba sa pagitan nila.

Mga pagkakaiba sa pagitan ng enum at iterator

• Oras na idinagdag sa JDK: Ang mga ito ay ipinakilala sa iba't ibang oras. Ang Enum ay ipinakilala sa JDK 1.0, habang ang iterator ay ipinakilala sa JDK 1.2.

• Pag-alis ng mga elemento: Ito ang pangunahing pagkakaiba ng dalawa. Sa Interface ng Iterator , maaari naming alisin ang isang elemento kapag umuulit sa isang object ng Collection , samantalang hindi namin ito mababago kapag umuulit sa isang object ng Collection gamit ang Enumeration . Ito ay dahil ang Iterator interface ay may remove() na paraan, ngunit ang Enumeration interface ay wala.

• Uri ng pagpapatakbo: Ang iterator ay may uri ng pagpapatakbo na mabilis mabigo, at ang enumeration ay may hindi ligtas na uri ng pagpapatakbo. Bilang resulta, ang Iterator ay naghagis ng ConcurrentModificationException kapag ang koleksyon ay binago sa panahon ng pag-ulit maliban kung ang sarili nitong remove() na pamamaraan ay ginagamit , habang ang Enumeration ay hindi nagtatapon ng anumang exception kapag ang koleksyon ay binago sa panahon ng pag-ulit.

Mga Halimbawa ng Enumeration at Iterator sa Java

Halimbawa ng enumerasyon

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

            }

      }

}

Konklusyon:

Halimbawa ng iterator:

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

            }

      }

}

Konklusyon: