Pirms turpināt, ļaujiet mums ātri pārskatīt koncepciju masīvi un ArrayList ātri. Tātad Java mēs redzējām, ka masīvi ir lineāras datu struktūras, kas nodrošina funkcionalitāti nepārtrauktai elementu pievienošanai atmiņas adrešu telpā, savukārt ArrayList ir klase, kas pieder kolekcijas ietvaram. Tā kā viņš ir labs programmētājs, viņš jau zina, kā izmantot ArrayList masīvus, neskatoties uz to, ka ir zināms atšķirības starp šiem diviem. Tagad, virzoties uz priekšu pat ar ArrayList, tiek piedāvāta funkcionalitāte, kas ļauj nodot to elementu datu tipu, kuri ir jāsaglabā ArrayList, neatkarīgi no tā, vai tā ir objekta virkne vesela skaitļa dubultā peldēšana utt. 

Sintakse:

 Arraylist  al = new ArrayList  ;  
    Piezīme:    ArrayList Java valodā (ekvivalents C++ vektoram) ar dinamisku izmēru. To var samazināt vai paplašināt atkarībā no izmēra. ArrayList ir daļa no kolekcijas sistēmas, un tā ir pieejama    java.util pakotne    .   
 
    Sintakse:    
 
 ArrayList   list = new ArrayList  <> ();  
 Šeit galvenais ir tas, ka E šeit apzīmē objekta datu tipu, vai tas būtu     Vesels skaitlis    šeit. Veselu skaitļu klase aptver primitīvā tipa vērtību     starpt    objektā. Integer tipa objekts satur vienu lauku, kura tips ir int. Izejiet cauri jēdzienam    iesaiņojuma nodarbības    java, pirms pāriet uz priekšu, jo tas kalpos šeit aizmugures daļā, padarot izpratni skaidrāku, ja mēs to labi apzināmies    autoboxing un unboxing koncepcijas    . Tas ir tāpēc, ka, veicot darbības ar saraksta elementiem, to sintakse atšķirsies, tāpēc jēdziena uztvere izsīks, pieņemot, ka tiek apsvērts scenārijs elementu pievienošanai pielāgotajam ArrayList un jāņem vērā sintakses atšķirības starp diviem no tiem.   
 
    Sintakse:    
 
 ArrayList        al     = new Arraylist  () ;   
    al.add(1)     ;  
    Sintakse:    
 
 ArrayList      alobj     = new Arraylist() ;   
    alobj(new Integer(1))     ;  
 Ņemsim ilustrācijas paraugu, lai to uztvertu šādi:  
 
    Ilustrācija:    
 
   
 
 šeit mums ir visi viena veida elementi, kurus mēs parasti izmantojam. Tagad piedāvāsim to pašu diagrammu plūsmu. ArrayList vienkārši atbalsta vairākus datus, kā parādīts šajā attēlā.   
 
   
 
  
 Iepriekš minētajā ArrayList mēs skaidri redzam, ka saglabātie elementi ir dažāda veida. Tātad tas izceļ jēdzienu          ierobežojot. uz vienu tipu, un ne tikai šis saraksts dod mums iespēju izveidot sarakstu atbilstoši mūsu veidam, kur mums ir piekļuve tam, kāda veida datu tipi var būt mūsu ArrayList. Šis saraksts Java valodā tiek saukts par Custom ArrayList     .    Pielāgotam ArrayList ir atribūti, kuru pamatā ir lietotāja prasības, un tajā var būt vairāk nekā viena veida dati. Šos datus nodrošina pielāgota iekšējā klase, ko veido dažādu primitīvu objektu datu tipu kombinācija.  
 
    Īstenošana:    Apsveriet gadījumu, kad ievade ir jāuzņem kā     N    studentu skaits un informācija ir:   
 
 
    ruļļa numurs    
 
    nosaukums    
 
    atzīmes    
 
    tālruņa numuru    
 
 
 Pieņemsim, ka, ja mēs nezinām pielāgotā masīvu saraksta jēdzienu java, mēs veidosim tālāk norādītos atsevišķus masīvu sarakstus. Kā mēs definējam 4 ArrayLists un attiecīgi saglabājam datus katrā no tiem.  
 
 ArrayList   roll = new ArrayList <>(); // roll number  
  ArrayList  name = new ArrayList <>(); // name  
 ArrayList   marks = new ArrayList <>(); // marks  
 ArrayList  phone = new ArrayList <>(); // phone number   
 Tagad mēs atkārtosim katru no tiem, lai iegūtu studentu datus, tādējādi palielinot mūsu programmas laika sarežģītību, kā parādīts tālāk.  
 
 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);   
 }  
 Tagad darīsim to pašu, izmantojot iepriekš apgūto koncepciju, īstenojot to pašu. Tātad, lai izveidotu mūsu pielāgoto ArrayList, veiciet tālāk norādītās darbības:  
 
    Procedūra:    Pielāgota ArrayList izveide ir šāda:  
 
 
 Izveidojiet ArrayList objektu un ievietojiet tā veidu kā klases datus.  
 
 Definējiet klasi un konstruktorā ievietojiet nepieciešamās entītijas.  
 
 Saistiet šīs entītijas ar globālajiem mainīgajiem.  
 
 Dati, kas saņemti no ArrayList, ir tāda tipa, kurā tiek glabāti vairāki dati.  
 
 
    Piemērs    
 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  );      }   }   
    
  Izvade   
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384 
 
 Pielāgotu ArrayList Java var izveidot, paplašinot klasi java.util.AbstractList un ieviešot tās metodes. Šeit ir piemērs, kā izveidot pielāgotu 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  );      }   }   
    
  Izvade   
CustomArrayList: [1 2 3] 
 
 Šajā piemērā pielāgotais ArrayList tiek izveidots, paplašinot AbstractList klasi un ieviešot tās metodes lieluma iegūšanai pievienošana un noņemšana. Pielāgotajam ArrayList ir arī privāta metode, ko sauc par secureCapacity, kas dubulto ArrayList lielumu, ja tajā pietrūkst vietas.  
 
 Pielāgota ArrayList izmantošanas priekšrocības Java:  
 
 
 Elastība: Pielāgota ArrayList izveide ļauj pielāgot ArrayList darbību, lai tā atbilstu jūsu lietojumprogrammas īpašajām vajadzībām.  
 
 Izpratne: izveidojot savu ArrayList no jauna, varat saprast, kā ArrayLists darbojas un kā tos efektīvi izmantot.  
 
 
 Pielāgota ArrayList izmantošanas trūkumi Java:  
 
 
 Laika patēriņš: pielāgota ArrayList izveide var būt laikietilpīga, un tam ir nepieciešams labs  
 
 
    
         Izveidojiet viktorīnu