Coffee break #185. Isang Komprehensibong Gabay sa Java Collection Framework

Source: Medium Tutulungan ka ng tutorial na ito na mas maunawaan ang mga gawain ng iba't ibang klase at interface na kasama sa Java Collection Framework. Ang Java Collection ay isang balangkas na nagbibigay ng pinag-isang arkitektura para sa pag-iimbak at pamamahala ng isang pangkat ng mga bagay. Sa kaibuturan nito, ito ay isang hanay ng mga klase at interface na nagbibigay ng karaniwang paraan upang kumatawan at manipulahin ang mga koleksyon ng mga bagay sa wikang Java. Nakakatulong din ang framework sa pagpapatupad ng mga karaniwang ginagamit na istruktura ng data gaya ng List, Set at Map. Kasama sa Java Collection Framework ang ilang mga interface at klase. Narito ang isang listahan ng ilan sa kanila:

Mga interface

Tinutukoy ng mga interface sa Java Collection Framework ang pangkalahatang pag-uugali at mga operasyon na maaaring gawin sa mga koleksyon. Kabilang dito ang pagdaragdag o pag-alis ng mga item, pag-uulit ng mga item sa isang koleksyon, at higit pa.

• Koleksyon : Ang root interface sa isang hierarchy ng koleksyon, na kumakatawan sa isang pangkat ng mga bagay na kilala bilang mga elemento.
• Listahan : Isang nakaayos na koleksyon ng mga elemento na nagbibigay-daan sa pagdoble.
• Set : isang koleksyon ng mga elemento na hindi pinapayagan ang pagdoble.
• Mapa : isang koleksyon ng mga pares ng key-value, kung saan natatangi ang bawat key.
• Queue : Ang queue ay isang istraktura ng data na ginagamit upang mag-imbak ng mga elemento sa First-In-First-Out (FIFO).

Hindi kasama sa listahang ito ang lahat, ngunit ang mga pinakaginagamit na interface lang sa Java Collection Framework. Ngayon tingnan natin ang bawat isa sa kanila.

Koleksyon

Ang Koleksyon ay isang pangkat ng mga bagay na kilala bilang mga elemento nito. Ito ay isang bagay na maaaring maglaman ng mga sanggunian sa iba pang mga bagay. Ang interface ng Collection ay ang ugat ng hierarchy ng koleksyon. Ito ang batayang interface para sa lahat ng mga koleksyon sa Java Collection Framework. Tinutukoy nito ang mga pangunahing pamamaraan na dapat ipatupad sa lahat ng mga koleksyon, tulad ng add() , remove() at contains() . Narito ang isang halimbawa ng paggamit ng mga koleksyon sa Java Collection Framework. Dito ginagamit ang interface ng Collection upang magdagdag at mag-alis ng mga elemento mula sa isang koleksyon:

import java.util.Collection;
import java.util.ArrayList;

public class CollectionExample {
    public static void main(String[] args) {
        // Создаем новую коллекцию
        Collection<String> stringCollection = new ArrayList<>();

        // Добавляем несколько элементов в коллекцию
        stringCollection.add("hello");
        stringCollection.add("world");
        stringCollection.add("foo");
        stringCollection.add("bar");

        // Печатаем число элементов в коллекции
        System.out.println("Number of elements: " + stringCollection.size());

        // Удаляем элемент из коллекции
        stringCollection.remove("foo");

        // Опять печатаем число элементов в коллекции
        System.out.println("Number of elements: " + stringCollection.size());
    }
}

Ang output ay: Tulad ng nakikita mo, ang interface ng Collection ay isang simple at maginhawang paraan upang magsagawa ng mga karaniwang operasyon na may isang koleksyon ng mga bagay. Madalas itong ginagamit bilang panimulang punto kapag nagtatrabaho sa mga koleksyon sa Java. Kasama sa Java Collection Framework ang ilang interface na tumutukoy sa karaniwang gawi para sa iba't ibang uri ng mga koleksyon. Ang ilan sa mga ito ay bahagi ng pangkat ng interface ng java.util.Collection :

• java.util.List
• java.util.set
• java.util.Queue

java.util.List

Ang listahan ay isang nakaayos na koleksyon ng mga bagay, na ang bawat elemento ay sumasakop sa isang partikular na posisyon sa listahan. Pinapalawak ng interface ng Listahan ang interface ng Koleksyon at nagdaragdag ng ilang mga pamamaraan para sa pagtatrabaho sa mga listahan, tulad ng mga pamamaraan para sa pag-access ng mga elemento ayon sa kanilang posisyon sa listahan at mga pamamaraan para sa paghahanap at pag-uuri ng mga listahan. Ang isang Listahan ay maaaring maglaman ng mga dobleng elemento , ang mga elementong ito ay maaaring ma-access sa pamamagitan ng kanilang posisyon sa listahan. Narito ang isang halimbawa ng paggamit ng interface ng Listahan upang magdagdag, mag-alis, at mag-access ng mga item sa isang listahan:

import java.util.List;
import java.util.ArrayList;

public class ListExample {
    public static void main(String[] args) {
        // Создаем новый список
        List<String> stringList = new ArrayList<>();

        // Добавляем несколько элементов в список
        stringList.add("India");
        stringList.add("UAE");
        stringList.add("London");
        stringList.add("US");

        // Печатаем первый элемент в списке
        System.out.println("First element: " + stringList.get(0));

        // Удаляем второй элемент из списка
        stringList.remove(1);

        // Печатаем второй элемент в списке
        System.out.println("Second element: " + stringList.get(1));
    }
}

Konklusyon: Tulad ng ipinakita sa itaas, ang interface ng Listahan ay nagbibigay ng isang maginhawang paraan upang gumana sa mga nakaayos na koleksyon ng mga elemento. Karaniwan itong ginagamit kapag kailangan mong panatilihin ang pagkakasunud-sunod ng mga elemento sa isang koleksyon o kapag kailangan mong i-access ang mga elemento sa pamamagitan ng kanilang index sa isang listahan.

java.util.Set

Ang isang Set sa Java Collection Framework ay isang hindi nakaayos na hanay ng mga natatanging elemento na hindi nagpapahintulot ng mga dobleng elemento . Ang interface ng Set ay nagpapalawak sa interface ng Collection at nagdaragdag ng ilang mga pamamaraan, tulad ng mga pamamaraan para sa pagsuri kung ang isang elemento ay nasa isang set at mga pamamaraan para sa pagdaragdag at pag-alis ng mga elemento mula sa isang set. Narito ang isang halimbawa ng paggamit ng Set interface upang magdagdag at mag-alis ng mga elemento mula sa isang set sa Java Collection Framework:

import java.util.Set;
import java.util.HashSet;

public class SetExample {
    public static void main(String[] args) {
        // Создаем новый set
        Set<String> stringSet = new HashSet<>();

        // Добавляем несколько элементов в set
        stringSet.add("Jan");
        stringSet.add("Feb");
        stringSet.add("March");
        stringSet.add("April");

        // Проверяем наличие в set element "March"
        if (stringSet.contains("March")) {
            System.out.println("The set contains the element 'March'");
        }

        // Удаляем элемент "April" из set
        stringSet.remove("April");

        // Опять проверяем наличие element "April" в set
        if (!stringSet.contains("April")) {
            System.out.println("The set no longer contains the element 'April'");
        }
    }
}

Konklusyon:

java.util.Queue

Ang Queue ay isang istraktura ng data na ginagamit upang mag-imbak ng mga elemento sa pagkakasunud-sunod na first-in-first-out (FIFO). Nangangahulugan ito na ang unang elementong idinagdag sa pila ay ang unang elementong aalisin. Narito ang isang halimbawa kung paano gumamit ng queue sa Java Collection Framework:

// Creation очереди
Queue<String> queue = new LinkedList<>();

// Добавление элементов в очередь
queue.add("apple");
queue.add("banana");
queue.add("orange");
// Печатаем очередь
System.out.println("Queue: " + queue);
// Удаляем элемент из очереди
String element = queue.remove();
System.out.println("Removed element: " + element);
// Печатаем обновленную очередь
System.out.println("Queue: " + queue);

Sa halimbawang ito, gumawa kami ng string queue at nagdagdag ng tatlong elemento dito: "mansanas", "saging" at "orange". Pagkatapos ay i-print namin ang pila upang makita ang kasalukuyang estado nito. Susunod, aalisin namin ang elemento mula sa pila at i-print ito sa console. Sa wakas, ini-print namin ang na-update na pila upang matiyak na ang tinanggal na elemento ay wala na sa pila.

Mapa

Ang java.util.Map interface sa Java Collection Framework ay ginagamit upang imapa ang mga key sa mga value. Binibigyang-daan ka nitong mag-imbak ng mga elemento bilang mga pares ng key-value at nagbibigay ng mga pamamaraan para sa pag-access, pagbabago, at pag-ulit sa mga elemento sa isang mapa. Nasa ibaba ang isang halimbawa ng paggamit ng Map interface :

// Создаем Map
 Map<String, Integer> map = new  HashMap <>();
// Добавляем элементы в Map
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);
// Печать Map
 System.out.println("Map: " + map);
// Получаем meaning для определенного ключа
int  value  = map.get( "banana" );
System.out.println("Value for 'banana': " + value);
// Удаляем элемент из Map
map.remove("orange");
// Печать обновленной карты
 System.out.println( "Map: " + map);

Sa halimbawang ito, lumikha kami ng isang mapa ng mga string at integer sa pamamagitan ng pagdaragdag ng tatlong elemento dito: "apple" na mga tugma 1, "banana" na mga tugma 2, at "orange" na mga tugma 3. Pagkatapos ay i-print namin ang mapa upang makita ang kasalukuyang kahulugan nito. Pagkatapos nito, nakukuha namin ang halaga ng "saging" key at i-print ito sa console. Panghuli, inalis namin ang key-value pair para sa "orange" mula sa mapa at i-print ang na-update na mapa upang makitang wala na doon ang inalis na elemento.

Mga klase

Ang Klase ay isang kongkretong pagpapatupad ng isang interface ng koleksyon. Nagbibigay ito ng mga partikular na pagpapatupad ng mga karaniwang pag-uugali at pagpapatakbo na tinukoy ng mga interface sa balangkas.

• ArrayList : Isang pagpapatupad ng List interface na may resizable array.
• LinkedList : isang dobleng naka-link na listahan, isang pagpapatupad ng List at Deque na mga interface .
• HashSet : Isang pagpapatupad ng Set na gumagamit ng hash table para sa storage.
• TreeSet : Isang pagpapatupad ng Set na gumagamit ng tree para sa storage.
• HashMap : Isang pagpapatupad ng Map na gumagamit ng hash table para sa storage.

Ang listahan sa itaas ay isa sa mga pinakakaraniwang ginagamit na klase sa Java Collection Framework. Ngayon tingnan natin ang detalyadong paliwanag ng mga klaseng ito.

ArrayList

Ang java.util.ArrayList na klase sa mga koleksyon ng Java ay ginagamit upang mag-imbak ng isang resizable na hanay ng mga elemento sa isang listahan. Ito ay malawakang ginagamit na pagpapatupad ng interface ng java.util.List na gumagamit ng array upang mag-imbak ng mga elemento at nagbibigay ng mahusay na mga pamamaraan para sa pag-access, pagbabago, at pag-ulit sa pamamagitan ng mga elemento sa isang listahan. Ang klase ng java.util.ArrayList ay nagbibigay ng mabilis na random na pag-access sa mga elemento nito, ngunit mabagal ang pagpasok at pagtanggal sa mga random na posisyon. Nasa ibaba ang isang halimbawa ng paggamit ng klase ng ArrayList sa Java Collection Framework:

// Создаем array list
List<String> list = new ArrayList<>();
// Добавляем элементы в array list
list.add("qa");
list.add("devops");
list.add("dev");
// Печатаем array list
System.out.println("Array list: " + list);
// Доступ к элементу по определенному индексу
String element = list.get(1);
System.out.println("Element at index 1: " + element);
// Удаление element из the array list
list.remove(1);
// Print the updated array list
System.out.println("Array list: " + list);

Tulad ng nakikita mo, lumikha kami ng isang hanay ng mga string at nagdagdag ng tatlong elemento dito: "qa", "devops" at "dev". Pagkatapos ay nai-print namin ang listahan ng array upang makita ang kasalukuyang estado nito. Pagkatapos nito, ina-access namin ang elemento sa index 1 at i-print ito sa console. Sa wakas, inaalis namin ang elemento sa index 1 mula sa listahan ng array at nag-print ng na-update na listahan ng array upang matiyak na wala na sa listahan ang inalis na elemento.

LinkedList

Ang java.util.LinkedList na klase sa Java Collection Framework ay nagmamana mula sa AbstractList na klase at nagpapatupad ng List at Deque na mga interface . Nagbibigay ito ng mga mahusay na pamamaraan para sa pagdaragdag, pag-alis, at pag-access ng mga elemento sa simula at dulo ng isang listahan. Ang Klase na ito ay isa ring pagpapatupad ng interface ng Listahan , na gumagamit ng dobleng naka-link na listahan upang mag-imbak ng mga elemento. Nagbibigay ito ng mabilis na pagpasok at pagtanggal sa mga arbitrary na posisyon, ngunit mabagal ang random na pag-access sa mga elemento nito. Narito ang isang halimbawa kung paano gamitin ang LinkList na klase sa Java Collection Framework:

// Создаем linked list
List<String> list = new LinkedList<>();
// Добавляем элементы в linked list
list.add("selenium");
list.add("cypress");
list.add("playwright");
// Печатаем linked list
System.out.println("Linked list: " + list);
// Добавляем элемент в начало списка
list.add(0, "webdriver.io");
// Печатаем обновленный linked list
System.out.println("Linked list: " + list);
// Удаляем первый элемент в списке
list.remove(0);
// Еще раз печатаем обновленный linked list
System.out.println("Linked list: " + list);

Sa halimbawang ito, gumawa kami ng naka-link na listahan ng mga string at nagdagdag kami ng tatlong elemento dito: "selenium", "cypress" at "playwright". Pagkatapos ay i-print namin ang naka-link na listahan upang makita ang kasalukuyang estado nito. Susunod, idaragdag namin ang elementong "webdriver.io" sa simula ng listahan at i-print ang na-update na naka-link na listahan. Sa wakas, aalisin namin ang unang elemento sa listahan at i-print muli ang na-update na naka-link na listahan upang makitang wala na sa listahan ang tinanggal na elemento.

HashSet

Ang java.util.HashSet na klase sa Java Collection Framework ay ginagamit upang mag-imbak ng isang koleksyon ng mga natatanging elemento sa isang set. Nagbibigay ito ng hash table-based na pagpapatupad ng interface ng java.util.Set . Nagbibigay din ito ng mabilis na pagpasok, pagtanggal at paghahanap, ngunit hindi pinapanatili ang pagkakasunud-sunod ng mga elemento nito. Nasa ibaba ang isang halimbawa ng paggamit ng klase ng HashSet sa Java Collection Framework:

// Создаем hash set
Set<String> set = new HashSet<>();

// Добавляем элементы в hash set
set.add("rose");
set.add("lily");
set.add("lotus");
// Попытка добавить повторяющийся элемент
set.add("rose");
// Печатаем hash set
System.out.println("Hash set: " + set);
// Удаляем элемент из hash set
set.remove("lily");
// Печать обновленного hash set
System.out.println("Hash set: " + set);

Dito lumikha kami ng isang hash set ng mga string at nagdagdag ng tatlong elemento dito: "rosas", "lily" at "lotus". Susubukan naming idagdag muli ang elementong "rosas", ngunit dahil hindi pinapayagan ng hash set ang mga duplicate, hindi ito idadagdag. Pagkatapos nito, ipi-print namin ang hash set para makita ang kasalukuyang estado nito. Pagkatapos ay aalisin namin ang elementong "lily" mula sa set at i-print ang na-update na hash ng set upang makita na ang tinanggal na elemento ay wala na sa set.

TreeSet

Ang java.util.TreeSet na klase sa Java Collection Framework ay ginagamit upang mag-imbak ng isang koleksyon ng mga natatanging elemento sa isang set na pinagsunod-sunod sa pataas na pagkakasunud-sunod. Nagbibigay ito ng tree-based na pagpapatupad ng java.util.Set interface upang mag-imbak ng mga elemento nang hindi pinapayagan ang mga duplicate na elemento. Nagbibigay ang klase ng mabilis na pagpasok, pagtanggal, at paghahanap, at pinapanatili ang pagkakasunud-sunod ng mga elemento nito ayon sa kanilang natural na pagkakasunud-sunod o comparator. Narito ang isang halimbawa kung paano gamitin ang klase ng TreeSet sa Java Collection Framework:

// Создаем tree set
Set<String> set = new TreeSet<>();

// Добавляем элементы в tree set
set.add("apple");
set.add("banana");
set.add("orange");
// Попытка добавить повторяющийся элемент
set.add("apple");
// Печатаем tree set
System.out.println("Tree set: " + set);
// Удаляем элемент из tree set
set.remove("banana");
// Печатаем обновленный tree set
System.out.println("Tree set: " + set);

Sa halimbawang ito, lumikha kami ng isang punong hanay ng mga string at magdagdag ng tatlong elemento dito: "mansanas", "saging" at "kahel". Susubukan naming idagdag muli ang elemento ng "mansanas", ngunit dahil hindi pinapayagan ng tree set ang mga duplicate, hindi ito idaragdag. Pagkatapos nito, ipi-print namin ang set ng puno upang makita ang kasalukuyang estado nito. Dahil ang hanay ng puno ay pinagsunod-sunod sa pataas na pagkakasunud-sunod, ang mga elemento ay ipi-print sa pagkakasunud-sunod: "mansanas", "saging" at "kahel". Pagkatapos ay aalisin namin ang elementong "saging" mula sa set at i-print ang na-update na hanay ng puno upang makita na ang tinanggal na elemento ay wala na sa hanay.

HashMap

Ang java.util.HashMap na klase sa Java Collection Framework ay ginagamit upang iimbak ang pagmamapa ng mga susi sa mga halaga sa isang mapa. Nagbibigay ito ng hash table-based na pagpapatupad ng java.util.Map interface at nagbibigay-daan sa mga elemento na maimbak bilang key-value pairs. Nagbibigay ang klase ng mabilis na pagpasok, pagtanggal, at paghahanap, ngunit hindi pinapanatili ang pagkakasunud-sunod ng mga elemento nito. Narito ang isang halimbawa kung paano gamitin ang klase ng HashMap sa Java Collection Framework:

// Создаем hash map
Map<String, Integer> map = new HashMap<>();

// Добавляем элементы в hash map
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);
// Печатаем hash map
System.out.println("Hash map: " + map);
// Получаем meaning для определенного ключа
int value = map.get("banana");
System.out.println("Value for 'banana': " + value);
// Удаляем элемент из hash map
map.remove("orange");
// Печатаем обновленный hash map
System.out.println("Hash map: " + map);

Sa halimbawang ito, gumawa kami ng hash map ng mga integer string at magdagdag ng tatlong elemento dito: "apple" na mga tugma 1, "banana" na mga tugma 2, at "orange" na mga tugma 3. Pagkatapos ay i-print namin ang hash na mapa upang makita ito Kasalukuyang estado. Pagkatapos nito, nakukuha namin ang halaga ng "saging" key at i-print ito sa console. Panghuli, inalis namin ang key-value pair para sa "orange" sa hash map at i-print ang na-update na hash map para makitang wala na rito ang inalis na elemento.

Konklusyon

Ang Java Collection Framework ay isang hanay ng mga klase at interface na nagbibigay ng karaniwang paraan upang kumatawan at magmanipula ng mga koleksyon ng mga bagay sa Java programming language. Nagbibigay-daan ito sa mga developer/tester na magtrabaho kasama ang mga koleksyon ng mga bagay sa pare-pareho at mahusay na paraan. Ang framework ay nagbibigay sa kanila ng mga paraan upang mag-imbak, mag-access, at pamahalaan ang mga item sa isang koleksyon, at nagbibigay-daan sa kanila na madaling lumipat sa pagitan ng iba't ibang mga pagpapatupad ng koleksyon depende sa mga kinakailangan ng application.