Nangungunang 50 Java Core na Mga Tanong at Sagot sa Panayam. Bahagi 2

Nangungunang 50 Java Core na Mga Tanong at Sagot sa Panayam. Bahagi 1

Mga koleksyon

25. Ano ang ibig sabihin ng Mga Koleksyon sa Java?

Ang koleksyon ay isang balangkas na idinisenyo upang mag-imbak at magmanipula ng mga bagay. Ginagamit upang isagawa ang mga sumusunod na operasyon:

• paghahanap;
• pag-uuri;
• pagpapatakbo;
• karagdagan;
• pagtanggal.

Ang lahat ng mga klase at interface para sa balangkas ng Collection ay nasa java.utilpackage.

26. Anong mga klase at interface ang available sa balangkas ng Collection?

Mga Interface:

• Koleksyon;
• Listahan;
• Itakda;
• Mapa;
• Pinagsunod-sunod na Set;
• Pinagsunod-sunod na Mapa;
• Nakapila.

Mga klase:

• Mga listahan:
  1. ArrayList;
  2. LinkedList;
  3. Vector(hindi na ginagamit).
• Mga hanay:
  1. HashSet;
  2. LinkedHashSet;
  3. TreeSet.
• Mapa:
  1. HashMap
  2. TreeMap
  3. HashTable (hindi na ginagamit)
  4. LinkedHashMap
• Nakapila
  1. Priyoridad na Pila.

27. Ano ang ibig sabihin ng sorted at ordered in collections?

Inutusan:

Nangangahulugan ito na ang mga item na nakaimbak sa koleksyon ay batay sa mga halaga na idinagdag sa koleksyon. Sa ganitong paraan maaari nating ulitin ang mga halaga mula sa koleksyon sa isang tiyak na pagkakasunud-sunod. Sa madaling salita, nangangahulugan ito na ang mga elemento ng koleksyon ay may sariling tiyak na pagkakasunud-sunod ayon sa kung saan sila ay nakaayos. Para sa mas mahusay na pag-unawa, ang isang koleksyon na hindi nakaayos ay nag-iimbak ng mga elemento nito sa isang random na pagkakasunud-sunod. Halimbawa, Set.

Pinagbukud-bukod:

Nangangahulugan ito na ang isang pangkat ng mga elemento ay pinagbukod-bukod sa isang koleksyon batay sa data ng elemento ng koleksyon. Iyon ay, hindi lamang ang koleksyon ay iniutos, kundi pati na rin ang pagkakasunud-sunod ng mga elemento ay nakasalalay sa kanilang mga halaga. Maaaring magbago ang order na ito kung mag-uuri ka ayon sa ibang value ng elemento.

28. Anong mga koleksyon ang mayroong interface ng Listahan? Paano ka nagtatrabaho sa List?

Ang mga halaga ng mga elemento sa isang sheet ay batay sa kanilang index-sila ay inayos ayon sa index. Ang mga pag-uulit ng mga elemento ay pinapayagan (iyon ay, maaari mong idagdag ang parehong bagay sa koleksyon nang maraming beses at magiging maayos ito).

ArrayList:

Ang pinakakaraniwang koleksyon. Mahalaga, ito ay isang array na may dynamic na lumalawak na laki. Ang trabaho ng pamamahala sa laki ng array ay nakasalalay sa koleksyon. Mahalagang maunawaan natin na sa karamihan ng mga kaso ito ang kailangan nating gamitin. Mga Katangian:

• mabilis na paghahanap at mabilis na paghahanap ng index;
• ang koleksyon ay inayos ayon sa index, ngunit hindi pinagsunod-sunod;
• nagpapatupad ng RandomAccess interface;
• dahan-dahang idinaragdag sa gitna ng listahan.

Halimbawa:

public class A {

   public static void main(String[] args) {
       ArrayList names = new ArrayList<>();
       names.add("John");
       names.add("John");
       names.add("Roman");
       names.add("Ivan");
   }

}

>> output

   [John, John, Roman, Ivan]

Ipinapakita ng output na ang mga ito ay nauulit na elemento. Ang mga ito ay ipinapakita sa pagkakasunud-sunod kung saan sila ay naitala. Ano pa ang dapat basahin? Oo, maraming impormasyon, hindi mo na kailangang umalis sa JavaRush:

• Detalyadong pagsusuri ng klase ng ArrayList
• klase ng ArrayList
• Working ArrayList sa mga larawan
• ArrayList sa Java

Naka-link na Listahan:

Ito ay isang koleksyon kung saan ang bawat elemento ay may link sa nakaraan at susunod na mga elemento. Binibigyang-daan ka ng mga link na ito na lumipat mula sa isang elemento patungo sa isa pa. Kapag nagdadagdag ng elemento, nagbabago lang ang mga link sa nakaraan at susunod na elemento:

• ang mga elemento ay konektado sa isa't isa, iyon ay, ipinatupad ang isang dobleng naka-link na listahan;
• ang kabuuang bilis ng operasyon ay kapansin-pansing mas mababa kaysa sa ArrayList;
• isang mahusay na pagpipilian para sa isang malaking bilang ng mga pagsingit at pagtanggal sa gitna ng isang array;
• nagpapatupad ng mga interface ng Queue at Deque list, at samakatuwid ay may mga pamamaraan nito para sa pagtatrabaho.

Halimbawa:

LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("One");
linkedList.add("Two");
linkedList.add("Three");

29. Sabihin sa amin ang tungkol sa koleksyon ng Mapa at mga pagpapatupad nito?

Ang mapa ay isang key-value collection. Mayroong natatanging susi at isang halaga na tumutugma sa halagang iyon. Ginagamit equals()din ang mga pamamaraan hashcode()upang matukoy ang pagiging natatangi ng isang susi.

HashMap:

• hindi pinagsunod-sunod o inayos;
• ginagamit kung hindi mahalaga ang pagkakasunud-sunod at pag-uuri;
• sumusuporta sa null key.

Halimbawa:

public class CollectionExample {

   public static void main(String[] args) {
       HashMap positions = new HashMap<>();
       positions.put("junior", "Ivan");
       positions.put("middle", "Roman");
       positions.put("senior", "Vasily");
       positions.put("team lead", "Anton");
       positions.put("arthitect", "Andrew");
       positions.put("senior", "John");
       System.out.println(positions);
   }
}

// вывод в консоль
// {junior=Ivan, middle=Roman, senior=John, team lead=Anton, arthitect=Andrew}

Ang mga susi ay palaging natatangi, kaya isang senior lamang ang naitala.

LinkedHashMap:

• nagpapanatili ng insertion order;
• mas mabagal kaysa sa HashMap;
• ang pag-ulit ay inaasahang mas mabilis kaysa sa HashMap.

Halimbawa:

public class CollectionExample {

   public static void main(String[] args) {
       LinkedHashMap<String, String> positions = new LinkedHashMap<>();
       positions.put("junior", "Ivan");
       positions.put("middle", "Roman");
       positions.put("senior", "Vasily");
       positions.put("team lead", "Anton");
       positions.put("arthitect", "Andrew");
       positions.put("senior", "John");
       System.out.println(positions);
   }
}

// вывод в консоль
// {junior=Ivan, middle=Roman, senior=John, team lead=Anton, arthitect=Andrew}

TreeMap:

Isang pagpapatupad ng mapa na nagpapanatili sa mga entry na pinagsunod-sunod ayon sa natural na pagkakasunud-sunod ng kanilang mga susi, o mas mabuti pa, gamit ang isang comparator kung ang isa ay ibinigay sa constructor kapag ginawa ang mapa. Halimbawa:

1. Nang walang kumpare

   public class CollectionExample {
   
      public static void main(String[] args) {
          TreeMap<Integer, String> positions = new TreeMap<>();
          positions.put(1, "Ivan");
          positions.put(3, "Roman");
          positions.put(2, "Vasily");
          positions.put(10, "Anton");
          positions.put(7, "Andrew");
          positions.put(1, "John");
          System.out.println(positions);
      }
   }
   
   // вывод в консоль
   // {1=John, 2=Vasily, 3=Roman, 7=Andrew, 10=Anton}

2. Sa comparator

   public class CollectionExample {
   
      public static void main(String[] args) {
          //используем реализацию Strategy Pattern'a и добавим компаратор:
          TreeMap<Integer, String> positions = new TreeMap<>(Comparator.reverseOrder());
          positions.put(1, "Ivan");
          positions.put(3, "Roman");
          positions.put(2, "Vasily");
          positions.put(10, "Anton");
          positions.put(7, "Andrew");
          positions.put(1, "John");
          System.out.println(positions);
      }
   }
   
   // вывод в консоль
   // {10=Anton, 7=Andrew, 3=Roman, 2=Vasily, 1=John}

Nakikita namin na ang pag-uuri sa pataas na pagkakasunud-sunod ay ipinatupad bilang pamantayan, ngunit maaari itong baguhin sa pamamagitan ng pagdaragdag ng isang comparator sa constructor. Ang TreeMap ay mahusay na inilarawan dito .

30. Sabihin sa amin ang tungkol sa Set collection at mga pagpapatupad nito?

Ang set ay isang hanay ng mga natatanging elemento, at ito ang pangunahing tampok nito. Ibig sabihin, hindi pinapayagan ng Set na maulit ang parehong mga elemento. Ito ay mahalaga dito na ang mga bagay na idinagdag ay may isang pamamaraan na ipinatupad equals .

HashSet:

• hindi inayos o inayos. Sa ilalim ng hood ay mayroong HashMap na may placeholder para sa halaga. Tingnan mo ang sarili mo ;)
• gumagamit ng hashCode upang magdagdag ng mga bagay;
• Dapat itong gamitin kapag kailangan mong magkaroon ng mga natatanging bagay at ang kanilang pagkakasunud-sunod ay hindi mahalaga.

Halimbawa:

public class CollectionExample {

   public static void main(String[] args) {
       HashSet<String> positions = new HashSet<>();
       positions.add("junior");
       positions.add("junior");
       positions.add("middle");
       positions.add("senior");
       positions.add("team lead");
       positions.add("architect");
       System.out.println(positions);
   }
}

// вывод в консоль
// [senior, middle, team lead, architect, junior]

Dito makikita mo na ang "junior" na elemento, na idinagdag nang dalawang beses, ay naroroon lamang sa isang pagkakataon. At ang pagkakasunud-sunod ay hindi katulad ng kapag nagdadagdag.

LinkedHashSet:

• iniutos na bersyon ng HashSet;
• sumusuporta sa dobleng naka-link na listahan para sa lahat ng mga elemento;
• gamitin ito kapag kailangan ang kaayusan sa panahon ng pag-ulit.

Halimbawa:

public class CollectionExample {

   public static void main(String[] args) {
       LinkedHashSet<String> positions = new LinkedHashSet<>();
       positions.add("junior");
       positions.add("junior");
       positions.add("middle");
       positions.add("senior");
       positions.add("team lead");
       positions.add("architect");
       System.out.println(positions);
   }
}

// вывод в консоль
// [senior, middle, team lead, architect, junior]

TreeSet:

• isa sa dalawang pinagsunod-sunod na koleksyon;
• gumagamit ng pulang-itim na istraktura ng puno at tinitiyak na ang mga elemento ay nasa pataas na ayos;
• Sa ilalim ng talukbong ito ay isang TreeMap na may stub sa mga halaga. At ang mga elemento ng TreeSet ay ang mga susi sa TreeMap (tingnan din ;)).

Halimbawa:

public class CollectionExample {

   public static void main(String[] args) {
       TreeSet<String> positions = new TreeSet<>();
       positions.add("junior");
       positions.add("junior");
       positions.add("middle");
       positions.add("senior");
       positions.add("team lead");
       positions.add("architect");
       System.out.println(positions);
   }
}

// вывод в консоль
// [architect, junior, middle, senior, team lead]

Mga pagbubukod

31. Ano ang Exception?

Ang pagbubukod ay isang problema na maaaring mangyari sa runtime. Ito ay isang pambihirang sitwasyon na lumitaw dahil sa ilang kadahilanan. Ganito ang hitsura ng exception inheritance diagram (kailangan mong malaman ito sa puso ;)): Ipinapakita ng diagram na, sa pangkalahatan, ang lahat ng exception ay nahahati sa dalawang grupo - exception at error. Error - Ginagamit ang mga JVM upang magpakita ng mga error pagkatapos nito ay wala nang saysay ang application. Halimbawa, ang StackOverFlowError, na nagsasabing puno na ang stack at hindi na maaaring tumakbo ang program. Exception - mga pagbubukod na nabuo sa pamamagitan ng program sa code. Mayroong iba't ibang mga pagbubukod, nasuri at hindi nasuri, ngunit ang pangunahing bagay ay umiiral ang mga ito, at maaari silang mahuli at ang application ay maaaring magpatuloy na gumana. Ang mga pagbubukod, sa turn, ay higit na nahahati sa mga nagmana mula sa RuntimeException at iba pang mga inapo ng Exception. May sapat na impormasyon sa isyung ito. Pag-uusapan natin kung ano ang mga naka-check/uncheck na mga exception sa ibaba.

32. Paano pinangangasiwaan ng JVM ang mga pagbubukod?

Paano ito gumagana? Sa sandaling itapon ang isang exception sa isang lugar, lumilikha ang runtime ng Exception Object (na tinukoy bilang ExcObj). Iniimbak nito ang lahat ng impormasyong kinakailangan para sa trabaho - ang pagbubukod mismo na itinapon at ang lugar kung saan ito nangyari. Ang paglikha ExcObjat pagpapadala sa runtime ay walang iba kundi ang "paghagis ng eksepsiyon." ExcObjnaglalaman ng mga pamamaraan na maaaring magamit upang makarating sa lugar kung saan itinapon ang pagbubukod. Ang hanay ng mga pamamaraan na ito ay tinatawag na Call Stack. Susunod, ang runtime system ay naghahanap ng isang paraan sa Call Stack na maaaring humawak sa aming exception. Kung makakahanap ito ng kaukulang handler, iyon ay, ang uri ng exception ay tumutugma sa uri sa handler, lahat ay maayos. Kung hindi ito mahanap, pagkatapos ay ipapasa ng runtime ang lahat sa default na handler ng exception, na naghahanda ng tugon at paglabas. Kung ano ang hitsura nito sa paningin:

/**
* Пример, в котором показываются две опции — когда находится обработчик для исключения и когда нет.
*/
class ThrowerExceptionExample {

   public static void main(String[] args) throws IllegalAccessException {

       ThrowerExceptionExample example = new ThrowerExceptionExample();

       System.out.println(example.populateString());
   }

   /**
    * Здесь происходит перехват одного из возможных исключений — {@link IOException}.
    * А вот второй будет пробрасываться дальше вверх по вызову.
    */
   private String populateString() throws IllegalAccessException {
       try {
           return randomThrower();
       } catch (IOException e) {
           return "Caught IOException";
       }
   }

   /**
    * Здесь две опции: or бросается {@link IOException} or {@link IllegalAccessException}.
    * Выбирается случайным образом.
    */
   private String randomThrower() throws IOException, IllegalAccessException {
       if (new Random().nextBoolean()) {
           throw new IOException();
       } else {
           throw new IllegalAccessException();
       }
   }
}

Sa aming kaso, ang CallStack ay schematically magmukhang:

randomThrower() => populateString() => main(String[] args)

Mayroong dalawang mga pagpipilian: ang isa o ang isa pang pagbubukod ay random na itatapon. Para sa IOException ang lahat ay ok, kung ito ay nabuo, ang resulta ng trabaho ay: "Caught IOException". Ngunit kung mayroong pangalawang pagbubukod kung saan walang tagapangasiwa, ang programa ay titigil sa sumusunod na output:

Exception in thread "main" java.lang.IllegalAccessException
  at ThrowerExceptionExample.randomThrower(CollectionExample.java:38)
  at ThrowerExceptionExample.populateString(CollectionExample.java:24)
  at ThrowerExceptionExample.main(CollectionExample.java:15)

33. Paano pinangangasiwaan ng mga programmer ang mga pagbubukod?

Sa mga tanong sa itaas, nagamit na ang ilang partikular na keyword upang gumana nang may mga pagbubukod; ngayon kailangan nating pag-usapan ang mga ito nang mas detalyado. Ano ang mga keyword?

• subukan
• mahuli
• itapon
• nagtatapon
• sa wakas

Mahalagang tandaan na ang catch, throw at throws ay magagamit lamang sa java.lang.Throwable. Hindi ito gagana sa iba pang mga uri. Ngayon ay tatalakayin natin ang try, catch at sa wakas.

• try-catch-finallyay isang construct na nagbibigay-daan sa iyo na mahuli at mahawakan nang tama ang isang exception.
• try- maaari lamang magkaroon ng isang pagkakataon, kung saan nangyayari ang lohika;
• catch— isang bloke na tumatanggap ng ilang uri ng pagbubukod; maaaring marami sa kanila. Halimbawa, ang isang try block ay magtapon ng ilang mga exception na walang kinalaman sa isa't isa;
• finally- "sa wakas" block na ito. Ito ay isang bloke na isasagawa sa anumang kaso, anuman ang ginawa sa pagsubok, catch.

Ito ang hitsura nito:

try {
   // сюда передают тот code, который может вызвать исключение.
} catch (IOException e) {
   // первый catch блок, который принимает IOException и все его подтипы(потомки).
   // Например, нет file при чтении, выпадает FileNotFoundException, и мы уже соответствующе
   // обрабатываем это.
} catch (IllegalAccessException e) {
   // если нужно, можно добавить больше одного catch блока, в этом нет проблем.
} catch (OneException | TwoException e) {
   // можно даже объединять несколько в один блок
} catch (Throwable t) {
   // а можно сказать, что мы принимаем ВСЁ))))
} finally {
   // этот блок может быть, а может и не быть.
   // и он точно выполнится.
}

Maingat na basahin ang paglalarawan ng halimbawa at magiging malinaw ang lahat)

34. magtapon at magtapon sa Java

itapon

throwginagamit kapag kailangan mong tahasang lumikha ng bagong exception. Ito ay ginagamit upang lumikha at magtapon ng mga custom na pagbubukod. Halimbawa, ang mga pagbubukod na nauugnay sa pagpapatunay. Karaniwan, para sa pagpapatunay, nagmana sila mula sa RuntimeException. Halimbawa:

// пример пробрасывания исключения
throw new RuntimeException("because I can :D");

Mahalaga na ang konstruksiyon na ito ay magagamit lamang ng isang bagay na nagmana mula sa Throwable. Ibig sabihin, hindi mo masasabi ito:

throw new String("How тебе такое, Илон Маск?");

Susunod, winakasan ang gawain ng thread at magsisimula ang paghahanap para sa isang handler na maaaring magproseso nito. Kapag hindi nito nahanap, pupunta ito sa paraan na tumawag dito, at sa gayon ang paghahanap ay tataas sa linya ng mga tawag hanggang sa mahanap nito ang kaukulang handler o iwanang tumatakbo ang application. Tingnan natin:

// Пример, который демонстрирует работу throw
class ThrowExample {

   void willThrow() throws IOException {
       throw new IOException("Because I Can!");
   }

   void doSomething() {
       System.out.println("Doing something");
       try {
           willThrow();
       } catch (IOException e) {
           System.out.println("IOException was successfully handled.");
       }
   }

   public static void main(String args[]) {
       ThrowExample throwExample = new ThrowExample();
       throwExample.doSomething();
   }
}

Kung patakbuhin namin ang programa, makukuha namin ang sumusunod na resulta:

Doing something
IOException was successfully handled.

nagtatapon

throws- isang mekanismo kung saan ang isang pamamaraan ay maaaring magtapon ng isa o higit pang mga pagbubukod. Ang mga ito ay idinaragdag na pinaghihiwalay ng mga kuwit. Tingnan natin kung gaano kadali at simple ito:

private Object willThrow() throws RuntimeException, IOException, FileNotFoundException

Bukod dito, mahalagang tandaan na maaaring mayroong parehong naka-check at hindi naka-check na mga pagbubukod. Siyempre, ang mga hindi naka-check na mga pagbubukod ay hindi maaaring idagdag sa throws, ngunit iba ang sinasabi ng mabuting asal. Kung ito ay mga checkable, pagkatapos ay gamit ang paraan na bumubuo sa kanila, kailangan mong iproseso ito kahit papaano. Mayroong dalawang mga pagpipilian:

1. Sumulat try-catchnang may naaangkop at higit na eksepsiyon sa mana.
2. Gamitin ito throwssa eksaktong parehong paraan upang ang ibang tao ay may ganitong problema :D

35. May check at Unchecked na mga exception sa Java

Mayroong dalawang uri ng mga exception sa Java - may check at uncheck.

Sinuri ang mga pagbubukod:

Ito ay mga pagbubukod na sinusuri sa oras ng pag-compile. Kung ang ilang code sa isang pamamaraan ay naghagis ng may check na exception sa panahon ng exception, dapat itong iproseso ng paraan gamit ang try-catch, o ipasa pa ito. Halimbawa, na nagbabasa ng larawan mula sa path na "/users/romankh3/image.png", ina-update ito sa ilang paraan (para sa amin ito ay hindi mahalaga) at i-save ito pabalik.

class CheckedImageExample {
   public static void main(String[] args) {
       File imageFile = new File("/users/romankh3/image.png");
       BufferedImage image = ImageIO.read(imageFile);
       updateAndSaveImage(image, imageFile);
   }

   private static void updateAndSaveImage(BufferedImage image, File imageFile) {
       ImageIO.write(image, "png", imageFile);
   }
}

Ang nasabing code ay hindi mag-compile, dahil ang mga static na pamamaraan ay ImageIO.read()nagtatapon ImageIO.write()ng isang IOException, na sinusuri at dapat na hawakan nang naaayon. Mayroong dalawang mga opsyon dito na napag-usapan na natin sa itaas: alinman sa paggamit try-catch, o pasulong pa. Para sa mas mahusay na asimilasyon, gagawin natin ito at iyon. Iyon ay, updateAndSaveipapasa lang namin ito sa pamamaraan, at pagkatapos ay gamitin ito sa pangunahing pamamaraan try-catch:

class CheckedImageExample {
   public static void main(String[] args) {
       File imageFile = new File("/users/romankh3/image.png");
       try {
           BufferedImage image = ImageIO.read(imageFile);
           updateAndSaveImage(image, imageFile);
       } catch (IOException e) {
           e.printStackTrace();
       }
   }

   private static void updateAndSaveImage(BufferedImage image, File imageFile) throws IOException {
       ImageIO.write(image, "png", imageFile);
   }
}

Walang check na mga pagbubukod:

Ito ang mga pagbubukod na hindi nasuri sa yugto ng compilation. Iyon ay, ang isang pamamaraan ay maaaring makabuo ng isang RuntimeException, ngunit ang compiler ay hindi magpapaalala sa iyo na kahit papaano ay pangasiwaan ito. Tulad ng ipinapakita sa ibaba, mayroon kaming lahat ng nagmamana mula sa RuntimeException at ang Error ay hindi naka-check. Isaalang-alang ang sumusunod na Java program. Ang code ay nag-compile nang maayos, ngunit nagtatapon ng isang pagbubukod kapag tumakbo ArrayIndexOutOfBoundsException. Pinapayagan ito ng compiler na mag-compile dahil ArrayIndexOutOfBoundsExceptionito ay isang unchecked exception. Isang karaniwang sitwasyon na may array, na maaaring:

class CheckedImageExample {
   public static void main(String[] args) {
       int[] array = new int[3];
       array[5] = 12;
   }
}

Ang magiging resulta ay:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
  at main(CheckedImageExample.java:12)

Oo nga pala, napansin mo na ba na sa Java walang nagbibigay ng maikling pangalan? Ang mas malaki, mas mabuti. Siya, Spring Framework, ay napaka-matagumpay dito: kumuha lang ng ilang klase ng BeanFactoryPostProcessor )))

36. Ano ang try-with-resources?

Ito ay isang mekanismo kung saan ang lahat ng mga mapagkukunan ay dapat na sarado nang tama. Ito ay kahit papaano ay hindi malinaw, tama?) Una sa lahat, ano ang isang mapagkukunan... Ang isang mapagkukunan ay isang bagay, pagkatapos magtrabaho kung saan kailangan mong isara ito, iyon ay, tawagan ang close(). Ang isang mapagkukunan ay tumutukoy sa lahat ng mga bagay na nagpapatupad ng isang interface AutoClosable, na siya namang nagpapatupad ng isang interface Closeable. Mahalagang maunawaan natin na ang lahat InputStreamay OutpuStreamisang mapagkukunan at kailangang mailabas nang tama at matagumpay. Ito ang eksaktong dahilan kung bakit kailangan nating gamitin try-with-resourceang istraktura. Narito ang hitsura nito:

private void unzipFile(File zipFile) throws IOException {
   try(ZipInputStream zipOutputStream = new ZipInputStream(new FileInputStream(zipFile))) {
       ZipEntry zipEntry = zipOutputStream.getNextEntry();
       while (zipEntry != null) {

       }
   }
}

private void saveZipEntry(ZipEntry zipEntry) {
   // логика сохранения
}

Sa halimbawang ito, ang mapagkukunan ay ZipInputStream, pagkatapos magtrabaho kung saan kakailanganin mong isara ito. At upang hindi mag-isip tungkol sa pagtawag sa pamamaraan close(), tukuyin lang namin ang variable na ito sa isang try block, tulad ng ipinapakita sa halimbawa, at sa loob ng block na ito ginagawa namin ang lahat ng kailangan. Ano ang ginagawa ng halimbawa? I-unzip nito ang zip archive. Upang gawin ito kailangan mong gamitin InputStreamang 'om. Maaari mong tukuyin ang higit sa isang variable; pinaghihiwalay sila ng isang semicolon. Ano ang problema? Ngunit maaari kang gumamit finallyng isang bloke, maaari mong sabihin. Narito ang isang artikulo na nagdedetalye ng mga problema sa diskarteng ito. Inilalarawan din nito ang buong listahan ng mga kabiguan na maaaring mangyari sa isang taong nagpapabaya sa paggamit ng disenyong ito. Inirerekumenda kong basahin ito ;) Sa huling bahagi ay may mga tanong/sagot sa paksa ng Multithreading. Aking GitHub profile