Listahan ng Java

Ang Java Collection Framework ay naglalaman ng napakakapaki-pakinabang na mga interface at mga klase na nagpapatupad ng mga ito para sa pagtatrabaho sa mga istruktura ng data. Masasabing isa ito sa pinakamahalagang balangkas ng JDK. Ang interface ng Listahan ay napakapopular. dahil walang lahat ng uri ng mga listahan sa programming ito ay lubhang kailangan. Sa artikulong ito, tatalakayin namin ang interface na ito, mga pamamaraan at pagpapatupad ng Listahan ng Java.

Interface ng Listahan ng Java

Ang pinakamahalagang bagay tungkol sa isang listahan ay ito ay isang nakaayos na koleksyon. Maaari mo ring tawaging isang pagkakasunud-sunod. Sa Java, ang mga listahan ay homogenous, iyon ay, ang mga elemento ng listahan ay may parehong uri ng data. Ang interface ng Java List ay namamana mula sa Collection, namamana nito ang lahat ng mga operasyon nito. Bilang karagdagan sa mga ito, ang mga sumusunod na operasyon ay posible rin sa Listahan:

• Posisyonal na pag-access. Ang bawat elemento ay may index at maaaring manipulahin batay sa kanilang posisyon. sa listahan. Ibig sabihin, maaari kang magdagdag, magbukod at magbago ng mga elemento.
• Maghanap. Makakahanap ka ng elemento sa isang listahan ayon sa nilalaman nito at ibalik ang index nito.
• Pag-ulit. Ang sunud-sunod na katangian ng Listahan ay nagbibigay-daan sa paggamit ng mga pamamaraan ng pag-ulit (listIterator).
• Range-view. Ang paraan ng sublist ay nagsasagawa ng mga arbitrary na operasyon ng hanay sa listahan.

Mga Paraan ng Listahan ng Java

Ang mga operasyon sa itaas ay nakalantad sa mga pamamaraan ng interface ng Listahan ng Java. Narito ang ilan sa mga ito:

Pagpapatupad ng listahan

Dahil ang Listahan ay isang interface, ang mga programa ay kailangang lumikha ng isang kongkretong pagpapatupad nito. Maaari kang pumili sa pagitan ng mga sumusunod na pagpapatupad ng Listahan sa Java Collections API:

• java.util.ArrayList
• java.util.LinkedList
• java.util.Vector
• java.util.Stack

Ang pinakasikat na pagpapatupad ng interface ng Listahan na tinatawag na ArrayList. Mas madalas, ngunit makikita mo pa rin ang paggamit ng LinkedList sa mga totoong gawain, ngunit ang Vector at Stack ay naging lipas na sa moral sa loob ng mahabang panahon, kaya malamang na mahahanap mo lamang ang mga ito sa mga proyektong may sinaunang legacy code.

Listahan ng Interface Deklarasyon

Maaari kang magdeklara ng isang List in Java program sa isa sa mga sumusunod na paraan:

List<String> myList = new ArrayList();
List myList1 = new ArrayList();
List myList3 = new ArrayList<String>();
ArrayList arrayList = new ArrayList();

Pinakamainam na magdeklara ng bagong listahan sa pamamagitan ng isang interface. Katulad nito, maaari mong ideklara ang iba pang mga pagpapatupad ng Listahan. Ang pinakamaikling paraan:

Vector myVector = new Vector;
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();

Sa ganoong deklarasyon, ang uri ng data ng mga elemento ng naturang mga listahan ay tinutukoy sa panahon ng pagsisimula ng listahan, iyon ay, kapag ang mga elemento ay idinagdag doon.

List myList = new ArrayList<String>();
Vector myVector = new Vector();
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();
stack.add("Paul");
linkedList.add(1);
myVector.add(1.2f);
myList.add('a');

Ngayon ay mga string na lang ang maaaring idagdag sa aming stack, mga integer sa linkedList , floats sa myVector , at ang myList ay isang listahan ng mga character.

Paano gumagana ang ArrayList

Kung pamilyar ka na sa mga regular na array, medyo pamilyar ka rin sa ArrayList. Sa katunayan, ang ArrayList ay isang dynamic na array, at sa loob nito ay isang ordinaryong array. Ang array na ito ay gumaganap bilang isang data store. Ang ArrayList ay nag-iimbak lamang ng mga uri ng sanggunian, anumang mga bagay, kabilang ang mga third-party na klase, string, output stream, at iba pang mga koleksyon. Ginagamit ang mga klase ng wrapper upang mag-imbak ng mga primitive na uri ng data sa ArrayList. Kapag gumagawa ng isang listahan, maaari naming agad na itakda ang laki nito, ngunit sa karamihan ng mga kaso hindi namin ginagawa. Bilang default, laki ng ArrayList = 10. Ano ang hitsura ng pagdaragdag ng bagong elemento sa isang ArrayList? Una sa lahat, sinisimulan ang pagsusuri upang makita kung may sapat na espasyo sa panloob na hanay at kung magkasya ang isa pang elemento. Kung mayroong espasyo, ang bagong elemento ay idaragdag sa dulo ng listahan, iyon ay, sa cell na sumusunod sa huling elemento. Ang index nito ay arraylist.size(). Kung nilikha lang namin ang aming listahan at ito ay walang laman, nangangahulugan ito na arrayList.size() = 0. Alinsunod dito, isang bagong elemento ang idadagdag sa cell na may index 0. Kung ito ay lumabas na walang sapat na espasyo, isang bagong Ang array ay nilikha sa loob ng ArrayList na may sukat (ang laki ng OldArray * 1.5) + 1. Sa parehong prinsipyo, ang isang pagpasok ay nangyayari sa gitna ng listahan, ngunit sa parehong oras, ang lahat ng mga elemento na sumusunod sa ipinasok na elemento ay inilipat sa kanan. Kaya, kung mayroon tayong 5 elemento sa array, at kailangan nating magpasok ng isang elemento sa cell number 2 (iyon ay, ang pangatlo), pagkatapos ay mananatili ang 0 at 1 array elements sa lugar, isang bagong elemento ang lilitaw sa cell 2, at ang hinalinhan nito ay napupunta sa ikatlong cell at iba pa. isang bagong elemento ang idadagdag sa cell na may index 0. Kung ito ay lumabas na walang sapat na espasyo, isang bagong array ay nilikha sa loob ng ArrayList na may laki (ang laki ng OldArray * 1.5) + 1. Sa parehong prinsipyo, ang isang pagpapasok ay nangyayari sa gitna ng listahan, ngunit sa parehong oras, ang lahat ng mga elemento na sumusunod sa ipinasok na elemento ay inilipat sa kanan. Kaya, kung mayroon tayong 5 elemento sa array, at kailangan nating magpasok ng isang elemento sa cell number 2 (iyon ay, ang pangatlo), pagkatapos ay mananatili ang 0 at 1 array elements sa lugar, isang bagong elemento ang lilitaw sa cell 2, at ang hinalinhan nito ay napupunta sa ikatlong cell at iba pa. isang bagong elemento ang idadagdag sa cell na may index 0. Kung ito ay lumabas na walang sapat na espasyo, isang bagong array ay nilikha sa loob ng ArrayList na may laki (ang laki ng OldArray * 1.5) + 1. Sa parehong prinsipyo, ang isang pagpapasok ay nangyayari sa gitna ng listahan, ngunit sa parehong oras, ang lahat ng mga elemento na sumusunod sa ipinasok na elemento ay inilipat sa kanan. Kaya, kung mayroon tayong 5 elemento sa array, at kailangan nating magpasok ng isang elemento sa cell number 2 (iyon ay, ang pangatlo), pagkatapos ay mananatili ang 0 at 1 array elements sa lugar, isang bagong elemento ang lilitaw sa cell 2, at ang hinalinhan nito ay napupunta sa ikatlong cell at iba pa. ang isang pagpasok ay nangyayari sa gitna ng listahan, ngunit sa parehong oras, ang lahat ng mga elemento na sumusunod sa ipinasok na elemento ay inilipat sa kanan. Kaya, kung mayroon tayong 5 elemento sa array, at kailangan nating magpasok ng isang elemento sa cell number 2 (iyon ay, ang pangatlo), pagkatapos ay mananatili ang 0 at 1 array elements sa lugar, isang bagong elemento ang lilitaw sa cell 2, at ang hinalinhan nito ay napupunta sa ikatlong cell at iba pa. ang isang pagpasok ay nangyayari sa gitna ng listahan, ngunit sa parehong oras, ang lahat ng mga elemento na sumusunod sa ipinasok na elemento ay inilipat sa kanan. Kaya, kung mayroon tayong 5 elemento sa array, at kailangan nating magpasok ng isang elemento sa cell number 2 (iyon ay, ang pangatlo), pagkatapos ay mananatili ang 0 at 1 array elements sa lugar, isang bagong elemento ang lilitaw sa cell 2, at ang hinalinhan nito ay napupunta sa ikatlong cell at iba pa.

Halimbawa ng Listahan ng Java (Pagsasakatuparan ng Arraylist)

import java.util.*;

public class ArrayListExample2 {
   public static void main(String[] args) {
       List<String> myFriendsList = new ArrayList();
       //we created list of some objects 
       System.out.println( "the size of myList before init = " + myFriendsList.size());
       myFriendsList.add("Alex");
       myFriendsList.add("Tanya");
       myFriendsList.add("Veloxy");
       myFriendsList.add("Alex");
       myFriendsList.add("Andrew");
       System.out.println(myFriendsList);
       System.out.println( "the size of myList after init = " + myFriendsList.size());

       myFriendsList.add("Ihor");
       System.out.println(myFriendsList);
       System.out.println("the size of my list = " +  myFriendsList.size());


       //here the program will print out the first appearance of "Alex" element
       System.out.println(myFriendsList.indexOf("Alex"));
       //program will print out the first appearance of "Alex" element starting from the element 0

       myFriendsList.remove(3);
       System.out.println(myFriendsList.get(3));
       System.out.println("after removing one of Alex's there is only one Alex: " + myFriendsList);
       System.out.println(myFriendsList.get(1));



       myFriendsList.clear();
       System.out.println("the size of the vector after clear method = " +  myFriendsList.size());

   }
}

Narito ang output ng program na ito:

Paano gumagana ang LinkList

Sa isang LinkedList, ang mga elemento ay talagang mga link sa parehong chain. Ang bawat elemento, bilang karagdagan sa data na iniimbak nito, ay may link sa nakaraan at susunod na elemento. Nagbibigay-daan sa iyo ang mga link na ito na mag-navigate mula sa isang elemento patungo sa isa pa. Sinusuportahan ng iterator ang traversal sa parehong direksyon. Nagpapatupad ng mga paraan para sa pagkuha, pag-alis, at pagpasok sa simula, gitna, at dulo ng isang listahan. Binibigyang-daan kang magdagdag ng anumang elemento kabilang ang null. Ang LinkedList ay nagpapatupad ng dalawang interface — hindi lamang Listahan, kundi pati na rin ang Deque. Nagbibigay ito ng kakayahang lumikha ng bidirectional queue mula sa anumang elemento, kahit null. Ang bawat bagay na inilagay sa naka-link na listahan ay isang node (node). Ang bawat node ay naglalaman ng isang elemento, isang link sa nakaraan at susunod na node. Sa katunayan, ang naka-link na listahan ay binubuo ng isang pagkakasunud-sunod ng mga node, na ang bawat isa ay idinisenyo upang mag-imbak ng isang bagay ng uri na tinukoy noong ito ay nilikha.

Halimbawa ng Code

import java.util.*;
public class LinkedListTest {

       public static void main(String args[]){

           List myLinkedList= new LinkedList<Integer>();
           myLinkedList.add(1);
           myLinkedList.add(2);
           myLinkedList.add(4);
           System.out.println("three added elements: " + myLinkedList);
           myLinkedList.add(5);
           myLinkedList.remove(1);
           System.out.println(myLinkedList);
           myLinkedList.size(); //3
           
           //add new element at the specified position:
           myLinkedList.add(2,7);
           System.out.println(myLinkedList);
                }
       }

Ang output ay narito:

Halimbawa ng Vector Code

Ang Vector ay isa ring dynamic na pagsasakatuparan ng array at halos kapareho sa ArrayList, ngunit naka-synchronize at may ilang legacy na pamamaraan na hindi naglalaman ng framework ng koleksyon. Narito ang isang simpleng halimbawa ng paggamit ng klase na ito.

import java.util.Vector;

public class VectorExample1 {

   public static void main(String[] args) {
       Vector vector = new Vector();
       System.out.println("the size of the empty vector = " +  vector.size());
       vector.add("Alex");
       vector.add("Tanya");
       vector.add("Andrew");
       System.out.println(vector);
       vector.add("Alex");
       vector.add("Ihor");
       System.out.println(vector);
       System.out.println("the size of the vector = " +  vector.size());
       System.out.println("the first element of the vector = " + vector.firstElement());

       //here the program will print out the first appearance of "Johnny" element
       System.out.println(vector.indexOf("Andrew"));
       //program will print out the first appearance of "Johnny" element starting from the element 1
       System.out.println(vector.indexOf("Alex", 1));
       System.out.println(vector);
       vector.clear();
       System.out.println("the size of the vector after clear method = " +  vector.size());

   }
}

Ang output ay:

Halimbawa ng Java Stack class code

import java.util.Stack;

public class StackTest {
   public static void main(String[] args) {
       Stack stack = new Stack();
       System.out.println(stack.isEmpty());
       stack.add("Paul");
       stack.add("Johnny");
       stack.add("Alex");
       System.out.println(stack.isEmpty());
       stack.push("Andrew");
       System.out.println(stack);
       stack.pop();
       System.out.println(stack);
   }
}

Ang stack ay hindi lamang add() at remove() na mga pamamaraan kundi pati na rin ang push at pop, ang mga ito ay klasikal para sa naturang istruktura ng data. Sumusunod ang stack sa panuntunang “first in, last out” — isa itong anti-queue. Samakatuwid, pina-pop ng pop operation ang elementong huling inilagay sa stack. Narito ang output ng aming halimbawa: