Predtým, ako budeme pokračovať ďalej, rýchlo zrevidujme koncept polia a ArrayList rýchlo. Takže v jave sme videli polia sú lineárne dátové štruktúry, ktoré poskytujú funkcie na nepretržité pridávanie prvkov do priestoru adries pamäte, zatiaľ čo ArrayList je trieda patriaca do rámca Collection. Ako dobrý programátor si je už vedomý používania ArrayList na poliach napriek tomu, že pozná rozdiely medzi týmito dvoma. Teraz vpred aj s ArrayList prichádza funkcia na odovzdanie typu dátového typu prvkov, ktoré majú byť uložené v ArrayList, či už ide o objektový reťazec celé číslo s dvojitým floatom atď. 

Syntax:

 Arraylist  al = new ArrayList  ;  
    Poznámka:    ArrayList v jazyku Java (ekvivalent vektora v C++) s dynamickou veľkosťou. Môže sa zmenšiť alebo rozšíriť podľa veľkosti. ArrayList je súčasťou rámca kolekcie a je prítomný v    balík java.util    .   
 
    Syntax:    
 
 ArrayList   list = new ArrayList  <> ();  
 Tu je dôležité, že E tu predstavuje dátový typ objektu, predstavte si to     Celé číslo    tu. Trieda Integer obaľuje hodnotu primitívneho typu     int    v objekte. Objekt typu Integer obsahuje jedno pole, ktorého typ je int. Prejdite si koncept    obalové triedy    v jave predtým, než sa posuniete vpred, pretože bude slúžiť tu na backende, čím bude porozumenie jasnejšie, ak sme si toho dobre vedomí    koncepty autoboxing a unboxing    . Je to preto, že pri vykonávaní operácií nad prvkami v zozname sa ich syntax bude líšiť, takže koncept uchopenia sa vyčerpá, pretože predpokladajme, že zvážte scenár pridávania prvkov do vlastného ArrayList a všimnite si rozdiely v syntaxi medzi dvoma z nich.   
 
    Syntax:    
 
 ArrayList        al     = new Arraylist  () ;   
    al.add(1)     ;  
    Syntax:    
 
 ArrayList      alobj     = new Arraylist() ;   
    alobj(new Integer(1))     ;  
 Zoberme si vzorovú ilustráciu, aby sme ju vnímali takto:  
 
    Ilustrácia:    
 
   
 
 tu máme všetky prvky rovnakého typu, ktoré vo všeobecnosti často používame. Teraz navrhnime rovnaký schematický tok ArrayList jednoducho podporuje viacero údajov spôsobom znázorneným na tomto obrázku.   
 
   
 
  
 Vo vyššie uvedenom ArrayList môžeme jasne vidieť, že uložené prvky sú rôznych typov. Takže to vybuchne z konceptu          obmedzujúce. na jeden typ a nielen tento zoznam nám dáva flexibilitu pri vytváraní zoznamu podľa nášho typu, kde máme prístup k tomu, aké typy údajov môžu byť v našom ArrayList. Tento zoznam sa v jazyku Java označuje ako Custom ArrayList     .    Vlastný ArrayList má atribúty založené na požiadavkách používateľov a môže obsahovať viac ako jeden typ údajov. Tieto údaje poskytuje vlastná vnútorná trieda, ktorá je tvorená kombináciou rôznych typov údajov primitívnych objektov.  
 
    Implementácia:    Zoberme si prípad, keď musíme brať vstup ako     N    počet študentov a podrobnosti sú:   
 
 
    číslo rolky    
 
    meno    
 
    známky    
 
    telefónne číslo    
 
 
 Predpokladajme, že ak nepoznáme koncept vlastného Arraylistu v jazyku Java, potom by sme vytvorili nižšie uvedené jednotlivé ArrayListy. Keďže definujeme 4 ArrayListy a podľa toho ukladáme údaje 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   
 Teraz by sme opakovali každý z nich, aby sme získali údaje o študentoch, čím by sme vo väčšej miere zvýšili časovú zložitosť nášho programu, ako je znázornené nižšie.  
 
 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);   
 }  
 Teraz urobme to isté s pomocou vyššie uvedeného konceptu implementáciou toho istého. Aby ste vytvorili náš vlastný ArrayList, vykonajte nižšie uvedené kroky takto:  
 
    Postup:    Vytvorenie vlastného ArrayList je nasledovné:  
 
 
 Zostavte objekt ArrayList a umiestnite jeho typ ako údaje triedy.  
 
 Definujte triedu a vložte požadované entity do konštruktora.  
 
 Prepojte tieto entity s globálnymi premennými.  
 
 Údaje prijaté z ArrayList sú takého typu triedy, ktorý ukladá viacero údajov.  
 
 
    Príklad    
 Java   
   // 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  );      }   }   
    
  Výstup   
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384 
 
 Vlastný ArrayList v Jave možno vytvoriť rozšírením triedy java.util.AbstractList a implementáciou jej metód. Tu je príklad, ako môžete vytvoriť vlastný ArrayList:  
 Java   
   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  );      }   }   
    
  Výstup   
CustomArrayList: [1 2 3] 
 
 V tomto príklade je vlastný ArrayList vytvorený rozšírením triedy AbstractList a implementáciou jej metód size get add a remove. Vlastný ArrayList má tiež súkromnú metódu s názvom secureCapacity, ktorá zdvojnásobí veľkosť ArrayList, ak sa v ňom minie miesto.  
 
 Výhody použitia vlastného ArrayList v jazyku Java:  
 
 
 Flexibilita: Vytvorenie vlastného ArrayList vám umožňuje prispôsobiť správanie ArrayList tak, aby vyhovovalo špecifickým potrebám vašej aplikácie.  
 
 Pochopenie: Vytvorenie vlastného ArrayList od začiatku vám môže pomôcť pochopiť, ako ArrayLists fungujú a ako ich efektívne používať.  
 
 
 Nevýhody použitia vlastného ArrayList v jazyku Java:  
 
 
 Časová spotreba: Vytvorenie vlastného ArrayList môže byť časovo náročné a vyžaduje si dobré  
 
 
    
         Vytvoriť kvíz