Før vi går videre, la oss raskt revidere konseptet matriser og ArrayList raskt. Så i java har vi sett at arrays er lineære datastrukturer som gir funksjonalitet for å legge til elementer på en kontinuerlig måte i minneadresserommet, mens ArrayList er en klasse som tilhører samlingsrammeverket. Som en god programmerer er man allerede klar over å bruke ArrayList over arrays til tross for at man kjenner forskjellene mellom disse to. Når du nå går videre selv med ArrayList, kommer det en funksjonalitet for å overføre typen datatype av elementer som er ment å være lagret i ArrayList, enten det er en objektstreng heltall double float osv. 

Syntaks:

 Arraylist  al = new ArrayList  ;  
    Note:    ArrayList i Java (tilsvarer vektor i C++) med dynamisk størrelse. Den kan krympes eller utvides basert på størrelse. ArrayList er en del av samlingsrammeverket og er tilstede i    java.util-pakken    .   
 
    Syntaks:    
 
 ArrayList   list = new ArrayList  <> ();  
 Det viktige her ute er at E her representerer en objektdatatype forestill deg     Heltall    her. Heltallsklassen omslutter en verdi av den primitive typen     int    i en gjenstand. Et objekt av typen Heltall inneholder et enkelt felt hvis typen er int. Gå gjennom konseptet    innpakningsklasser    i java før du går videre, da det vil tjene her i backend, noe som gjør forståelsen klarere hvis vi er godt klar over    autoboxing og unboxing konsepter    . Det er fordi når de utfører operasjoner over elementer i listen, vil syntaksen deres være forskjellig, så gripe over konseptet vil tømmes, for anta at du bør vurdere et scenario med å legge til elementer i egendefinert ArrayList og legge merke til forskjellene i syntaks mellom to av dem.   
 
    Syntaks:    
 
 ArrayList        al     = new Arraylist  () ;   
    al.add(1)     ;  
    Syntaks:    
 
 ArrayList      alobj     = new Arraylist() ;   
    alobj(new Integer(1))     ;  
 La oss ta en eksempelillustrasjon for å oppfatte som gitt nedenfor som følger:  
 
    Illustrasjon:    
 
   
 
 her har vi alle elementene av samme type som vi vanligvis bruker. La oss nå foreslå den samme diagrammatiske flyten. ArrayList støtter ganske enkelt flere data på den måten som er vist i dette bildet.   
 
   
 
  
 I ArrayList ovenfor kan vi tydelig se at elementene som er lagret i er av forskjellige typer. Så det bryter ut konseptet          begrensende. til en enkelt type, og ikke bare denne listen går, gir oss fleksibiliteten til å lage List i henhold til vår type der vi har tilgang til hva slags datatyper som kan være der i ArrayList. Denne listen blir referert til som Custom ArrayList i java     .    En tilpasset ArrayList har attributter basert på brukerkrav og kan ha mer enn én type data. Disse dataene leveres av en tilpasset indre klasse som er dannet av kombinasjonen av ulike primitive objektdatatyper.  
 
    Implementering:    Vurder en sak når vi må ta innspill som     N    antall studenter og detaljer er:   
 
 
    rullenummer    
 
    navn    
 
    merker    
 
    telefonnummer    
 
 
 Anta at hvis vi ikke er klar over konseptet med tilpasset Arraylist i java, vil vi lage individuelle ArrayLists nedenfor. Som vi definerer 4 ArrayLists og lagrer data tilsvarende i hver av dem.  
 
 ArrayList   roll = new ArrayList <>(); // roll number  
  ArrayList  name = new ArrayList <>(); // name  
 ArrayList   marks = new ArrayList <>(); // marks  
 ArrayList  phone = new ArrayList <>(); // phone number   
 Nå ville vi iterere over hver av dem for å hente studentdata og øke tidskompleksiteten til programmet vårt i større grad som illustrert nedenfor som følger.  
 
 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);   
 }  
 La oss nå gjøre det samme ved hjelp av konseptet lært ovenfor ved å implementere det samme. Så for å konstruere vår tilpassede ArrayList, utfør trinnene nedenfor som følger:  
 
    Prosedyre:    Å konstruere tilpasset ArrayList er som følger:  
 
 
 Bygg et ArrayList-objekt og plasser typen som en klassedata.  
 
 Definer en klasse og legg inn de nødvendige enhetene i konstruktøren.  
 
 Koble disse enhetene til globale variabler.  
 
 Data mottatt fra ArrayList er av den klassetypen som lagrer flere data.  
 
 
    Eksempel    
 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  );      }   }   
    
  Produksjon   
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384 
 
 En tilpasset ArrayList i Java kan opprettes ved å utvide klassen java.util.AbstractList og implementere metodene. Her er et eksempel på hvordan du kan lage en egendefinert 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  );      }   }   
    
  Produksjon   
CustomArrayList: [1 2 3] 
 
 I dette eksemplet er den tilpassede ArrayList opprettet ved å utvide AbstractList-klassen og implementere dens metodestørrelse for å legge til og fjerne. Den tilpassede ArrayList har også en privat metode kalt sureCapacity som dobler størrelsen på ArrayList hvis den går tom for plass.  
 
 Fordeler med å bruke en tilpasset ArrayList i Java:  
 
 
 Fleksibilitet: Ved å lage en tilpasset ArrayList kan du tilpasse oppførselen til ArrayList for å møte de spesifikke behovene til applikasjonen din.  
 
 Forståelse: Å lage din egen ArrayList fra bunnen av kan hjelpe deg å forstå hvordan ArrayLists fungerer og hvordan du bruker dem effektivt.  
 
 
 Ulemper ved å bruke en tilpasset ArrayList i Java:  
 
 
 Tidsforbruk: Å lage en egendefinert ArrayList kan være tidkrevende og krever et godt  
 
 
    
         Lag quiz