Voordat we verder gaan, moeten we eerst even het concept van de arrays En ArrayLijst snel. Dus in Java hebben we gezien dat arrays lineaire datastructuren zijn die functionaliteit bieden om elementen op een continue manier toe te voegen aan de geheugenadresruimte, terwijl ArrayList een klasse is die behoort tot het Collection-framework. Als goede programmeur ben je al op de hoogte van het gebruik van ArrayList over arrays, ondanks dat je de verschillen tussen deze twee kent. Nu we verder gaan, zelfs met ArrayList, komt er een functionaliteit om het type datatype van elementen door te geven dat in de ArrayList zou moeten worden opgeslagen, of het nu een objectstring geheel getal dubbele float enz. is. 

Syntaxis:

 Arraylist  al = new ArrayList  ;  
    Opmerking:    ArrayList in Java (equivalent aan vector in C++) met dynamische grootte. Het kan worden verkleind of uitgebreid op basis van de grootte. ArrayList maakt deel uit van het verzamelingsframework en is aanwezig in    java.util-pakket    .   
 
    Syntaxis:    
 
 ArrayList   list = new ArrayList  <> ();  
 Het belangrijkste hier is dat E hier een objectdatatype vertegenwoordigt, stel je voor dat het zo is     Geheel getal    hier. De klasse Integer omhult een waarde van het primitieve type     int    in een voorwerp. Een object van het type Integer bevat één veld waarvan het type int is. Neem het concept door van    wrap klassen    in Java voordat we verder gaan, omdat het hier aan de achterkant zal dienen om het begrip duidelijker te maken als we ons er goed van bewust zijn    autoboxing- en unboxing-concepten    . Het is omdat tijdens het uitvoeren van bewerkingen op elementen in de lijst hun syntaxis zal verschillen, zodat het begrip over het concept zal afnemen, bijvoorbeeld als u een scenario overweegt waarin u elementen aan aangepaste ArrayList toevoegt en de verschillen in syntaxis tussen twee ervan opmerkt.   
 
    Syntaxis:    
 
 ArrayList        al     = new Arraylist  () ;   
    al.add(1)     ;  
    Syntaxis:    
 
 ArrayList      alobj     = new Arraylist() ;   
    alobj(new Integer(1))     ;  
 Laten we een voorbeeldillustratie nemen om het hieronder als volgt waar te nemen:  
 
    Illustratie:    
 
   
 
 hier hebben we alle elementen van hetzelfde type die we over het algemeen vaak gebruiken. Laten we nu dezelfde schematische stroom voorstellen. ArrayList ondersteunt eenvoudigweg meerdere gegevens op de manier die in deze afbeelding wordt weergegeven.   
 
   
 
  
 In de bovenstaande ArrayList kunnen we duidelijk zien dat de elementen waarin zijn opgeslagen van verschillende typen zijn. Dus het barst los van het concept van          beperkend. naar een enkel type en niet alleen deze lijst geeft ons de flexibiliteit om een ​​lijst te maken volgens ons type, waarbij we toegang hebben tot wat voor soort gegevenstypen er in onze ArrayList kunnen voorkomen. Deze lijst wordt in Java Custom ArrayList genoemd     .    Een aangepaste ArrayList heeft kenmerken die zijn gebaseerd op gebruikersvereisten en kan meer dan één gegevenstype bevatten. Deze gegevens worden geleverd door een aangepaste innerlijke klasse die wordt gevormd door de combinatie van verschillende primitieve objectgegevenstypen.  
 
    Uitvoering:    Beschouw een geval waarin we input moeten nemen als     N    aantal studenten en details zijn:   
 
 
    rolnummer    
 
    naam    
 
    merken    
 
    telefoonnummer    
 
 
 Stel dat als we ons niet bewust zijn van het concept van aangepaste Arraylist in Java, we de onderstaande individuele ArrayListen zouden maken. Terwijl we 4 ArrayLists definiëren en gegevens dienovereenkomstig in elk ervan opslaan.  
 
 ArrayList   roll = new ArrayList <>(); // roll number  
  ArrayList  name = new ArrayList <>(); // name  
 ArrayList   marks = new ArrayList <>(); // marks  
 ArrayList  phone = new ArrayList <>(); // phone number   
 Nu zouden we elk van deze herhalen om leerlinggegevens op te halen, waardoor de tijdscomplexiteit van ons programma in grotere mate toeneemt, zoals hieronder als volgt wordt geïllustreerd.  
 
 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);   
 }  
 Laten we nu hetzelfde doen met behulp van het hierboven geleerde concept door hetzelfde te implementeren. Dus om onze aangepaste ArrayList samen te stellen, voert u de onderstaande stappen als volgt uit:  
 
    Procedure:    Het construeren van een aangepaste ArrayList gaat als volgt:  
 
 
 Bouw een ArrayList-object en plaats het type ervan als Class Data.  
 
 Definieer een klasse en plaats de vereiste entiteiten in de constructor.  
 
 Koppel deze entiteiten aan globale variabelen.  
 
 Gegevens ontvangen van de ArrayList zijn van dat klassetype waarin meerdere gegevens worden opgeslagen.  
 
 
    Voorbeeld    
 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  );      }   }   
    
  Uitvoer   
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384 
 
 Een aangepaste ArrayList in Java kan worden gemaakt door de klasse java.util.AbstractList uit te breiden en de methoden ervan te implementeren. Hier is een voorbeeld van hoe u een aangepaste ArrayList kunt maken:  
 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  );      }   }   
    
  Uitvoer   
CustomArrayList: [1 2 3] 
 
 In dit voorbeeld wordt de aangepaste ArrayList gemaakt door de klasse AbstractList uit te breiden en de methoden size get add en remove te implementeren. De aangepaste ArrayList heeft ook een privémethode genaamd sureCapacity, die de grootte van de ArrayList verdubbelt als er onvoldoende ruimte is.  
 
 Voordelen van het gebruik van een aangepaste ArrayList in Java:  
 
 
 Flexibiliteit: Door een aangepaste ArrayList te maken, kunt u het gedrag van de ArrayList aanpassen aan de specifieke behoeften van uw toepassing.  
 
 Begrijpen: Door uw eigen ArrayList helemaal opnieuw te maken, kunt u beter begrijpen hoe ArrayLists werken en hoe u ze effectief kunt gebruiken.  
 
 
 Nadelen van het gebruik van een aangepaste ArrayList in Java:  
 
 
 Tijdverbruik: het maken van een aangepaste ArrayList kan tijdrovend zijn en vereist een goede voorbereiding  
 
 
    
         Quiz maken