Mielőtt továbblépnénk, nézzük át gyorsan a fogalmát tömbök és ArrayList gyorsan. Tehát a Java-ban láttuk, hogy a tömbök lineáris adatstruktúrák, amelyek lehetővé teszik az elemek folyamatos hozzáadását a memória címterébe, míg az ArrayList a Collection keretrendszerhez tartozó osztály. Jó programozóként már ismeri az ArrayList használatát tömbökön, annak ellenére, hogy ismeri a kettő közötti különbségeket. Most, még az ArrayList esetében is jön egy olyan funkció, amely átadja az ArrayListben tárolni kívánt elemek adattípusát, legyen az objektumkarakterlánc egész szám dupla lebegés stb. 

Szintaxis:

 Arraylist  al = new ArrayList  ;  
    Jegyzet:    ArrayList Java nyelven (egyenértékű a C++ vektorával), dinamikus méretű. Méret szerint zsugorítható vagy bővíthető. Az ArrayList a gyűjtési keretrendszer része, és megtalálható benne    java.util csomag    .   
 
    Szintaxis:    
 
 ArrayList   list = new ArrayList  <> ();  
 Itt az a fontos, hogy E itt egy objektum adattípust képvisel, legyen az     Egész szám    itt. Az Integer osztály egy primitív típusú értéket csomagol     int    egy tárgyban. Egy Integer típusú objektum egyetlen mezőt tartalmaz, amelynek típusa int. Menj végig a koncepción    csomagoló osztályok    Java-ban, mielőtt továbblépne, mivel itt a háttérben fog szolgálni, és tisztábbá teszi a megértést, ha jól ismerjük    autobox és unboxing fogalmak    . Ez azért van így, mert a lista elemei feletti műveletek végrehajtása során a szintaxisuk eltérő lesz, így a fogalom megragadása is kimerül, mivel tegyük fel, hogy vegyünk fontolóra egy olyan forgatókönyvet, amikor elemeket adunk az egyéni ArrayListhez, és figyeljük meg a kettő közötti szintaxis különbségeket.   
 
    Szintaxis:    
 
 ArrayList        al     = new Arraylist  () ;   
    al.add(1)     ;  
    Szintaxis:    
 
 ArrayList      alobj     = new Arraylist() ;   
    alobj(new Integer(1))     ;  
 Vegyünk egy mintaillusztrációt, hogy az alábbiak szerint érzékeljük:  
 
    Ábra:    
 
   
 
 itt van az összes azonos típusú elem, amelyet általában gyakran használunk. Most javasoljuk ugyanazt a diagramszerű folyamatot, az ArrayList egyszerűen több adatot támogat a képen látható módon.   
 
   
 
  
 A fenti ArrayList-ben jól látható, hogy a tárolt elemek különböző típusúak. Tehát kitör belőle a koncepció          korlátozó. Egyetlen típusra, és nem csak ez a lista ad lehetőséget arra, hogy a típusunknak megfelelő listát készítsünk, ahol hozzáférhetünk ahhoz, hogy milyen típusú adattípusok lehetnek az ArrayListünkben. Erre a listára a Java-ban Custom ArrayList néven hivatkoznak     .    Az egyéni ArrayList a felhasználói követelményeken alapuló attribútumokkal rendelkezik, és egynél több adattípust tartalmazhat. Ezeket az adatokat egy egyéni belső osztály biztosítja, amelyet különféle primitív objektum adattípusok kombinációja alkot.  
 
    Végrehajtás:    Tekintsünk egy esetet, amikor a bemenetet as-nak kell vennünk     N    a tanulók száma és a részletek:   
 
 
    tekercs száma    
 
    név    
 
    jelek    
 
    telefonszám    
 
 
 Tegyük fel, hogy ha nem vagyunk tisztában az egyéni Arraylist fogalmával a java-ban, akkor az alábbiakban felsorolt ​​egyedi ArrayListeket készítenénk. Ahogy definiálunk 4 ArrayList-et, és mindegyikbe ennek megfelelően mentjük az adatokat.  
 
 ArrayList   roll = new ArrayList <>(); // roll number  
  ArrayList  name = new ArrayList <>(); // name  
 ArrayList   marks = new ArrayList <>(); // marks  
 ArrayList  phone = new ArrayList <>(); // phone number   
 Most mindegyiket megismételjük, hogy lekérjük a tanulók adatait, ami nagyobb mértékben növeli programunk időbeli összetettségét, ahogy az alábbiakban bemutatjuk.  
 
 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);   
 }  
 Most tegyük meg ugyanezt a fent megismert koncepció segítségével, ugyanazt megvalósítva. Tehát az egyéni ArrayList létrehozásához hajtsa végre az alábbi lépéseket az alábbiak szerint:  
 
    Eljárás:    Az egyéni ArrayList létrehozása a következő:  
 
 
 Hozzon létre egy ArrayList objektumot, és helyezze el a típusát osztályadatként.  
 
 Határozzon meg egy osztályt, és tegye a szükséges entitásokat a konstruktorba.  
 
 Kapcsolja össze ezeket az entitásokat globális változókkal.  
 
 Az ArrayList-től kapott adatok abból az osztálytípusból származnak, amely több adatot tárol.  
 
 
    Példa    
 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  );      }   }   
    
  Kimenet   
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384 
 
 Egyedi ArrayList Java nyelven a java.util.AbstractList osztály kiterjesztésével és metódusainak megvalósításával hozható létre. Íme egy példa arra, hogyan hozhat létre egyéni ArrayList-t:  
 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  );      }   }   
    
  Kimenet   
CustomArrayList: [1 2 3] 
 
 Ebben a példában az egyéni ArrayList az AbstractList osztály kibővítésével és a size get add és remove metódusainak megvalósításával jön létre. Az egyéni ArrayList-nek van egy privát metódusa is, a biztosítékCapacity, amely megduplázza az ArrayList méretét, ha kifogy belőle.  
 
 Az egyéni ArrayList Java-ban való használatának előnyei:  
 
 
 Rugalmasság: Egyéni ArrayList létrehozása lehetővé teszi az ArrayList viselkedésének testreszabását az alkalmazás speciális igényeinek megfelelően.  
 
 Megértés: A saját ArrayList létrehozása a semmiből segíthet megérteni, hogyan működnek az ArrayLists-ek, és hogyan lehet őket hatékonyan használni.  
 
 
 Az egyéni ArrayList Java-ban való használatának hátrányai:  
 
 
 Időfelhasználás: Egy egyéni ArrayList létrehozása időigényes lehet, és jót tesz  
 
 
    
         Kvíz létrehozása