Pamamaraan ng Sublist() sa Java: ArrayList at Listahan

Ano ang subList() na pamamaraan?

Ang Collections Framework ay isang napaka-tanyag na bahagi sa Java API. Ang interface ng listahan at klase ng ArrayList ay marahil ang pinakamahalagang tool sa Framework ng Mga Koleksyon. Ang subList ay isang paraan sa interface ng Listahan na nagbibigay-daan sa iyong lumikha ng isang bagong listahan mula sa isang bahagi ng isang umiiral na listahan. Gayunpaman, ang bagong likhang listahang ito ay isang view lamang na may reference sa orihinal na listahan. Halimbawa, kunin ang listahan ng [1,2,3,4,5,6]. Ipagpalagay na gusto mong lumikha ng isang bagong listahan nang wala ang una at huling mga elemento. Sa ganitong sitwasyon, ang list.subList() na paraan ay makakatulong sa iyo. Ang subList(fromIndex, toIndex) na pamamaraan ay may isang anyo lamang at nangangailangan ito ng dalawang argumento, na kung saan ay ang unang index (mula saIndex) at ang huling index(saIndex) . Ibabalik nito ang bahagi sa pagitan ng fromIndex at toIndex bilang isang bagong listahan. May mahalagang puntong dapat tandaan. Isasama sa bagong likhang listahan ang fromIndex at ibubukod ang toIndex. Kaya ang algorithm para sa senaryo sa itaas ay magiging katulad nito. List = [1,2,3,4,5,6] newList = List.subList(1,5) Dahil ang subList ay isang paraan ng List interface, magagamit mo ito sa ArrayList, LinkedList, Stack, at Vector objects. Gayunpaman, sa artikulong ito, pangunahing tututuon namin ang mga bagay na ArrayList at LinkedList.

Halimbawa ng subList na paraan sa isang ArrayList object.

Nagdedeklara kami ng ArrayList ng mga bansa. Pagkatapos ay sinubukan naming ibalik ang bahagi sa pagitan ng ika-2 at ika-4 na elemento.

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
         // create an ArrayList 
        ArrayList list = new ArrayList();
         // add values to ArrayList
         list.add("USA");
         list.add("UK");
         list.add("France");
         list.add("Germany");
         list.add("Russia");
        System.out.println("List of the countries:" + list);
         //Return the subList : 1 inclusive and 3 exclusive
        ArrayList new_list = new  ArrayList(list.subList(1, 3));
        System.out.println("The subList of the list: "+new_list);
    }
 }

Ang output ng code sa itaas ay magiging Sa isang ArrayList, ang index value ng unang elemento ay 0. Samakatuwid, ang index value ng pangalawa at ikaapat na elemento ay 1 at 3 ayon sa pagkakabanggit. Kaya, ginagamit namin ang sublist() method bilang list.subList(1, 3) . Gayunpaman, tandaan na ibinabalik ng subList na paraan ang bahagi na hindi kasama ang toIndex na siyang pang-apat na elemento (“Germany”) sa kasong ito. Kaya ito ay maglalabas ng "UK" at "France" lamang. Dahil ang ibinalik na output ay isang Listahan mismo, maaari mong tawagan ang anumang mga pamamaraan ng Listahan nang direkta dito. Kaya ano ang mangyayari kung gagamitin natin ang parehong index para sa parehong mga parameter? Isasama ba o ibubukod ang index na iyon sa ibinalik na listahan? Alamin Natin.

//execute subList() method with the same argument for both parameters.
ArrayList new_list2 = new ArrayList(list.subList(3, 3));
System.out.println("The subList of the list: "+new_list2);

Ang Output ay Ang output ay isang walang laman na listahan. Kahit na pinili ng fromIndex ang ika-4 na elemento, aalisin ito ng subList() na pamamaraan dahil ito rin ang toIndex.

Halimbawa ng paraan ng subList sa isang object ng LinkList.

Sa halimbawang ito, gagamitin namin ang paraan ng sublist sa isang elemento ng LinkList. Muli, Ibabalik nito ang listahan sa pagitan ng tinukoy na index fromIndex(inclusive) at toIndex(exclusive) . Tandaan na sinabi namin na ang listahan na ibinalik ng subList() na pamamaraan ay isang view lamang na may reference sa orihinal na listahan. Kung gumawa ka ng anumang mga pagbabago sa sublist, makakaapekto rin ito sa orihinal na listahan. Susubukan din natin iyan sa halimbawang ito.

import java.util.LinkedList;
import java.util.Iterator;
import java.util.List;
 
public class Main {
 
 public static void main(String[] args) {
 
    // Create a LinkedList
    LinkedList linkedlist = new LinkedList();
 
    // Add elements to LinkedList
    for(int i = 0; i<7; i++){
      linkedlist.add("Node "+ (i+1));
    }
 
    // Displaying LinkedList elements
    System.out.println("Elements of the LinkedList:");
    Iterator it= linkedlist.iterator();
    while(it.hasNext()){
       System.out.print(it.next()+ " ");
    }
 
    // invoke subList() method on the linkedList
    List sublist = linkedlist.subList(2,5);
 
    // Displaying SubList elements
    System.out.println("\nElements of the sublist:");
    Iterator subit= sublist.iterator();
    while(subit.hasNext()){
       System.out.print(subit.next()+" ");
    }
 
    /* The changes you made to the sublist will affect the     original LinkedList
     * Let’s take this example - We
     * will remove the element "Node 4" from the sublist.
     * Then we will print the original LinkedList. 
     * Node 4 will not be in the original LinkedList too. 
     */
    sublist.remove("Node 4");
    System.out.println("\nElements of the LinkedList LinkedList After removing Node 4:");
    Iterator it2= linkedlist.iterator();
    while(it2.hasNext()){
       System.out.print(it2.next()+" ");
    }
 }
}

Ang output ay magiging ganito:

Ano ang mangyayari kung ang mga index ay hindi nakagapos sa subList()?

Ang paraan ng subList ay nagbabalik ng dalawang uri ng mga pagbubukod. Tingnan natin sila. Isaalang-alang ang isang sitwasyon kung ang mga tinukoy na index ay wala sa saklaw ng elemento ng Listahan (mula saIndex < 0 || toIndex > size) . Pagkatapos ay magtapon ito ng IndexOutOfBoundExecption .

//using subList() method with fromIndex <0 
ArrayList new_list2 = new ArrayList(list.subList(-1, 3));
System.out.println("Portion of the list: "+new_list2);
 
Exception in thread "main" java.lang.IndexOutOfBoundsException: fromIndex = -1
 
// using subList() method with toIndex > size
ArrayList new_list2 = new ArrayList(list.subList(3, 6));
System.out.println("Portion of the list: "+new_list2);
 
Exception in thread "main" java.lang.IndexOutOfBoundsException: toIndex = 6

Gayundin, kung ang fromIndex ay mas malaki kaysa sa toIndex (fromIndex > toIndex) , ang subList() na paraan ay naghagis ng IllegalArgumentException na error.

//If fromIndex > toIndex
ArrayList new_list2 = new ArrayList(list.subList(5, 3));
System.out.println("Portion of the list: "+new_list2);
 
Exception in thread "main" java.lang.IllegalArgumentException: fromIndex(5) > toIndex(3)

Konklusyon

Sa artikulong ito, tinalakay namin ang paraan ng subList at kung paano ito gamitin. Ang subList() na pamamaraan ay nag-aalis ng pangangailangan para sa tahasang hanay ng mga operasyon (Ito ay isang uri ng mga operasyon na karaniwang umiiral para sa mga array). Ang pinakamahalagang bagay na dapat tandaan ay ang subList na paraan ay hindi nagbabalik ng bagong instance ngunit isang view na may reference sa orihinal na listahan. Samakatuwid, ang sobrang paggamit ng subList na paraan sa parehong listahan ay maaaring magdulot ng thread na natigil sa iyong Java application.