Kaedah Sublist() dalam Java: ArrayList dan Senarai

Apakah kaedah subList()?

Rangka Kerja Koleksi ialah komponen yang sangat popular dalam Java API. Antara muka senarai dan kelas ArrayList mungkin merupakan alatan yang paling penting dalam Rangka Kerja Koleksi. subList ialah kaedah dalam antara muka Senarai yang membolehkan anda membuat senarai baharu daripada sebahagian daripada senarai sedia ada. Walau bagaimanapun, senarai yang baru dibuat ini hanyalah paparan dengan rujukan kepada senarai asal. Contohnya ambil senarai [1,2,3,4,5,6]. Katakan anda ingin membuat senarai baharu tanpa elemen pertama dan terakhir. Dalam senario sedemikian, kaedah list.subList() akan membantu anda. kaedah subList(fromIndex, toIndex) hanya mempunyai satu bentuk dan memerlukan dua argumen, iaitu indeks pertama (fromIndex) dan indeks terakhir(kepadaIndex) . Ia akan mengembalikan bahagian antara fromIndex dan toIndex sebagai senarai baharu. Terdapat satu perkara penting yang perlu diingat. Senarai yang baru dibuat akan menyertakan fromIndex dan mengecualikan toIndex. Jadi algoritma untuk senario di atas akan menjadi seperti ini. List = [1,2,3,4,5,6] newList = List.subList(1,5) Memandangkan subList ialah kaedah antara muka Senarai, anda boleh menggunakannya pada objek ArrayList, LinkedList, Stack dan Vector. Walau bagaimanapun, dalam artikel ini, kami akan memberi tumpuan terutamanya pada objek ArrayList dan LinkedList.

Contoh kaedah subList pada objek ArrayList.

Kami mengisytiharkan ArrayList negara. Kemudian kami cuba mengembalikan bahagian antara elemen ke-2 dan ke-4.

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);
    }
 }

Output kod di atas adalah Dalam ArrayList, nilai indeks elemen pertama ialah 0. Oleh itu, nilai indeks elemen kedua dan keempat ialah 1 dan 3 masing-masing. Jadi, kami menggunakan kaedah sublist() sebagai list.subList(1, 3) . Walau bagaimanapun, ingat bahawa kaedah subList mengembalikan bahagian tidak termasuk toIndex yang merupakan elemen keempat (“Jerman”) dalam kes ini. Oleh itu ia akan mengeluarkan "UK" dan "Perancis" sahaja. Memandangkan output yang dikembalikan ialah Senarai itu sendiri, anda boleh memanggil sebarang kaedah Senarai terus padanya. Jadi apa yang akan berlaku jika kita menggunakan indeks yang sama untuk kedua-dua parameter? Adakah indeks itu akan disertakan atau dikecualikan dalam senarai yang dikembalikan? Mari kita ketahui.

//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);

Outputnya ialah Outputnya ialah senarai kosong. Walaupun fromIndex memilih elemen ke-4, kaedah subList() akan mengalih keluarnya kerana ia juga merupakan toIndex.

Contoh kaedah subList pada objek LinkedList.

Dalam contoh ini, kami akan menggunakan kaedah subsenarai pada elemen LinkedList. Sekali lagi, Ia akan mengembalikan senarai antara indeks yang ditentukan fromIndex(inclusive) dan toIndex(exclusive) . Ingat bahawa kami berkata senarai yang dikembalikan oleh kaedah subList() hanyalah paparan yang mempunyai rujukan kepada senarai asal. Jika anda melakukan sebarang perubahan pada subsenarai, ia akan menjejaskan senarai asal juga. Kami akan mengujinya juga dalam contoh ini.

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()+" ");
    }
 }
}

Output akan kelihatan seperti ini:

Apakah yang akan berlaku jika indeks tidak terikat dalam subList()?

Kaedah subList mengembalikan dua jenis pengecualian. Mari kita lihat mereka. Pertimbangkan situasi jika indeks yang ditentukan berada di luar julat elemen Senarai (dariIndex < 0 || toIndex > size) . Kemudian ia akan membuang 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

Selain itu, jika fromIndex lebih besar daripada toIndex (fromIndex > toIndex) , kaedah subList() membuang ralat IllegalArgumentException .

//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)

Kesimpulan

Dalam artikel ini, kami membincangkan kaedah subList dan cara menggunakannya. kaedah subList() menghapuskan keperluan untuk operasi julat eksplisit (Ia adalah jenis operasi yang biasa wujud untuk tatasusunan). Perkara yang paling penting untuk diingat ialah kaedah subList tidak mengembalikan contoh baharu tetapi pandangan dengan rujukan kepada senarai asal. Oleh itu, terlalu menggunakan kaedah subList pada senarai yang sama boleh menyebabkan benang tersekat dalam aplikasi Java anda.