Mga koleksyon sa Java

Ano ang Koleksyon sa Java?

Ang isang koleksyon sa java ay kinakatawan bilang isang lalagyan na nagpapangkat sa lahat ng mga elemento sa isang yunit. Halimbawa , isang mail folder (pangkat ng mga email), isang direktoryo ng telepono (pagma-map ng mga pangalan sa mga numero ng telepono).

Ano ang isang Framework?

Ang balangkas ay isang pangunahing pundasyon o layout kung saan ka magsisimulang magtrabaho sa pamamagitan ng paggamit ng iba't ibang klase at interface na ibinigay. Halimbawa , ang Laravel ay isa sa pinakasikat na PHP frameworks na nagbibigay ng basic skeleton para sa iyong application.

Ano ang Collections Framework sa Java?

Ang lahat ng mga bagay ay pinagsama-sama sa isang solong bagay kasama ng isang arkitektura na kumakatawan at nagbibigay ng iba't ibang mga pamamaraan para sa pagmamanipula ng mga koleksyon. Kaya ang balangkas ng Collections sa Java ay nagbibigay ng iba't ibang istruktura ng data na ipinatupad na para sa pag-iimbak ng data at mga pamamaraan, upang manipulahin ang mga ito gamit ang mga tampok tulad ng pag-uuri, paghahanap, pagtanggal, at pagpasok . Halimbawa , gusto mong magpatupad ng system para sa ilang random na kumpanya upang mapabuti ang serbisyo para sa kanilang mga customer, batay sa first come first serve basis. Ito ay kilala rin bilang pagpapatupad ng FIFO (first in first out). Ngayon ay kailangan naming ipatupad ang istruktura ng data na ito at pagkatapos ay gamitin ito upang makamit ang aming layunin. Ang balangkas ng Mga Koleksyon ay nagbibigay sa amin ng interface ng Queue na kailangan lang naming i-import sa halip na ipatupad, pagkatapos ay gamitin ito, at tapos na kami. Pagpapatupad : Maaari mong i-import ang lahat ng mga koleksyon sa pamamagitan ng paggamit ng sumusunod na linya:

import java.util.*;

Kung gusto mong mag-import ng isang partikular na koleksyon pagkatapos ay gamitin ang eksaktong pangalan ng package, tulad ng:

import java.util.LinkedList;

Mga Benepisyo ng Collections Framework sa Java

Ito ay may mga sumusunod na benepisyo.

1. Naipatupad na (nagtitipid sa oras).
2. Performance Efficiency (bilis at kalidad).
3. Binabawasan ang pagsisikap na matuto at gumamit ng mga bagong API.

Ano ang Hierarchy ng Collection Framework?

Ngayon tingnan natin ang hierarchy ng mga koleksyon ngunit una, kailangan nating malaman ang mahahalagang bahagi ng balangkas na ito.

1. Mga interface
2. Mga klase (pagpapatupad)
3. Mga algorithm

Hierarchy ng Collection Framework

Para sa iyong pang-unawa:

1. Ang Collection, Set, Queue, at List lahat ay mga interface. Ang Set, Queue at List ay pinalawak ng interface ng Collection.
2. Ang PriorityQueue, HashSet, LinkedList, at Stack lahat ay mga klase o ang pagpapatupad ng mga interface na ito.
3. Hindi sapilitan na ang isang klase ay nagpapatupad lamang ng isang interface. Ipinapatupad din ng LinkList ang interface ng Deque, halimbawa.

Mga Uri ng Koleksyon

Ang balangkas ng mga koleksyon ng Java ay mayroong maraming uri ng mga koleksyon dito upang bawasan ang aming mga pagsisikap. Narito ang isang listahan ng ilan sa mga koleksyon:

1. Klase ng ArrayList
2. Klase ng LinkedList
3. Interface ng Listahan
4. Itakda ang Interface
5. Interface ng Queue
6. Interface ng Mapa
7. PriorityQueue Class
8. Klase ng HashMap
9. Maihahambing na Interface
10. Klase ng LinkedHashMap
11. Klase ng TreeMap
12. HashTable

Mga Interface ng Koleksyon

Dito tatalakayin natin ang ilang karaniwang mga interface ng koleksyon at pagkatapos ay ang ilang mga pamamaraan na ipinatupad ng mga klase.

Interface ng Koleksyon

Ito ay isang pangunahing pundasyon para sa balangkas ng Mga Koleksyon dahil nagbibigay ito ng lahat ng kinakailangang pamamaraan para sa pagpapatupad. Ang Map ay ang tanging istraktura ng data na hindi nagpapatupad nito ngunit ang natitirang lahat ay nagpapatupad ng mga pamamaraan nito. Ang interface na ito ay may mga pamamaraan para sa pag-alam sa laki ng koleksyon, at kung mayroong isang bagay sa koleksyon, pagdaragdag o pag-alis ng mga bagay mula sa koleksyon.

Iterable Interface

Ito ang root interface para sa balangkas ng Collections dahil pinalawak ito ng interface ng Collection na ipinapatupad ng lahat ng klase. Nagbabalik ito ng iterator para sa partikular na koleksyon upang umulit dito.

Interface ng Queue

Ang queue ay ginagamit upang hawakan ang mga elemento ngunit hindi sila maproseso. Ang pagpapatupad ng mga pangunahing operasyon sa pagkolekta, nagbibigay din ito ng karagdagang mga paraan ng pagpasok at pagkuha.

Itakda ang Interface

Ginagamit ang set para hawakan ang mga natatanging elemento dito. Ito ay hindi kailanman naglalaman ng mga duplicate na elemento at modelo ng mathematical set abstraction upang kumatawan sa mga set tulad ng mga prosesong tumatakbo sa isang makina.

Interface ng Listahan

Ang listahan ay isang nakaayos na koleksyon kung minsan ay tinatawag na sequence na maaaring maglaman ng mga duplicate na elemento dito. Nagbibigay ito ng kontrol sa user para sa pag-update o pag-alis ng isang partikular na elemento, pagpasok ng isang elemento sa isang partikular na punto sa pamamagitan ng paggamit ng integer index value nito. Ang LinkedList at ArrayList ay mga klase ng pagpapatupad ng interface ng Listahan.

Deque Interface

Ang Deque ay kumakatawan sa double-ended queue na nangangahulugan na maaari tayong magsagawa ng mga operasyon sa magkabilang dulo. Maaari naming ipasok at alisin ang mga elemento mula sa magkabilang dulo. Pinapalawak ng interface ng Deque ang interface ng pila. Ang ArrayDeque at LinkedList ay parehong nagpapatupad ng Deque interface. Nagbibigay ito ng mga pamamaraan para sa pagpasok, pagtanggal, at pagsusuri sa instance mula sa magkabilang dulo.

Interface ng Mapa

Ang interface ng mapa ay bahagi rin ng balangkas ng Mga Koleksyon ngunit hindi nito pinahaba ang interface ng Koleksyon. Ginagamit ito upang mag-imbak ng mga pares ng key-value. Ang mga pangunahing pagpapatupad nito ay HashMap, TreeMap, at LinkesHashMap na katulad sa ilang aspeto sa HashSet, TreeSet, at LinkedHashSet. Palagi itong naglalaman ng mga natatanging key ngunit maaaring madoble ang mga halaga. Ito ay kapaki-pakinabang kapag kailangan mong magdagdag, magtanggal, o maghanap ng isang item batay sa isang susi. Nagbibigay ito sa amin ng mga pangunahing pamamaraan tulad ng put , get , remove , size , empty , at iba pa.

Mga Karaniwang Paraan ng Mga Interface na ito

Ngayon ay titingnan natin ang ilang karaniwang pamamaraan na ibinigay para sa pagpapatupad ng iba't ibang klase sa balangkas na ito maliban sa interface ng Map.

Mga Klase sa Koleksyon

Tulad ng alam natin na ang balangkas ay may iba't ibang mga interface na ipinatupad ng maraming mga klase sa loob nito. Ngayon tingnan natin ang ilang karaniwang ginagamit na mga klase.

LinkedList

Ito ang pinakakaraniwang ginagamit na istraktura ng data na nagpapatupad ng dobleng naka-link na listahan upang iimbak ang mga elemento sa loob nito. Maaari itong mag-imbak ng mga dobleng elemento. Ipinapatupad nito ang interface ng Dequeue na pinalawig ng interface ng Queue at ang interface ng Listahan. Hindi ito naka-synchronize. Ngayon tingnan natin kung paano lutasin ang ating problemang tinalakay sa itaas (ang konsepto ng FIFO) gamit ang LinkedList. Ang problema ay upang pagsilbihan ang mga customer sa paraang dumating sila ie unang in first out .

Halimbawa

import java.util.*;

public class LinkedListExample {
    public static void main(String[] args) {
        Queue<String> customerQueue = new LinkedList<String>();
        //Adding customers to the Queue as they arrived
        customerQueue.add("John");
        customerQueue.add("Angelina");
        customerQueue.add("Brooke");
        customerQueue.add("Maxwell");

        System.out.println("Customers in Queue:"+customerQueue);
        //element() => returns head of the queue
        //we will see our first customer and serve him
        System.out.println("Head of the queue i.e first customer: "+customerQueue.element());
        //remove () method =>removes first element(customer) from the queue i.e the customer is served so remove him to see next
        System.out.println("Element removed from the queue: "+customerQueue.remove());
        //poll () => removes and returns the head
        System.out.println("Poll():Returned Head of the queue: "+customerQueue.poll());
        //print the remaining customers in the Queue
        System.out.println("Final Queue:"+customerQueue);
    }
}

Output

ArrayList

Ipinapatupad lamang nito ang interface ng Listahan. Pinapanatili nito ang pagkakasunud-sunod ng pagpapasok at gumagamit ng isang dynamic na array upang mag-imbak ng mga elemento ng iba't ibang uri ng data. Maaaring i-duplicate ang mga elemento. Hindi rin ito naka-synchronize at maaaring mag-imbak ng mga null value. Ngayon tingnan natin ang iba't ibang pamamaraan nito... Ito ay kapaki-pakinabang kapag hindi natin alam kung gaano karaming mga tala o elemento ang kailangan nating ipasok. Kunin natin ang isang halimbawa ng isang silid-aklatan kung saan hindi natin alam kung gaano karaming mga libro ang dapat nating itago. Kaya sa tuwing mayroon tayong aklat, kailangan nating ipasok ito sa ArrayList.

Halimbawa

public class ArrayListExample {
	public static void main(String args[]) {

		// Creating the ArrayList
		ArrayList<String> books = new ArrayList<String>();

		// Adding a book to the list
		books.add("Absalom, Absalom!");
		// Adding a book in array list
		books.add("A Time to Kill");
		// Adding a book to the list
		books.add("The House of Mirth");
		// Adding a book to the list
		books.add("East of Eden");
		// Traversing the list through Iterator
		Iterator<String> itr = books.iterator();
		while (itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

Output

HashSet

Ipinapatupad nito ang Set interface at hindi kailanman naglalaman ng mga duplicate na halaga. Ipinapatupad nito ang hash table para sa pag-iimbak ng mga halaga. Pinapayagan din nito ang mga null na halaga. Hindi nito pinapanatili ang pagkakasunud-sunod ng pagpapasok ngunit nagbibigay ng patuloy na pagganap ng oras para sa pagdaragdag , pag-alis , laki , at naglalaman ng mga pamamaraan. Ito ay pinakamahusay para sa mga operasyon sa paghahanap at hindi ito naka-synchronize.

Halimbawa

import java.util.*;
class HashSetExample{
    public static void main(String args[]){
        //creating HashSet and adding elements to it
        HashSet<Integer> hashSet=new HashSet();
        hashSet.add(1);
        hashSet.add(5);
        hashSet.add(4);
        hashSet.add(3);
        hashSet.add(2);
        //getting an iterator for the collection
        Iterator<Integer> i=hashSet.iterator();
        //iterating over the value
        while(i.hasNext())  {
            System.out.println(i.next());
        }
    }
}

Output

Tulad ng nakikita mo, hindi nito pinapanatili ang pagkakasunud-sunod ng pagpapasok.

ArrayDeque

Ipinapatupad nito ang interface ng Deque kaya pinapayagan nito ang mga operasyon mula sa magkabilang dulo. Hindi nito pinapayagan ang mga null na halaga. Ito ay mas mabilis kaysa sa Stack at LinkedList kapag ipinatupad bilang Stack at LinkedList. Ang ArrayDeque ay walang mga paghihigpit sa laki habang ito ay lumalaki at lumiliit ayon sa mga kinakailangan. Ito ay hindi naka-synchronize, ibig sabihin ay hindi ito ligtas sa thread. Upang mapanatili itong ligtas sa thread, kailangan nating ipatupad ang ilang panlabas na lohika.

Halimbawa

import java.util.*;
public class ArrayDequeExample {
   public static void main(String[] args) {
       //creating Deque and adding elements
       Deque<String> deque = new ArrayDeque<String>();
       //adding an element
       deque.add("One");
       //adding an element at the start
       deque.addFirst("Two");
       //adding an element at the end
       deque.addLast("Three");
       //traversing elements of the collection
       for (String str : deque) {
            System.out.println(str);
       }
   }
}

Output

HashMap

Ito ay ang pagpapatupad ng interface ng Map na sinusuportahan ng hash table. Iniimbak nito ang mga pares ng key-value. Hindi nito pinapayagan ang mga null na halaga. Hindi ito naka-synchronize. Hindi nito ginagarantiyahan ang pagkakasunud-sunod ng pagpapasok. Nagbibigay ito ng patuloy na pagganap ng oras para sa mga pamamaraan tulad ng get , at put . Nakadepende ang pagganap nito sa dalawang salik — paunang kapasidad at salik ng pagkarga . Ang kapasidad ay ang bilang ng mga bucket sa hash table kaya ang paunang kapasidad ay ang bilang ng mga bucket na inilaan sa oras ng paggawa. Ang load factor ay ang sukatan kung gaano kalaki ang maaaring i-populate ng hash table bago tumaas ang kapasidad nito. Ang paraan ng rehash ay ginagamit upang madagdagan ang kapasidad at higit na doble nito ang bilang ng mga balde.

Halimbawa

import java.util.*;
public class HashMapExample{
    public static void main(String args[]){
        //creating a HashMap
        HashMap<Integer,String> map=new HashMap<Integer,String>();
        //putting elements into the map
        map.put(1,"England");
        map.put(2,"USA");
        map.put(3,"China");

        //get element at index 2
        System.out.println("Value at index 2 is: "+map.get(2));
        System.out.println("iterating map");
        //iterating the map
        for(Map.Entry m : map.entrySet()){
            System.out.println(m.getKey()+" "+m.getValue());
        }
    }
}

Output

Mga algorithm

Ang balangkas ng Mga Koleksyon ay nagbibigay sa amin ng iba't ibang mga algorithm para sa iba't ibang mga operasyon upang mailapat sa mga koleksyon. Dito ay titingnan natin kung aling mga pangunahing operasyon ang sakop ng mga algorithm na ito. Naglalaman ito ng mga algorithm na nauugnay sa:

1. Pag-uuri
2. Naghahanap
3. Balasahin
4. Karaniwang Pagmamanipula ng Data
5. Komposisyon
6. Paghahanap ng Extreme Values

Para sa mas mahusay na pag-unawa tatalakayin natin ang algorithm ng pag-uuri.

Pag-uuri

Inaayos muli ng algorithm ng pag-uuri ang isang listahan ayon sa isang relasyon sa pag-order. Dalawang anyo ng relasyon ang ibinigay.

1. Natural na Pag-order
2. Pag-order ng Paghahambing

Natural na Pag-order

Sa natural na pag-order ang isang listahan ay pinagsunod-sunod ayon sa mga elemento nito.

Pag-order ng Paghahambing

Sa ganitong paraan ng pag-order ng karagdagang parameter, na isang comparator, ay ipinasa kasama ng listahan. Ang isang bahagyang na-optimize na merge sort algorithm ay ginagamit para sa pag-uuri na mabilis at matatag dahil ginagarantiyahan nito ang oras ng pagtakbo ng n log(n) at hindi nito muling inaayos ang mga pantay na elemento. Gagamitin namin ang parehong halimbawa mula sa ArrayList upang ipakita ang pag-uuri.

Halimbawa

import java.util.*;
public class SortingExample{
    public static void main(String args[]){
        //Creating arraylist
        ArrayList<String> books=new ArrayList<String>();
        //Adding a book to the arraylist
        books.add("A Time to Kill");
        //Adding a book to the arraylist
        books.add("Absalom, Absalom!");
        //Adding a book to the arraylist
        books.add("The House of Mirth");
        //Adding a book to the arraylist
        books.add("East of Eden");
        //Traversing list through Iterator before sorting
        Iterator itrBeforeSort=books.iterator();
        while(itrBeforeSort.hasNext()){
            System.out.println(itrBeforeSort.next());
        }
        //sorting the books
        Collections.sort(books);
        System.out.println("After sorting the books");
        //Traversing list through Iterator after sorting
        Iterator itr=books.iterator();
        while(itr.hasNext()){
            System.out.println(itr.next());
        }
    }
}

Output

Konklusyon

Umaasa kami na sa ngayon ay naiintindihan mo na kung ano ang java collections framework, ano ang mga interface at klase nito at kung paano ipatupad ang iba't ibang klase nito. Maaari mong palaging gamitin ang balangkas na ito upang bawasan ang iyong mga pagsisikap sa Java. Huwag mag-atubiling magsanay at bumalik dito tuwing kailangan mo ng karagdagang tulong. Maligayang pag-aaral!