Prieš tęsdami toliau, greitai peržiūrėkime sąvoką masyvai ir ArrayList greitai. Taigi „Java“ programoje matėme, kad masyvai yra linijinės duomenų struktūros, suteikiančios galimybę nuolat pridėti elementus į atminties adresų erdvę, o „ArrayList“ yra klasė, priklausanti kolekcijai. Būdamas geras programuotojas, žmogus jau žino apie ArrayList naudojimą per masyvus, nepaisant to, kad žino šių dviejų skirtumus. Dabar net ir naudojant ArrayList atsiranda funkcija, leidžianti perduoti elementų, kurie turėtų būti saugomi ArrayList, tipo duomenų tipą, nesvarbu, ar tai būtų objektų eilutės sveikasis skaičius dvigubas plūdimas ir pan. 

Sintaksė:

 Arraylist  al = new ArrayList  ;  
    Pastaba:    „ArrayList“ Java kalba (atitinka C++ vektorių), turintis dinaminį dydį. Jis gali būti sumažintas arba išplėstas pagal dydį. ArrayList yra kolekcijos sistemos dalis ir yra    java.util paketą    .   
 
    Sintaksė:    
 
 ArrayList   list = new ArrayList  <> ();  
 Čia svarbu tai, kad E reiškia objekto duomenų tipą, įsivaizduokite, ar tai būtų     Sveikasis skaičius    čia. Integer klasė apima primityvaus tipo reikšmę     tarpt    objekte. Integer tipo objekte yra vienas laukas, kurio tipas yra int. Pereikite per sąvoką    vyniojimo klasės    „Java“ versijoje prieš judant į priekį, nes ji veiks čia, užpakalinėje programoje, todėl supratimas bus aiškesnis, jei gerai žinome    autoboxing ir unboxing koncepcijos    . Taip yra todėl, kad atliekant operacijas su sąrašo elementais, jų sintaksė skirsis, todėl supratimas apie sąvoką išeikvotas, nes, tarkime, apsvarstykite scenarijų, kaip įtraukti elementus į pasirinktinį ArrayList, ir atkreipkite dėmesį į dviejų iš jų sintaksės skirtumus.   
 
    Sintaksė:    
 
 ArrayList        al     = new Arraylist  () ;   
    al.add(1)     ;  
    Sintaksė:    
 
 ArrayList      alobj     = new Arraylist() ;   
    alobj(new Integer(1))     ;  
 Paimkime iliustracijos pavyzdį, kad suprastume, kaip nurodyta toliau:  
 
    Iliustracija:    
 
   
 
 čia yra visi to paties tipo elementai, kuriuos dažniausiai naudojame. Dabar pasiūlykime tą patį diagraminį srautą ArrayList tiesiog palaiko kelis duomenis, kaip parodyta šiame paveikslėlyje.   
 
   
 
  
 Aukščiau pateiktame „ArrayList“ aiškiai matome, kad saugomi elementai yra skirtingų tipų. Taigi ji išryškina sąvoką          ribojantis. į vieną tipą, o ne tik šis sąrašas suteikia mums lankstumo sudaryti sąrašą pagal savo tipą, kuriame galime pasiekti, kokių tipų duomenų gali būti mūsų „ArrayList“. Šis sąrašas java yra vadinamas Custom ArrayList     .    Tinkintas „ArrayList“ turi atributų, pagrįstų naudotojo reikalavimais, ir gali turėti daugiau nei vieno tipo duomenis. Šiuos duomenis teikia pritaikyta vidinė klasė, kurią sudaro įvairių primityvių objektų duomenų tipų derinys.  
 
    Įgyvendinimas:    Apsvarstykite atvejį, kai įvestį turime priimti kaip     N    studentų skaičius ir informacija yra:   
 
 
    ritinio numeris    
 
    pavadinimas    
 
    ženklų    
 
    telefono numerį    
 
 
 Tarkime, jei nežinome „Java“ tinkinto „Arraylist“ sąvokos, toliau sudarysime atskirus „ArrayLists“ sąrašus. Mes apibrėžiame 4 ArrayLists ir atitinkamai išsaugome duomenis kiekviename iš jų.  
 
 ArrayList   roll = new ArrayList <>(); // roll number  
  ArrayList  name = new ArrayList <>(); // name  
 ArrayList   marks = new ArrayList <>(); // marks  
 ArrayList  phone = new ArrayList <>(); // phone number   
 Dabar pakartosime kiekvieną iš jų, kad gautume studentų duomenis, taip padidindami mūsų programos laiko sudėtingumą, kaip parodyta toliau.  
 
 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);   
 }  
 Dabar padarykime tą patį, naudodamiesi anksčiau išmokta koncepcija, įgyvendindami tą patį. Taigi, norėdami sukurti pasirinktinį ArrayList, atlikite toliau nurodytus veiksmus:  
 
    Procedūra:    Pasirinktinio ArrayList kūrimas yra toks:  
 
 
 Sukurkite ArrayList objektą ir įdėkite jo tipą kaip klasės duomenis.  
 
 Apibrėžkite klasę ir į konstruktorių įdėkite reikiamus objektus.  
 
 Susiekite tuos objektus su visuotiniais kintamaisiais.  
 
 Duomenys, gauti iš ArrayList, yra tos klasės, kurioje saugomi keli duomenys.  
 
 
    Pavyzdys    
 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  );      }   }   
    
  Išvestis   
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384 
 
 Pasirinktinį ArrayList Java programoje galima sukurti išplėtus java.util.AbstractList klasę ir įdiegus jos metodus. Štai pavyzdys, kaip galite sukurti pasirinktinį 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  );      }   }   
    
  Išvestis   
CustomArrayList: [1 2 3] 
 
 Šiame pavyzdyje tinkintas ArrayList sukuriamas išplečiant AbstractList klasę ir įgyvendinant jos metodus, kurių dydis get add and Remove. Pasirinktiniame „ArrayList“ taip pat yra privatus metodas, vadinamas „secureCapacity“, kuris padvigubina „ArrayList“ dydį, jei jame pritrūksta vietos.  
 
 „Java“ tinkinto „ArrayList“ naudojimo pranašumai:  
 
 
 Lankstumas: Sukūrę pasirinktinį ArrayList galite tinkinti ArrayList veikimą, kad jis atitiktų konkrečius jūsų programos poreikius.  
 
 Supratimas: Sukūrę savo ArrayList nuo nulio, galite suprasti, kaip veikia ArrayLists ir kaip juos efektyviai naudoti.  
 
 
 „Java“ tinkinto „ArrayList“ naudojimo trūkumai:  
 
 
 Laiko sąnaudos: pasirinktinio „ArrayList“ kūrimas gali užtrukti ir tam reikia gerai  
 
 
    
         Sukurti viktoriną