Prima di procedere oltre rivediamo brevemente il concetto di matrici E ArrayList velocemente. Quindi in Java abbiamo visto che gli array sono strutture dati lineari che forniscono funzionalità per aggiungere elementi in modo continuo nello spazio degli indirizzi di memoria mentre ArrayList è una classe appartenente al framework Collection. Essendo un buon programmatore, sei già a conoscenza dell'utilizzo di ArrayList sugli array nonostante conosca le differenze tra questi due. Ora andando avanti anche con ArrayList arriva una funzionalità per passare il tipo di tipo di dati degli elementi che dovrebbero essere memorizzati nell'ArrayList, sia esso una stringa di oggetto intero doppio float ecc. 

Sintassi:

 Arraylist  al = new ArrayList  ;  
    Nota:    ArrayList in Java (equivalente al vettore in C++) con dimensioni dinamiche. Può essere ridotto o espanso in base alle dimensioni. ArrayList fa parte del framework della raccolta ed è presente in    pacchetto java.util    .   
 

 
    Sintassi:    
 
 ArrayList   list = new ArrayList  <> ();  
 La cosa importante qui è che E qui rappresenta un tipo di dati di oggetto, immagina che sia     Intero    Qui. La classe Integer racchiude un valore di tipo primitivo     int    in un oggetto. Un oggetto di tipo Integer contiene un singolo campo il cui tipo è int. Analizza il concetto di    classi wrapper    in Java prima di andare avanti poiché servirà qui nel backend per rendere la comprensione più chiara se ne siamo ben consapevoli    concetti di autoboxing e unboxing    . È perché durante l'esecuzione di operazioni sugli elementi nell'elenco, la loro sintassi sarà diversa, quindi la comprensione del concetto si esaurirà, come supponiamo di considerare uno scenario di aggiunta di elementi all'ArrayList personalizzato e notare le differenze nella sintassi tra due di essi.   
 
    Sintassi:    
 
 ArrayList        al     = new Arraylist  () ;   
    al.add(1)     ;  
    Sintassi:    
 
 ArrayList      alobj     = new Arraylist() ;   
    alobj(new Integer(1))     ;  
 Prendiamo un esempio di illustrazione per percepire quanto fornito di seguito come segue:  
 
    Illustrazione:    
 
   
 
 qui abbiamo tutti gli elementi dello stesso tipo che in generale usiamo spesso. Proponiamo ora che lo stesso flusso schematico ArrayList supporti semplicemente più dati nel modo mostrato in questa immagine.   
 
   
 
  
 Nell'ArrayList sopra possiamo vedere chiaramente che gli elementi memorizzati sono di diversi tipi. Quindi fa emergere il concetto di          restrittivo. a un singolo tipo e non solo questo Elenco ci dà la flessibilità di creare Elenco secondo il nostro tipo in cui abbiamo accesso a quale tipo di tipi di dati possono essere presenti nel nostro ArrayList. Questo elenco è denominato ArrayList personalizzato in Java     .    Un ArrayList personalizzato ha attributi basati sui requisiti dell'utente e può avere più di un tipo di dati. Questi dati sono forniti da una classe interna personalizzata formata dalla combinazione di vari tipi di dati di oggetti primitivi.  
 
    Attuazione:    Consideriamo un caso in cui dobbiamo prendere input come     N    numero di studenti e dettagli sono:   
 
 
    numero del rotolo    
 
    nome    
 
    segni    
 
    numero di telefono    
 
 
 Supponiamo che se non siamo a conoscenza del concetto di Arraylist personalizzato in Java, creeremo i singoli ArrayList elencati di seguito. Poiché definiamo 4 ArrayList e salviamo i dati di conseguenza in ciascuno di essi.  
 
 ArrayList   roll = new ArrayList <>(); // roll number  
  ArrayList  name = new ArrayList <>(); // name  
 ArrayList   marks = new ArrayList <>(); // marks  
 ArrayList  phone = new ArrayList <>(); // phone number   
 Ora eseguiremo l'iterazione su ciascuno di essi per recuperare i dati degli studenti aumentando la complessità temporale del nostro programma in misura maggiore, come illustrato di seguito come segue.  
 
 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);   
 }  
 Ora facciamo lo stesso con l'aiuto del concetto appreso sopra implementando lo stesso. Quindi, per costruire il nostro ArrayList personalizzato, esegui i passaggi elencati di seguito come segue:  
 
    Procedura:    La costruzione di ArrayList personalizzati è la seguente:  
 
 
 Costruisci un oggetto ArrayList e inserisci il suo tipo come dati di classe.  
 
 Definire una classe e inserire le entità richieste nel costruttore.  
 
 Collega queste entità alle variabili globali.  
 
 I dati ricevuti da ArrayList sono di quel tipo di classe che memorizza più dati.  
 
 
    Esempio    
 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  );      }   }   
    
  Produzione   
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384 
 
 È possibile creare un ArrayList personalizzato in Java estendendo la classe java.util.AbstractList e implementandone i metodi. Ecco un esempio di come creare un ArrayList personalizzato:  
 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  );      }   }   
    
  Produzione   
CustomArrayList: [1 2 3] 
 
 In questo esempio l'ArrayList personalizzato viene creato estendendo la classe AbstractList e implementando i suoi metodi size get add e delete. L'ArrayList personalizzato ha anche un metodo privato chiamato verifyCapacity che raddoppia la dimensione dell'ArrayList se esaurisce lo spazio.  
 
 Vantaggi dell'utilizzo di un ArrayList personalizzato in Java:  
 
 
 Flessibilità: la creazione di un ArrayList personalizzato ti consente di personalizzare il comportamento dell'ArrayList per soddisfare le esigenze specifiche della tua applicazione.  
 
 Comprensione: creare il tuo ArrayList da zero può aiutarti a capire come funzionano gli ArrayList e come usarli in modo efficace.  
 
 
 Svantaggi dell'utilizzo di un ArrayList personalizzato in Java:  
 
 
 Consumo di tempo: la creazione di un ArrayList personalizzato può richiedere molto tempo e richiede un buon servizio  
 
 
    
         Crea quiz