Ennen kuin jatkamme eteenpäin, tarkistakaamme nopeasti konseptin käsite taulukoita ja ArrayList nopeasti. Joten Javassa olemme nähneet, että taulukot ovat lineaarisia tietorakenteita, jotka tarjoavat toiminnallisuuden lisätä elementtejä jatkuvalla tavalla muistin osoiteavaruuteen, kun taas ArrayList on Collection-kehykseen kuuluva luokka. Hyvä ohjelmoija on jo tietoinen ArrayListin käyttämisestä taulukoiden yli, vaikka tietää näiden kahden väliset erot. Nyt eteenpäin jopa ArrayListin kanssa tulee toiminto, joka välittää elementtien tietotyypin, jotka on tarkoitus tallentaa ArrayListiin, olipa kyseessä sitten objektijono kokonaisluku double float jne. 

Syntaksi:

 Arraylist  al = new ArrayList  ;  
    Huomautus:    ArrayList Java-kielellä (vastaa C++:n vektoria), jolla on dynaaminen koko. Sitä voidaan kutistaa tai laajentaa koon mukaan. ArrayList on osa kokoelmakehystä ja se on läsnä    java.util-paketti    .   
 

 
    Syntaksi:    
 
 ArrayList   list = new ArrayList  <> ();  
 Tärkeää tässä on, että E edustaa objektitietotyyppiä, olipa kyseessä     Kokonaisluku    tässä. Kokonaisluku-luokka käärii primitiivityypin arvon     int    esineessä. Integer-tyyppinen objekti sisältää yhden kentän, jonka tyyppi on int. Käy läpi käsite    käärekurssit    javassa ennen kuin siirryt eteenpäin, koska se palvelee täällä taustalla selkeyttäen ymmärtämistä, jos olemme hyvin tietoisia siitä    autoboxing- ja unboxing-konseptit    . Tämä johtuu siitä, että suoritettaessa toimintoja luettelon elementeille niiden syntaksi eroaa, joten käsitteen ymmärtäminen heikkenee, koska oletetaan, että harkitaan skenaariota elementtien lisäämisestä mukautettuun ArrayList-luetteloon ja huomioidaan niiden kahden syntaksin erot.   
 
    Syntaksi:    
 
 ArrayList        al     = new Arraylist  () ;   
    al.add(1)     ;  
    Syntaksi:    
 
 ArrayList      alobj     = new Arraylist() ;   
    alobj(new Integer(1))     ;  
 Otetaan esimerkkikuva, jonka avulla voit havaita alla olevan kuvan seuraavasti:  
 
    Kuva:    
 
   
 
 tässä on kaikki samantyyppiset elementit, joita yleensä käytämme. Nyt ehdotetaan samaa kaavamaista kulkua. ArrayList yksinkertaisesti tukee useita tietoja tässä kuvassa esitetyllä tavalla.   
 
   
 
  
 Yllä olevasta ArrayLististä näemme selvästi, että elementit, joihin on tallennettu, ovat erityyppisiä. Joten se purkaa käsitteen          rajoittava. yhdelle tyypille, eikä vain tämä luettelo anna meille joustavuutta tehdä tyyppimme mukainen luettelo, jossa meillä on pääsy siihen, millaisia ​​tietotyyppejä ArrayListissämme voi olla. Tätä luetteloa kutsutaan Javassa nimellä Custom ArrayList     .    Muokatulla ArrayListillä on käyttäjän vaatimuksiin perustuvia attribuutteja, ja se voi sisältää useampaa kuin yhden tyyppistä dataa. Nämä tiedot tarjoaa mukautettu sisäluokka, joka muodostuu erilaisten primitiivisten objektitietotyyppien yhdistelmästä.  
 
    Toteutus:    Harkitse tapausta, jossa meidän on otettava syöte muodossa     N    opiskelijoiden määrä ja tiedot ovat:   
 
 
    rullan numero    
 
    nimi    
 
    merkkejä    
 
    puhelinnumero    
 
 
 Oletetaan, että jos emme tiedä mukautetun Arraylistin käsitettä javassa, tekisimme alla luetellut yksittäiset ArrayLists-luettelot. Kun määrittelemme 4 ArrayLists-luetteloa ja tallennamme tiedot vastaavasti kuhunkin niistä.  
 
 ArrayList   roll = new ArrayList <>(); // roll number  
  ArrayList  name = new ArrayList <>(); // name  
 ArrayList   marks = new ArrayList <>(); // marks  
 ArrayList  phone = new ArrayList <>(); // phone number   
 Nyt toistaisimme jokaisen niistä hakeaksemme opiskelijatietoja, mikä lisäisi ohjelmamme ajan monimutkaisuutta, kuten alla on kuvattu.  
 
 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);   
 }  
 Tehdään nyt sama edellä opitun konseptin avulla toteuttamalla sama. Joten luodaksesi mukautetun ArrayList-luettelomme, suorita alla luetellut vaiheet seuraavasti:  
 
    Toimenpide:    Mukautetun ArrayListin luominen on seuraava:  
 
 
 Rakenna ArrayList-objekti ja aseta sen tyyppi luokkatiedoksi.  
 
 Määritä luokka ja laita tarvittavat entiteetit konstruktoriin.  
 
 Linkitä nämä entiteetit globaaleihin muuttujiin.  
 
 ArrayLististä vastaanotettu data on sitä luokkatyyppiä, joka tallentaa useita tietoja.  
 
 
    Esimerkki    
 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  );      }   }   
    
  Lähtö   
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384 
 
 Mukautettu ArrayList Javassa voidaan luoda laajentamalla java.util.AbstractList-luokkaa ja toteuttamalla sen menetelmät. Tässä on esimerkki siitä, kuinka voit luoda mukautetun ArrayListin:  
 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  );      }   }   
    
  Lähtö   
CustomArrayList: [1 2 3] 
 
 Tässä esimerkissä mukautettu ArrayList luodaan laajentamalla AbstractList-luokkaa ja toteuttamalla sen menetelmät size get add and remove. Mukautetussa ArrayListissä on myös yksityinen menetelmä, jota kutsutaan VarmistaCapacity, joka kaksinkertaistaa ArrayListin koon, jos tila loppuu.  
 
 Mukautetun ArrayListin käytön edut Javassa:  
 
 
 Joustavuus: Luomalla mukautetun ArrayListin voit mukauttaa ArrayListin toimintaa vastaamaan sovelluksesi erityistarpeita.  
 
 Ymmärtäminen: Oman ArrayListin luominen tyhjästä voi auttaa sinua ymmärtämään, kuinka ArrayLists toimivat ja kuinka niitä käytetään tehokkaasti.  
 
 
 Mukautetun ArrayListin käytön haitat Javassa:  
 
 
 Ajankulutus: Mukautetun ArrayListin luominen voi olla aikaa vievää ja vaatii hyvää  
 
 
    
         Luo tietokilpailu