Než budeme pokračovat dále, pojďme rychle zrevidovat koncept pole a ArrayList rychle. V Javě jsme tedy viděli, že pole jsou lineární datové struktury poskytující funkce pro kontinuální přidávání prvků do paměťového adresního prostoru, zatímco ArrayList je třída patřící do rámce Collection. Být dobrým programátorem si již uvědomuje použití ArrayList přes pole, přestože zná rozdíly mezi těmito dvěma. Nyní, dokonce i s ArrayList, přichází funkce pro předání typu datového typu prvků, které mají být uloženy v ArrayList, ať už jde o objektový řetězec celé číslo s dvojitým plovoucím úhlem atd. 

Syntax:

Arraylist al = new ArrayList ;

Poznámka: ArrayList v Javě (ekvivalentní vektoru v C++) s dynamickou velikostí. Lze jej zmenšit nebo rozšířit podle velikosti. ArrayList je součástí rámce kolekce a je přítomen v balíček java.util . 

Syntax:

r v jazyce c

ArrayList  list = new ArrayList <> ();

Zde je důležité, že E zde představuje datový typ objektu, představte si to Celé číslo zde. Třída Integer obaluje hodnotu primitivního typu int v objektu. Objekt typu Integer obsahuje jediné pole, jehož typ je int. Projděte si koncept obalové třídy v Javě, než se pohneme vpřed, protože bude sloužit zde na backendu, aby bylo pochopení jasnější, pokud jsme si toho dobře vědomi koncepty autoboxing a unboxing . Je to proto, že při provádění operací nad prvky v seznamu se jejich syntaxe bude lišit, takže koncept uchopení se vyčerpá, protože předpokládejme, že zvažte scénář přidávání prvků do vlastního seznamu ArrayList a povšimněte si rozdílů v syntaxi mezi dvěma z nich. 

Syntax:

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

Syntax:

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

Vezměme si vzorovou ilustraci, kterou si budete moci všimnout, jak je uvedeno níže:

Ilustrace:

zde máme všechny prvky stejného typu, které obecně často používáme. Nyní navrhneme stejný schematický tok ArrayList jednoduše podporuje více dat způsobem znázorněným na tomto obrázku. 

Ve výše uvedeném seznamu ArrayList jasně vidíme, že uložené prvky jsou různých typů. Takže to vybuchne z konceptu omezující. na jeden typ a nejen tento List nám dává flexibilitu, abychom List vytvořili podle našeho typu, kde máme přístup k tomu, jaké typy dat mohou být v našem ArrayList. Tento seznam se v jazyce Java označuje jako Custom ArrayList . Vlastní seznam ArrayList má atributy založené na požadavcích uživatele a může obsahovat více než jeden typ dat. Tato data poskytuje vlastní vnitřní třída, která je tvořena kombinací různých datových typů primitivních objektů.

Implementace: Zvažte případ, kdy musíme brát vstup jako N počet studentů a podrobnosti jsou: 

• číslo role
• jméno
• značky
• telefonní číslo

Předpokládejme, že pokud neznáme koncept vlastního Arraylistu v Javě, pak bychom vytvořili níže uvedené jednotlivé ArrayListy. Definujeme 4 ArrayListy a ukládáme data do každého z nich.

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

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

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

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

Nyní bychom opakovali každý z nich, abychom načetli data studentů, což ve větší míře zvýšilo časovou složitost našeho programu, jak je znázorněno níže.

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

Nyní udělejme totéž s pomocí výše uvedeného konceptu tím, že jej implementujeme. Abychom vytvořili náš vlastní ArrayList, proveďte níže uvedené kroky takto:

Postup: Vytvoření vlastního ArrayList je následující:

1. Sestavte objekt ArrayList a umístěte jeho typ jako data třídy.
2. Definujte třídu a vložte požadované entity do konstruktoru.
3. Propojte tyto entity s globálními proměnnými.
4. Data přijatá z ArrayList jsou toho typu třídy, která ukládá více dat.

Příklad

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

Vlastní ArrayList v Javě lze vytvořit rozšířením třídy java.util.AbstractList a implementací jejích metod. Zde je příklad, jak můžete vytvořit vlastní ArrayList:

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]

V tomto příkladu je vlastní ArrayList vytvořen rozšířením třídy AbstractList a implementací jejích metod size get add a remove. Vlastní ArrayList má také soukromou metodu nazvanou secureCapacity, která zdvojnásobí velikost ArrayList, pokud mu dojde místo.

Výhody použití vlastního ArrayList v Javě:

1. Flexibilita: Vytvoření vlastního ArrayList vám umožní přizpůsobit chování ArrayList tak, aby vyhovovalo specifickým potřebám vaší aplikace.
2. Pochopení: Vytvoření vlastního seznamu ArrayList od začátku vám může pomoci pochopit, jak ArrayLists fungují a jak je efektivně používat.

Nevýhody použití vlastního ArrayList v Javě:

1. Časová náročnost: Vytvoření vlastního ArrayListu může být časově náročné a vyžaduje dobré