Înainte de a continua, haideți să revizuim rapid conceptul de matrice şi ArrayList repede. Deci, în java, am văzut că tablourile sunt structuri de date liniare care oferă funcționalitate pentru a adăuga elemente într-o manieră continuă în spațiul de adrese de memorie, în timp ce ArrayList este o clasă care aparține cadrului Collection. Fiind un programator bun, cineva știe deja că folosește ArrayList peste matrice, în ciuda faptului că știe diferențele dintre acestea două. Acum, mergând mai departe, chiar și cu ArrayList, vine o funcționalitate pentru a transmite tipul de tip de date al elementelor care ar trebui să fie stocate în ArrayList, fie că este un șir de obiecte întreg dublu float etc. 

Sintaxă:

Arraylist al = new ArrayList ;

Nota: ArrayList în Java (echivalent cu vector în C++) având dimensiune dinamică. Poate fi micșorat sau extins în funcție de dimensiune. ArrayList face parte din cadrul de colecție și este prezent în pachetul java.util . 

Sintaxă:

ArrayList  list = new ArrayList <> ();

Lucrul important aici este că E aici reprezintă un tip de date obiect imaginați-vă Întreg Aici. Clasa Integer include o valoare de tip primitiv int într-un obiect. Un obiect de tip Integer conține un singur câmp al cărui tip este int. Treceți prin conceptul de clase de ambalare în java înainte de a merge mai departe, deoarece va servi aici la backend, făcând înțelegerea mai clară dacă suntem bine conștienți de concepte de autoboxing și unboxing . Se datorează faptului că, în timp ce se efectuează operații asupra elementelor din listă, sintaxa lor va diferi, astfel încât înțelegerea conceptului se va epuiza, presupunem că luăm în considerare un scenariu de adăugare a elementelor la ArrayList personalizat și observați diferențele de sintaxă dintre două dintre ele. 

Sintaxă:

ArrayList       al    = new Arraylist  () ;  
    al.add(1)    ;

Sintaxă:

ArrayList     alobj    = new Arraylist() ;  
    alobj(new Integer(1))    ;

Să luăm un exemplu de ilustrare pentru a percepe așa cum este prezentat mai jos, după cum urmează:

Ilustrare:

aici avem toate elementele de același tip pe care, în general, le folosim adesea. Acum haideți să propunem același flux schematic. ArrayList acceptă pur și simplu date multiple, așa cum se arată în această imagine. 

În ArrayList de mai sus putem vedea clar că elementele în care au fost stocate sunt de diferite tipuri. Deci erupe conceptul de restrictiv. la un singur tip și nu numai această listă merge, ne oferă flexibilitatea de a face Listă conform tipului nostru, unde avem acces la ce tipuri de date pot fi acolo în ArrayList. Această listă este denumită Custom ArrayList în java . O ArrayList personalizată are atribute bazate pe cerințele utilizatorului și poate avea mai multe tipuri de date. Aceste date sunt furnizate de o clasă interioară personalizată care este formată prin combinarea diferitelor tipuri de date de obiecte primitive.

Implementare: Luați în considerare un caz în care trebuie să luăm input ca N numărul de studenți și detaliile sunt: 

• numărul rolei
• nume
• semne
• număr de telefon

Să presupunem că dacă nu suntem conștienți de conceptul de Arraylist personalizată în java, atunci vom crea mai jos ArrayLists individuale. Deoarece definim 4 ArrayLists și salvăm datele corespunzător în fiecare dintre ele.

ArrayList   roll = new ArrayList<>(); // roll number

 ArrayList name = new ArrayList<>(); // name

ArrayList   marks = new ArrayList<>(); // marks

ArrayList phone = new ArrayList<>(); // phone number 

Acum am repeta fiecare dintre ele pentru a prelua datele studenților, crescând complexitatea timpului programului nostru într-o mai mare măsură, așa cum este ilustrat mai jos, după cum urmează.

for (int i = 0; i < n; i++)   
{  
  
 // Adding all the values to each arraylist  
 // each arraylist has primitive datatypes  
   
 roll.add(rollnum_i);  
 name.add(name_i);  
 marks.add(marks_i);  
 phone.add(phone_i);  
}

Acum haideți să facem același lucru cu ajutorul conceptului învățat mai sus prin implementarea aceluiași. Deci, pentru a construi ArrayList personalizat, efectuați pașii enumerați mai jos, după cum urmează:

Procedură: Construirea ArrayList personalizată este după cum urmează:

1. Construiți un obiect ArrayList și plasați tipul acestuia ca date de clasă.
2. Definiți o clasă și puneți entitățile necesare în constructor.
3. Conectați acele entități la variabile globale.
4. Datele primite de la ArrayList sunt de acel tip de clasă care stochează date multiple.

Exemplu

// Java program to illustrate Custom ArrayList // Importing ArrayList class from java.util package import java.util.ArrayList; // Class 1 // Outer class // Main class // CustomArrayList class Data {  // Global variables of the class  int roll;  String name;  int marks;  long phone;  // Constructor has type of data that is required  Data(int roll String name int marks long phone)  {  // Initialize the input variable from main  // function to the global variable of the class  // this keyword refers to current instance  this.roll = roll;  this.name = name;  this.marks = marks;  this.phone = phone;  } } public class GFG {  // Custom class which has data type class has  // defined the type of data ArrayList  // size of input 4  int n = 4;  // Class 2  // Inner class  // The custom datatype class  public void addValues(int roll[] String name[]  int marks[] long phone[])  {  // local custom arraylist of data type  // Data having (int String int long) type  // from the class  ArrayList<Data> list = new ArrayList<>();  for (int i = 0; i < n; i++) {  // create an object and send values to the  // constructor to be saved in the Data class  list.add(new Data(roll[i] name[i] marks[i]  phone[i]));  }  // after adding values printing the values to  // test the custom arraylist  printValues(list);  }  // Method 2  // To print the values  public void printValues(ArrayList<Data> list)  {  // list- the custom arraylist is sent from  // previous function  for (int i = 0; i < n; i++) {  // Data received from arraylist is of Data  // type which is custom (int String int  // long) based on class Data  Data data = list.get(i);  // Print and display custom ArrayList  // elements that holds for student attribute  // Data variable of type Data has four  // primitive datatypes roll -int name-  // String marks- int phone- long  System.out.println(data.roll + ' ' + data.name  + ' ' + data.marks + ' '  + data.phone);  }  }  // Method 1  // Main driver method  public static void main(String args[])  {  // Custom input data  int roll[] = { 1 2 3 4 };  String name[]  = { 'Shubham' 'Atul' 'Ayush' 'Rupesh' };  int marks[] = { 100 99 93 94 };  long phone[] = { 8762357381L 8762357382L  8762357383L 8762357384L };  // Creating an object of the class  GFG custom = new GFG();  // Now calling function to add the values to the  // arraylist  custom.addValues(roll name marks phone);  } } 

1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384

Un ArrayList personalizat în Java poate fi creat prin extinderea clasei java.util.AbstractList și implementarea metodelor acesteia. Iată un exemplu despre cum puteți crea o ArrayList personalizată:

import java.util.AbstractList; import java.util.Arrays; import java.util.List; public class CustomArrayList<E> extends AbstractList<E> {  private int size = 0;  private static final int DEFAULT_CAPACITY = 10;  private Object elements[];  public CustomArrayList() {  elements = new Object[DEFAULT_CAPACITY];  }  public CustomArrayList(int capacity) {  elements = new Object[capacity];  }  @Override  public int size() {  return size;  }  @Override  public E get(int index) {  if (index >= size || index < 0) {  throw new IndexOutOfBoundsException('Index: ' + index + ' Size ' + index);  }  return (E) elements[index];  }  @Override  public void add(int index E element) {  if (index > size || index < 0) {  throw new IndexOutOfBoundsException('Index: ' + index + ' Size ' + index);  }  ensureCapacity();  for (int i = size - 1; i >= index; i--) {  elements[i + 1] = elements[i];  }  elements[index] = element;  size++;  }  @Override  public E remove(int index) {  if (index >= size || index < 0) {  throw new IndexOutOfBoundsException('Index: ' + index + ' Size ' + index);  }  Object item = elements[index];  for (int i = index; i < size - 1; i++) {  elements[i] = elements[i + 1];  }  size--;  return (E) item;  }  private void ensureCapacity() {  int newSize = elements.length * 2;  elements = Arrays.copyOf(elements newSize);  }  public static void main(String[] args) {  List<Integer> list = new CustomArrayList<>();  list.add(1);  list.add(2);  list.add(3);  System.out.println('CustomArrayList: ' + list);  } } 

CustomArrayList: [1 2 3]

În acest exemplu, ArrayList personalizat este creat prin extinderea clasei AbstractList și implementarea metodelor sale size get add and remove. ArrayList personalizat are, de asemenea, o metodă privată numită assureCapacity, care dublează dimensiunea ArrayList dacă rămâne fără spațiu.

Avantajele utilizării unei ArrayList personalizate în Java:

1. Flexibilitate: Crearea unui ArrayList personalizat vă permite să personalizați comportamentul ArrayList pentru a satisface nevoile specifice ale aplicației dvs.
2. Înțelegerea: crearea propriei liste ArrayList de la zero vă poate ajuta să înțelegeți cum funcționează ArrayLists și cum să le utilizați eficient.

Dezavantajele utilizării unui ArrayList personalizat în Java:

1. Consum de timp: Crearea unui ArrayList personalizat poate consuma timp și necesită un bun