Double brace initialization

1. Double brace initialization

Ang pagsisimula gamit ang double braces ( mula rito ay tinutukoy bilang Double brace initialization ) ay isang Java tool para sa paglikha ng mga koleksyon tulad ng listahan, set at mapa nang sabay-sabay sa kanilang deklarasyon. Kapag kailangan mo ng mga listahan na may mga nakapirming elemento, tulad ng isang listahan ng mga sinusuportahang produkto o mga unit ng pera, ang pagdedeklara ng listahan kasabay ng pagsisimula nito ay nagpapabuti sa pagiging madaling mabasa ng code. Ito ang dahilan kung bakit nagiging popular ang Double brace initialization, dahil walang iba pang karaniwang pamamaraan para sa paglikha ng mga koleksyon na may sabay-sabay na pagsisimula sa code. Sa kasamaang palad, hindi tulad ng iba pang mga programming language, hindi sinusuportahan ng Java ang mga koleksyon ng mga literal. Dahil sa limitasyong ito, ang paglikha ng isang hindi nababagongList na may kahit isang maliit na bilang ng mga elemento ay pumipilit sa amin na magsulat ng maraming linya ng code sa anyo ng mga paulit-ulit na tawag add()upang idagdag ang mga gustong elemento na may panghuling pambalot:

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(3);
list.add(5);
list.add(7);
List<Integer> unmodifiableList = Collections.unmodifiableList(list);

Ito ay isang hindi kinakailangang paulit-ulit na paglalarawan na maaaring pasimplehin. Punan natin ang mga static na listahan sa paraang maginhawa para sa atin, lalo na sa mga static na bloke sa panahon ng pagsisimula, na kung saan ay Double bracemakakatulong sa atin ang pagsisimula, na nagpapahintulot sa amin na isulat ang lahat sa isang linya:

List<Integer> list = Collections.unmodifiableList(new ArrayList<Integer>() {{
        add(2);
        add(3);
        add(5);
}});

Katulad nito, Double braceang pagsisimula ay makakatulong sa amin na punan ang mga halaga at HashMap:

Map<Integer, String> intToString = new HashMap<Integer, String>(){{
         put(1, "one");
         put(2, "two");
         put(3, "three");
 }};

Ang lahat ng ito ay mukhang napaka-elegante, ngunit mayroon itong mga kakulangan, na ginagawang isang anti-pattern ang Double brace initialization. Titingnan pa natin sila sa susunod na kabanata.

Mga kalamangan at kahinaan ng Double brace initialization.

DoubleAng pagsisimula ng brace ay gumagamit ng paglikha ng isang hindi kilalang panloob na klase . Kung ano ang unang nakatago sa ibabaw, gayunpaman, Double braceang pagsisimula ay lumilikha ng isang klase na may karagdagang pagsisimula ng instance nito sa tuwing gagamitin mo ito. Bilang karagdagan, ang isang nakatagong sanggunian sa pribadong klase na ito ay ginagamit, na maaaring humantong sa amin sa mga posibleng pagtagas ng memorya. Hindi mo rin magagamit ang ghost operator para sa mga generics (diamond operator < >), dahil hindi namin ma-access ang loob ng isang anonymous na klase. Mga kalamangan:

1. Pagbawas ng mga linya sa code
2. Paglikha at pagsisimula sa isang expression.

Minuse:

1. Paggawa ng hindi kilalang klase na nakatago mula sa iyo.
2. Na nagkakahalaga sa amin ng mga karagdagang gastos para sa halimbawa nito sa tuwing gagamitin namin ito.
3. Sa bawat oras na ang isang nakatagong reference dito ay nilikha, na maaaring humantong sa mga tagas ng memorya.

Pasya: Dahil sa mga kahinaan sa itaas at pagkakaroon ng mga alternatibo sa Double brace, ang pagsisimula ay nakikita bilang isang anti-pattern sa mundo ng Java.

Mga alternatibo sa Double brace initialization sa Java

Ang mabuting balita ay may iba pang mga paraan upang makamit ang parehong mga layunin sa Java. Maaari naming ipatupad sa isang linya ng code ang paglikha at pagsisimula ng isang ArrayList gamit ang Copy constructor mula sa klase ng Collection gaya ng ipinapakita sa ibaba:

List<Integer> list = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(2, 3, 5)));

Arrays.asList()ay magbabalik sa amin ng isang listahan ng nakapirming haba na ipinasa sa ArrayListtagabuo ng kopya. Tandaan ang pagkakaiba sa pagitan ng mga fixed-length na listahan na ibinalik mula Arrays.asList()sa at Collections.unmodifiableList(): hindi ka maaaring magdagdag o mag-alis ng mga elemento ArrayListng - , ngunit maaari mong baguhin ang isang elemento sa pamamagitan ng index gamit ang set(), na hindi mo magagawa sa isang listahan na ibinalik ni Collections.unmodifiableList(). Kung nais mong makakuha ng isang maliit na listahan, ito ang pinakamahusay na paraan, bagama't ito ay magiging hindi gaanong transparent para sa Setiba pang mga koleksyon, kaya kailangan mong likhain ito Listbago gumawa ng Set-a. Ngunit ito ay mas mahusay pa rin kaysa sa Double brace initialization, dahil sa kasong ito ang isang dagdag na panloob na anonymous na klase ay hindi nilikha sa tuwing ito ay ginagamit. Kung nagpapatakbo ka ng Java 8 mayroon kang ibang alternatibong pamamaraan. Tutulungan ka ng JDK 8 Stream API na lumikha ng maliliit na koleksyon sa pamamagitan ng pagsasama-sama Stream Factoryng mga pamamaraan ng output sa isang koleksyon List:

List<String> list = Collections.unmodifiableList(Stream.of("abc", "bcd", "cde").collect(toList()));

Para sa halip Setay maaari mong gamitin Collectors.toSet()ang pamamaraan Collectors.toList()tulad ng sa ibaba:

Set<String> set = Collections.unmodifiableSet(Stream.of("abc", "bcd", "cde").collect(toSet()));

Sa pamamagitan ng paraan, Stream collectang mga pamamaraan ay hindi ginagarantiya na ang mga koleksyon na kanilang nabuo ay protektado mula sa mga pagbabago. Sa Java 8, ang mga koleksyon na kanilang ibinalik (tulad ng - ArrayList, HashSet, at HashMap) ay medyo karaniwan (maaari nating baguhin ang mga ito), ngunit ang katotohanang ito ay maaaring itama sa hinaharap na mga paglabas ng JDK. Iyon lang sa ngayon ang tungkol sa Double bracepagsisimula sa Java. Ang template na ito ay katanggap-tanggap para sa mga pagsubok at demo, ngunit hindi sapat para sa paggamit ng produksyon. Dahil sa mga likas na disadvantage nito, ang Double brace initialization ay naging isang anti-pattern sa mga araw na ito, lalo na sa mga alternatibong magagamit. Ako mismo ay gumagamit pa rin ng konstruksiyon na ito upang simulan ang mga static na mapa at iyon lang. Para sa Listmas gusto kong lumikha Collectionssa pamamagitan ng pagsasama-sama sa paglikha Array.asListsa constructor nito. At kung gumagamit ako ng Java 8 - isang disenyo gamit ang Stream API at collect(). Mga Kaugnay na Artikulo: Kung nasiyahan ka sa tutorial na ito at gusto mong matuto nang higit pa tungkol sa mga pattern, prinsipyo, at pinakamahuhusay na kasanayan sa Java programming, maaari mo ring tingnan ang iba pang mga artikulo sa aming site . Inirerekomendang Pagbasa: Kung gusto mong matuto nang higit pa tungkol sa mga pattern at pinakamahuhusay na kagawian dapat mong basahin ang Effective Programming ni Joshua Bloch , walang libro ang maaaring pumalit dito. At kung ikaw ay bihasa na sa Java at naghahanap ng isang libro sa mga pattern ng disenyo, ang nakakatawang istilo ng pagtatanghal na kung saan ay kawili-wili at madaling basahin, bigyang-pansin ang "Una ang Ulo. Mga Pattern ng Disenyo" . Pagsasalin ng artikulong Ano ang Double Brace Initialization sa Java? Halimbawa ng Anti Pattern (na-publish noong Oktubre 2015).