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:    
 
 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í:  
 
 
 Sestavte objekt ArrayList a umístěte jeho typ jako data třídy.  
 
 Definujte třídu a vložte požadované entity do konstruktoru.  
 
 Propojte tyto entity s globálními proměnnými.  
 
 Data přijatá z ArrayList jsou toho typu třídy, která ukládá více dat.  
 
 
    Pří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 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:  
 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 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ě:  
 
 
 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.  
 
 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ě:  
 
 
 Časová náročnost: Vytvoření vlastního ArrayListu může být časově náročné a vyžaduje dobré  
 
 
    
         Vytvořit kvíz