Pagsusuri ng mga tanong at sagot mula sa mga panayam para sa developer ng Java. Bahagi 16

Kumusta Kaibigan! Gaano katagal bago maging developer? Nagtanong ako sa maraming iba't ibang tao at narinig ko ang maraming iba't ibang mga sagot. Para sa ilang mga tao kahit isang buwan ay maaaring sapat, ngunit para sa iba kahit isang taon ay hindi sapat. Ngunit alam kong sigurado na ang pagiging isang developer ng Java ay isang mahirap at mahabang landas, anuman ang iyong mga paunang kakayahan. Kung tutuusin, hindi gaanong kakayahan ang mahalaga kundi ang katigasan ng ulo at pagsusumikap. Samakatuwid, ngayon ay patuloy naming sinasadyang suriin ang pinakasikat na mga tanong sa panayam para sa developer ng Java. Ang pag-aaral sa mga ito ay unti-unting maglalapit sa iyong mithiin. Magsimula na tayo!

17. Magbigay ng mga halimbawa ng matagumpay at hindi matagumpay na paggamit ng Opsyonal

Ipagpalagay na mayroon kaming isang tiyak na serye ng mga halaga kung saan dumadaan kami sa stream, at sa huli ay nakakuha kami ng ilang Opsyonal bilang isang resulta:

Optional<String> stringOptional = Stream.of("a", "ab", "abc", "abcd")
   .filter(str -> str.length() >= 3)
   .findAny();

Kami, tulad ng inaasahan, ay kailangang makuha ang halaga mula sa Opsyonal na ito . Ang paggamit lamang ng get() ay isang masamang paraan:

String result = stringOptional.get();

Ngunit ang pamamaraang ito ay dapat na makuha ang halaga mula sa Opsyonal at ibalik ito sa amin? Ito ay, siyempre, totoo, ngunit kung ito ay may kahulugan. Buweno, kung ang mga halaga sa stream ay iba, at sa huli ay nakatanggap kami ng isang walang laman na Opsyonal , kapag sinubukan naming kumuha ng halaga mula dito gamit ang get() na paraan, ang mga sumusunod ay itatapon: Alin ang hindi maganda. Sa kasong ito, mas mahusay na gamitin ang mga sumusunod na konstruksyon:

1. String result = null;
   if (stringOptional.isPresent()) {
    stringOptional.get();
   }

   Sa kasong ito, sinusuri namin kung ang elemento ay nasa Opsyonal . Kung hindi, ang resultang string ay may lumang halaga nito.

2. String result = stringOptional.orElse("default value");

   Sa kasong ito, tinukoy namin ang ilang default na halaga, na ibibigay sa magreresultang string sa kaso ng isang walang laman na Opsyonal .

3. String result = stringOptional.orElseThrow(() -> new CustomException());

   Sa kasong ito, kami mismo ang nagtatapon ng exception kapag Opsyonal ay walang laman .

Maaari itong maging maginhawa sa isang application kapag, halimbawa, ginamit ang Spring JPA method - findById() , na nagbabalik ng mga Opsyonal na halaga. Sa kasong ito, sa pamamaraang ito sinusubukan naming kunin ang halaga, at kung wala ito, itinapon namin ang ilang Runtime exception, na pinoproseso sa antas ng controller gamit ang ExceptionHandler at na-convert sa isang HTTP na tugon na may status na 404 - NOT FOUND .

18. Posible bang ideklara ang pangunahing pamamaraan bilang pinal?

Oo, siyempre, walang pumipigil sa amin na ideklara ang main() na pamamaraan bilang final . Hindi gagawa ng mga error ang compiler. Ngunit ito ay nagkakahalaga ng pag-alala na ang anumang paraan pagkatapos ideklara ito bilang pangwakas ay magiging huling paraan - hindi na-override. Bagaman, sino ang muling tukuyin ang pangunahing ???

19. Posible bang mag-import ng parehong pakete/klase nang dalawang beses? Ano ang maaaring maging kahihinatnan?

Oo kaya mo. Mga kahihinatnan? Magkakaroon kami ng ilang hindi kinakailangang pag-import na ipapakita ng Intelijj IDEA bilang gray, i.e. hindi nagamit.

20. Ano ang Casting? Kailan tayo makakakuha ng ClassCastException?

Ang pag-cast, o uri ng pag-cast , ay ang proseso ng pag-convert ng isang uri ng data sa isa pang uri ng data: manu-mano (implicit na pag-cast) o awtomatiko (tahasang uri ng pag-cast). Ang awtomatikong conversion ay ginagawa ng compiler, at ang manu-manong conversion ay ginagawa ng developer. Ang uri ng paghahagis para sa mga primitive at mga klase ay medyo naiiba, kaya isasaalang-alang namin ang mga ito nang hiwalay. Mga primitive na uri Isang halimbawa ng awtomatikong pag-cast ng mga primitive na uri:

int value = 17;
double convertedValue = value;

Gaya ng nakikita mo, walang karagdagang manipulasyon maliban sa = sign ang kailangan dito. Halimbawa ng manu-manong pag-cast ng mga primitive na uri:

double value = 17.89;
int convertedValue = (int)value;

Sa kasong ito, maaari naming obserbahan ang isang manu-manong cast, na ipinapatupad gamit ang (int) , kung saan ang bahagi pagkatapos ng kuwit ay itatapon at ang convertedValue ay magkakaroon ng halaga na - 17. Magbasa nang higit pa tungkol sa pag-cast ng mga primitive na uri sa artikulong ito . Well, ngayon ay lumipat tayo sa mga bagay. Mga uri ng sanggunian Para sa mga uri ng sanggunian, ang awtomatikong pag-cast ay posible para sa mga descendant na klase sa mga parent na klase. Tinatawag din itong polymorphism . Sabihin nating mayroon tayong klase ng Lion na nagmana mula sa klase ng Cat . Sa kasong ito, ang awtomatikong conversion ay magiging ganito:

Cat cat = new Lion();

Ngunit sa isang tahasang cast , ang lahat ay medyo mas kumplikado, dahil walang functionality para sa pagputol ng labis, tulad ng sa mga primitive. At gumagawa lang ng tahasang conversion ng form:

Lion lion= (Lion)new Cat();

Makakakuha ka ng isang error: Sa katunayan, maaari kang magdagdag ng mga pamamaraan sa klase ng descendant ng Lion na hindi orihinal sa klase ng Cat , at pagkatapos ay subukang tawagan ang mga ito, dahil ang uri ng iyong bagay ay magiging Lion . Well, walang logic dito. Samakatuwid, ang uri ng pagpapaliit ay posible lamang kapag ang orihinal na bagay ay nasa uri ng Lion ngunit kalaunan ay na-cast sa isang parent na klase:

Lion lion = new Lion();
Cat cat = lion;
Lion newLion = (Lion)cat;

Gayundin, para sa higit na pagiging maaasahan, ang isang narrowing cast para sa mga bagay ay inirerekomenda gamit ang instanceOf construct :

if (cat instanceof Lion) {
 newLion = (Lion)new Cat();
}

Magbasa nang higit pa tungkol sa mga uri ng reference na cast sa artikulong ito .

21. Bakit ang mga modernong balangkas ay pangunahing gumagamit lamang ng mga hindi naka-check na eksepsiyon?

Sa tingin ko, ito lang dahil ang paghawak ng mga naka-check na exception ay spaghetti code pa rin na paulit-ulit kahit saan, ngunit hindi talaga kailangan sa lahat ng pagkakataon. Sa ganitong mga kaso, mas madaling gawin ang pagproseso sa loob ng balangkas, upang hindi na muling ilipat ito sa mga balikat ng mga developer. Oo, siyempre, ang isang sitwasyong pang-emerhensiya ay maaaring lumitaw, ngunit ang parehong hindi na-check na mga eksepsiyon ay maaaring pangasiwaan sa isang mas maginhawang paraan, nang hindi naaabala sa pagpoproseso sa try-catch at nang hindi ipinapasa ang mga ito sa mga pamamaraan. Sapat lamang na i-convert ang exception sa ilang HTTP na tugon sa exceptionHandler .

22. Ano ang static na pag-import?

Kapag gumagamit ng static na data (paraan, mga variable), hindi ka maaaring lumikha ng bagay mismo, ngunit gawin ito sa pamamagitan ng pangalan ng klase, ngunit kahit na sa kasong ito kailangan namin ng isang sanggunian sa klase. Ang lahat ay simple dito: idinagdag ito gamit ang regular na pag-import. Ngunit paano kung gagamitin natin ang isang static na pamamaraan nang hindi isinusulat ang pangalan ng klase, na para bang ito ay isang static na pamamaraan ng kasalukuyang klase? Posible ito sa static na pag-import! Sa kasong ito, dapat tayong magsulat ng static na pag-import at isang link sa paraang iyon. Tulad nito, halimbawa, isang static na paraan ng klase ng Math para sa pagkalkula ng cosine value:

import static java.lang.Math.cos;

Bilang resulta, maaari nating gamitin ang pamamaraan nang hindi tinukoy ang pangalan ng klase:

double result = cos(60);

Maaari rin nating i-load ang lahat ng mga static na pamamaraan ng isang klase nang sabay-sabay gamit ang static na pag-import:

import static java.lang.Math.*;

23. Ano ang kaugnayan sa pagitan ng hashCode() at equals() na mga pamamaraan?

Ayon sa Oracle , ang panuntunan ay: Kung ang dalawang bagay ay pantay (i.e. ang equals() na pamamaraan ay nagbabalik ng true ), dapat silang magkaroon ng parehong hash code. Kasabay nito, huwag kalimutan na ang dalawang magkaibang bagay ay maaaring magkaroon ng parehong hash code. Upang maunawaan kung bakit ang equals() at hashCode() ay palaging pinapares sa mga pares, isaalang-alang ang mga sumusunod na kaso:

1. Ang parehong mga pamamaraan ay na-override.

   Sa kasong ito, dalawang magkaibang bagay na may parehong panloob na estado ang magbabalik equals() - true , habang ang hashCode() ay parehong magbabalik ng parehong numero.

   Okay na pala ang lahat, dahil sinusunod ang panuntunan.

2. Ang parehong mga pamamaraan ay hindi na-override.

   Sa kasong ito, dalawang magkaibang bagay na may parehong panloob na estado ay magbabalik ng false kapag equals() , dahil ang paghahambing ay sa pamamagitan ng sanggunian sa pamamagitan ng == operator .

   Ang pamamaraan ng hashCode() ay magbabalik din ng iba't ibang mga halaga (malamang) dahil ito ay gumagawa ng na-convert na halaga ng address ng lokasyon ng memorya. Ngunit para sa parehong bagay ang halagang ito ay magiging pareho, tulad ng equals() sa kasong ito ay babalik lamang ng totoo kapag ang mga sanggunian ay tumuturo sa parehong bagay.

   Ito ay lumiliko na sa kasong ito ang lahat ay ok at ang panuntunan ay natupad.

3. Overridden equals() , hindi overridden hashCode() .

   Sa kasong ito, para sa dalawang magkaibang bagay na may parehong panloob na estado, equals() ay magbabalik true , at hashCode() ay magbabalik (malamang) magkaibang mga halaga.

   Ito ay isang paglabag sa panuntunan, kaya hindi inirerekomenda na gawin ito.

4. equals() is not overridden , hashCode() is overridden .

   Sa kasong ito, para sa dalawang magkaibang object na may parehong panloob na estado, equals() ay magbabalik ng false at hashCode() ay magbabalik ng parehong mga halaga.

   May paglabag sa panuntunan, kaya mali ang diskarte.

Tulad ng nakikita mo, ang panuntunan ay maaari lamang isagawa kapag ang equals() at hashCode() ay parehong na-override o pareho ay hindi na-override. Magbasa nang higit pa tungkol sa equals() at hashCode() sa artikulong ito .

24. Kailan ginagamit ang mga klase ng BufferedInputStream at BufferedOutputStream?

Ginagamit ang InputStream upang basahin ang data byte-by-byte mula sa ilang mapagkukunan, at ang OutputStream ay ginagamit upang magsulat ng data byte-by-byte. Ngunit ang mga pagpapatakbo ng byte-byte ay maaaring maging lubhang abala at nangangailangan ng karagdagang pagpoproseso (upang makapagbasa/magsulat ng mga teksto nang normal). Sa totoo lang, upang gawing simple ang mga naturang byte record, ipinakilala ang BufferedOutputStream , at ipinakilala ang BufferedInputStream para sa pagbabasa . Ang mga klase na ito ay hindi hihigit sa mga buffer na nag-iipon ng data, na nagbibigay-daan sa iyong magtrabaho sa data hindi byte sa pamamagitan ng byte, ngunit sa pamamagitan ng buong data packet (mga array). Kapag ginawa, kinuha ng BufferedInputStream ang constructor nito ng isang instance ng uri ng InputStream , kung saan binabasa ang data:

BufferedInputStream bufferedInputStream = new BufferedInputStream(System.in);
byte[] arr = new byte[100];
bufferedInputStream.read(arr);

Ang System.in ay isang InputStream object na nagbabasa ng data mula sa console. Ibig sabihin, gamit itong BufferedInputStream object , mababasa natin ang data mula sa InputStream sa pamamagitan ng pagsusulat nito sa naipasa na array. Ito ay lumalabas na isang uri ng wrapper ng klase ng InputStream . Ang arr array mula sa halimbawang ito ay ang array na tumatanggap ng data mula sa BufferedInputStream . Iyon naman, nagbabasa ng data mula sa InputStream na may isa pang array, na bilang default ay may sukat na 2048 bytes. Ang parehong ay totoo para sa BufferedOutputStream : isang halimbawa ng uri ng OutputStream ay dapat ipasa sa constructor , kung saan kami ay magsusulat ng data sa buong array:

byte[] arr = "Hello world!!!".getBytes();
BufferedOutputStream bufferedInputStream = new BufferedOutputStream(System.out);
bufferedInputStream.write(arr);
bufferedInputStream.flush();

Ang System.out ay isang OutputStream object na nagsusulat ng data sa console. Ang flush() method ay nagpapadala ng data mula sa BufferedOutputStream papunta sa OutputStream , na nag-flush sa BufferedOutputStream sa proseso . Kung wala ang pamamaraang ito, walang maitatala. At katulad ng nakaraang halimbawa: ang arr ay ang array kung saan isinulat ang data sa BufferedOutputStream . Mula doon ay isinusulat ang mga ito sa OutputStream sa ibang array, na bilang default ay may sukat na 512 bytes. Magbasa nang higit pa tungkol sa dalawang klase na ito sa artikulo .

25. Ano ang pagkakaiba sa pagitan ng mga klase ng java.util.Collection at java.util.Collections?

Ang koleksyon ay isang interface na pinuno ng hierarchy ng koleksyon. Ipinakilala nito ang mga klase na nagbibigay-daan sa iyong lumikha, maglaman, at magbago ng buong grupo ng mga bagay. Mayroong maraming mga pamamaraan na ibinigay para dito, tulad ng add() , remove() , contains() at iba pa. Mga pangunahing interface ng klase ng Koleksyon :

• Ang set ay isang interface na naglalarawan sa isang set na naglalaman ng hindi nakaayos na natatanging (hindi umuulit) na mga elemento.

• Ang listahan ay isang interface na naglalarawan ng istraktura ng data na nag-iimbak ng isang nakaayos na pagkakasunud-sunod ng mga bagay. Ang mga bagay na ito ay tumatanggap ng kanilang sariling index (numero), kung saan maaari kang makipag-ugnayan sa kanila: kunin, tanggalin, baguhin, i-overwrite.

• Ang Queue ay isang interface na naglalarawan ng istraktura ng data na may mga elemento ng pag-iimbak sa anyo ng isang queue na sumusunod sa panuntunan - FIFO - First In First Out .

Magbasa pa tungkol sa Collection . Ang Collections ay isang utility class na nagbibigay ng maraming iba't ibang paraan ng utility. Halimbawa:

• addAll(Collection<? super T> collection, T...element) - idinaragdag ang mga naipasa na elemento ng uri T sa koleksyon .

• copy(List<? super T> dest, List<? extends T> src) - kinokopya ang lahat ng elemento mula sa list src papunta sa listahan sa dest .

• emptyList() - nagbabalik ng walang laman na listahan.

• max(Collection<? extends T> collection, Comparator<? super T> comp) - Ibinabalik ang maximum na elemento ng isang ibinigay na koleksyon ayon sa pagkakasunud-sunod na tinukoy ng tinukoy na comparator.

• unmodifiableList(List<? extends T> list) - nagbabalik ng hindi nababagong representasyon ng naipasa na listahan.

At mayroong napakaraming iba't ibang maginhawang pamamaraan sa Mga Koleksyon . Ang kumpletong listahan ng mga pamamaraang ito ay matatagpuan sa website ng Oracle . It's not for nothing na sinabi kong komportable sila. Pagkatapos ng lahat, lahat sila ay static. Iyon ay, hindi mo kailangang lumikha ng isang bagay ng klase na ito sa bawat oras upang tawagan ang kinakailangang pamamaraan dito. Kailangan mo lamang ipasok ang pangalan ng klase, tawagan ang nais na pamamaraan dito at ipasa ang lahat ng kinakailangang argumento. Upang ibuod, ang Collection ay ang root interface ng framework ng mga koleksyon. Ang Collections ay isang helper class para sa mas maginhawang pagproseso ng mga bagay na kabilang sa isang uri mula sa istruktura ng mga koleksyon. Well, iyon lang para sa araw na ito. Lahat ng pinakamahusay!