Coffee break #163. Ano ang pagkakaiba sa pagitan ng isang lambda at isang sanggunian ng pamamaraan. 5 Paraan para Pagsamahin ang String Null sa Java

Ano ang pagkakaiba sa pagitan ng isang lambda at isang sanggunian ng pamamaraan

Pinagmulan: Iminumungkahi ng Reddit IntelliJ IDEA na palitan ang mga expression ng lambda ng mga sanggunian ng pamamaraan. Ano ang pagkakaiba sa pagitan nila? Lumalabas na mayroong banayad na pagkakaiba sa pagitan ng mga expression ng lambda at mga sanggunian sa pamamaraan. Halimbawa, ihambing ang: myInstance::getStuff at () ->myInstance.getStuff() . Sa pangkalahatan, ang parehong mga pagpipilian ay katumbas ng bawat isa. Ngunit kung ang myInstance ay null, at ang lambda ay gumagawa ng isang null pointer kapag sinusuri ang lambda, pagkatapos ay isang sanggunian ng pamamaraan ay bubuo kaagad kapag sinusubukang i-access ang sanggunian. At ano? Sa pangkalahatan, mahalaga ito kung ang code na sinusuri ang lambda expression ay nasa loob ng try-catch na may null pointer. Halimbawa, mayroon akong function mightBeNull(Supplier<T> function) na gumagawa ng ganito:

try {
    doStuff(function.get().getSomeMore().getSomeMore());
} catch (NullPointerException e) {
    doOtherStuff();
}

Kung ang pagtawag sa mightBeNull(() -> myNullVariable.getStuff()) ay gagana nang walang pagbubukod, kung gayon ang "katumbas": mightBeNull(myNullVariable::getStuff) ay magtapon kaagad ng NullPointerException kapag tinawag ang function. Iyon ang pagkakaiba. Tandaan. Ayon sa Stackoverflow, kung papalitan mo ang lambda ng isang sanggunian ng pamamaraan, ang class bytecode ay magiging mas compact, na nangangahulugan na ang klase ay maglo-load nang mas mabilis sa JVM. Gayunpaman, upang maranasan ang ganoong pakinabang, libu-libong hindi na-optimize na lambda ang kailangan. Gayunpaman, sa isang malaking proyekto tulad ng isang numero ay madaling maipon. Kung hindi, ang pagpili sa pagitan ng isang lambda at isang sanggunian ng pamamaraan ay isang bagay sa panlasa at pagiging madaling mabasa ng code. Halimbawa, kung may ilang linya ang isang lambda, mababawasan ang pagiging madaling mabasa, at makikinabang lang ang code kung ilalagay ang lambda sa isang hiwalay na paraan at gumamit ng reference dito.

5 Paraan para Pagsamahin ang String Null sa Java

Pinagmulan: Gitconnected Pagkatapos basahin ang post na ito, matututo ka ng higit pang mga paraan upang gumana sa mga string sa Java. Nagbibigay ang Java ng maraming paraan para pagdugtungin ang mga string, ngunit minsan kapag hindi natin binibigyang pansin ang mga null na string, maaari tayong magkaroon ng null, na malinaw naman na hindi natin gusto. Kaya gamitin ang aking mga inirekumendang pamamaraan upang maiwasan ang mga null na halaga kapag pinagsama ang String.

Pagsusuri ng Suliranin

Kung gusto nating pagdugtungin ang mga string array, maaari lang nating gamitin ang + operator. Gayunpaman, maaari kaming makatagpo ng mga null na halaga kapag ginagawa ito .

String[] values = {"https", "://", "gist.", "github", ".com", null};
String result = "";

for (String value : values) {
    result = result + value;
}

Ang pagsasama-sama ng lahat ng mga elementong ito ay humahantong sa amin sa resultang ito: Bagama't nakita namin ang problema, ang resultang null value ay pinagsama-sama rin bilang isang string, na malinaw na hindi ang inaasahan namin. At kahit na nagtatrabaho kami sa Java 8 o mas mataas, gamit ang static na String.join() na paraan upang sumali sa mga string, mapupunta pa rin kami sa mga null na halaga .

String[] values = {"https", "://", "gist.", "github", ".com", null};
String result = String.join("", values);

Ang resulta ay pareho: Kaya paano malutas ang problemang ito? Mayroong ilang mga solusyon. Upang gawing mas madali ang pagpapakita ng code sa ibang pagkakataon, kinukuha namin ang isang paraan na maaaring magpasa ng string at magbalik ng hindi null na string.

public String nullToString(String value) {
    return value == null ? "" : value;
}

1. String.concat()

Ang String.concat() ay isang paraan na kasama ng String class . Ito ay napaka-maginhawa para sa string concatenation.

for (String value : values) {
    result = result.concat(getNonNullString(value));
}

Dahil ang nullToString() na pamamaraan ay tinatawag, walang mga null na halaga bilang isang resulta .

2.StringBuilder

Ang StringBuilder class ay nagbibigay ng maraming kapaki-pakinabang at maginhawang pamamaraan para sa pagbuo ng mga string. Ang pinakakaraniwang ginagamit sa mga ito ay ang append() method , na gumagamit ng append() upang pagdugtungin ang mga string at pinagsama sa nullToString() na paraan upang maiwasan ang mga null na halaga.

String[] values = {"https", "://", "gist.", "github", ".com", null};
StringBuilder result = new StringBuilder();

for (String value : values) {
    result = result.append(nullToString(value));
}

Bilang resulta, maaari mong makuha ang sumusunod na resulta:

3. StringJoiner class (Java 8+)

Ang StringJoiner class ay nagbibigay ng mas malakas na function para sa pagsali sa mga string. Hindi lamang nito maaaring tukuyin ang delimiter sa panahon ng pagsasama-sama, ngunit tukuyin din ang prefix at suffix. Kapag pinagsama-sama ang mga string, maaari naming gamitin ang add() na paraan . Ang nullToString() na pamamaraan ay gagamitin din dito upang maiwasan ang mga null na halaga.

String[] values = {"https", "://", "gist.", "github", ".com", null};
StringJoiner result = new StringJoiner("");

for (String value : values) {
    result = result.add(nullToString(value));
}

4. Streams.filter (Java 8+)

Ang Stream API ay isang malakas na klase ng pagpapatakbo ng stream na ipinakilala sa Java 8 na maaaring magsagawa ng karaniwang pag-filter, pagtutugma, pagtawid, pagpapangkat, istatistika, at iba pang mga operasyon.

• Ang filter na operasyon ng filter ay maaaring makatanggap ng isang Predicate function .
• Ang interface ng Predicate function ay pareho sa Function interface na ipinakilala kanina.
• Ito ay isang functional na interface.
• Maaari itong tumagal ng generic na parameter <T> at ang return value ay isang Boolean type.
• Ang panaguri ay kadalasang ginagamit para sa data ng filter .

Para matukoy natin ang isang Predicate para tingnan ang null string at ipasa ito sa filter() na paraan mula sa Stream API. Bukod pa rito, maaari mong gamitin ang paraan ng Collectors.joining() upang sumali sa natitirang mga hindi null na string.

String[] values = {"https", "://", "gist.", "github", ".com", null};

String result = Arrays.stream(values)
    .filter(Objects::nonNull)
    .collect(Collectors.joining());

5. Gamitin ang + operator

Ang paggamit ng + operator ay maaari ring malutas ang problema, ngunit hindi ito inirerekomenda. Alam namin na ang String ay isang hindi nababagong bagay. Ang paggamit ng + sign ay madalas na lumilikha ng isang string object, at sa bawat oras na ang isang bagong string ay nilikha sa memorya, kaya ang performance consumption ng paggamit ng + sign upang pagdugtungin ang mga string ay napakataas.

Konklusyon

Ang artikulong ito ay nagpapakita ng ilang mga pamamaraan para sa pagsasama-sama ng mga string at paghawak ng mga NULL, kung saan ang iba't ibang mga pamamaraan ay maaaring angkop para sa iba't ibang mga sitwasyon. Ipinapakita ng pagsusuri na ang pagganap ng StringBuilder ay ang pinakamahusay. Ngunit sa totoong mga kondisyon, kailangan mong pagsamahin ang ilang mga sitwasyon at pagkatapos ay piliin ang paraan na may pinakamababang pagkawala ng pagganap.