Prije nego što nastavimo dalje, brzo revidiramo koncept nizovi i ArrayList brzo. Dakle, u Javi smo vidjeli nizove kao linearne podatkovne strukture koje pružaju funkcionalnost za dodavanje elemenata na kontinuirani način u memorijski adresni prostor, dok je ArrayList klasa koja pripada okviru zbirke. Budući da je dobar programer, već je svjestan korištenja ArrayList-a preko nizova unatoč poznavanju razlika između ova dva. Idemo dalje, čak i s ArrayList-om, dolazi funkcija za prosljeđivanje tipa podataka elemenata koji bi trebali biti pohranjeni u ArrayList-u, bilo da se radi o nizu objekata, cjelobrojnom dvostrukom floatu itd. 

Sintaksa:

 Arraylist  al = new ArrayList  ;  
    Bilješka:    ArrayList u Javi (ekvivalent vektoru u C++) ima dinamičku veličinu. Može se smanjiti ili proširiti ovisno o veličini. ArrayList je dio okvira zbirke i prisutan je u    java.util paket    .   
 
    Sintaksa:    
 
 ArrayList   list = new ArrayList  <> ();  
 Važna stvar ovdje je da E ovdje predstavlja tip podataka objekta, zamislite     Cijeli broj    ovdje. Klasa Integer omotava vrijednost primitivnog tipa     int    u objektu. Objekt tipa Integer sadrži jedno polje čiji je tip int. Prođite kroz koncept    klase omotača    u Javi prije nego krenemo naprijed jer će služiti ovdje u pozadini što će jasnije razumjeti ako smo dobro svjesni    autoboxing i unboxing koncepti    . To je zato što će se tijekom izvođenja operacija nad elementima na popisu njihova sintaksa razlikovati pa će se i razumijevanje koncepta iscrpiti, kao što pretpostavimo da razmotrimo scenarij dodavanja elemenata u prilagođeni ArrayList i uočimo razlike u sintaksi između njih dva.   
 
    Sintaksa:    
 
 ArrayList        al     = new Arraylist  () ;   
    al.add(1)     ;  
    Sintaksa:    
 
 ArrayList      alobj     = new Arraylist() ;   
    alobj(new Integer(1))     ;  
 Uzmimo primjer ilustracije kako bismo je vidjeli kako je navedeno u nastavku:  
 
    Ilustracija:    
 
   
 
 ovdje imamo sve elemente iste vrste koje općenito često koristimo. Predložimo sada isti dijagramski tok. ArrayList jednostavno podržava više podataka na način prikazan na ovoj slici.   
 
   
 
  
 U gornjoj ArrayList jasno možemo vidjeti da su elementi koji su pohranjeni različitih tipova. Dakle, izbija koncept          ograničavajući. na jednu vrstu, a ne samo na ovaj popis, daje nam fleksibilnost da napravimo popis prema našem tipu gdje imamo pristup vrsti podataka koji se mogu nalaziti u našoj ArrayList. Ovaj popis se u Javi naziva Custom ArrayList     .    Prilagođeni ArrayList ima atribute koji se temelje na zahtjevima korisnika i može imati više od jedne vrste podataka. Ove podatke pruža prilagođena unutarnja klasa koja se formira kombinacijom različitih tipova podataka primitivnih objekata.  
 
    Implementacija:    Razmotrimo slučaj kada unos moramo uzeti kao     N    broj učenika i detalji su:   
 
 
    rolni broj    
 
    ime    
 
    oznake    
 
    broj telefona    
 
 
 Pretpostavimo da ako nismo svjesni koncepta prilagođenog ArrayLista u Javi, tada bismo napravili dolje navedene pojedinačne ArrayListe. Kao što definiramo 4 ArrayLists i spremamo podatke u skladu s tim u svakom od njih.  
 
 ArrayList   roll = new ArrayList <>(); // roll number  
  ArrayList  name = new ArrayList <>(); // name  
 ArrayList   marks = new ArrayList <>(); // marks  
 ArrayList  phone = new ArrayList <>(); // phone number   
 Sada bismo ponavljali svaki od njih kako bismo dohvatili podatke učenika povećavajući vremensku složenost našeg programa u većoj mjeri kao što je ilustrirano u nastavku na sljedeći način.  
 
 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);   
 }  
 Učinimo sada isto uz pomoć gore naučenog koncepta implementirajući isti. Dakle, kako biste izradili naš prilagođeni ArrayList, izvedite dolje navedene korake kako slijedi:  
 
    Postupak:    Konstruiranje prilagođene ArrayList je kako slijedi:  
 
 
 Izgradite objekt ArrayList i postavite njegovu vrstu kao podatke klase.  
 
 Definirajte klasu i stavite potrebne entitete u konstruktor.  
 
 Povežite te entitete s globalnim varijablama.  
 
 Podaci primljeni iz ArrayList-a su one vrste klase koja pohranjuje više podataka.  
 
 
    Primjer    
 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  );      }   }   
    
  Izlaz   
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384 
 
 Prilagođeni ArrayList u Javi može se stvoriti proširenjem klase java.util.AbstractList i implementacijom njezinih metoda. Evo primjera kako možete stvoriti prilagođeni 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  );      }   }   
    
  Izlaz   
CustomArrayList: [1 2 3] 
 
 U ovom primjeru prilagođeni ArrayList stvoren je proširenjem klase AbstractList i implementacijom njezinih metoda size get add i remove. Prilagođeni ArrayList također ima privatnu metodu pod nazivom secureCapacity koja udvostručuje veličinu ArrayList-a ako mu ponestane prostora.  
 
 Prednosti korištenja prilagođenog ArrayList-a u Javi:  
 
 
 Fleksibilnost: Stvaranje prilagođenog ArrayList-a omogućuje vam prilagođavanje ponašanja ArrayList-a kako bi zadovoljio specifične potrebe vaše aplikacije.  
 
 Razumijevanje: Stvaranje vlastitog ArrayList-a od nule može vam pomoći da shvatite kako ArrayLists funkcioniraju i kako ih učinkovito koristiti.  
 
 
 Nedostaci korištenja prilagođenog ArrayList-a u Javi:  
 
 
 Potrošnja vremena: Stvaranje prilagođenog ArrayList-a može biti dugotrajan i zahtijeva dobar  
 
 
    
         Napravi kviz