Avant d'aller plus loin, révisons rapidement le concept de tableaux et Liste de tableaux rapidement. Ainsi, en Java, nous avons vu que les tableaux sont des structures de données linéaires fournissant des fonctionnalités permettant d'ajouter des éléments de manière continue dans l'espace d'adressage mémoire alors qu'ArrayList est une classe appartenant au framework Collection. En tant que bon programmeur, vous savez déjà utiliser ArrayList sur des tableaux, même si vous connaissez les différences entre ces deux éléments. Maintenant, même avec ArrayList, il existe une fonctionnalité permettant de transmettre le type de type de données des éléments qui sont censés être stockés dans ArrayList, qu'il s'agisse d'une chaîne d'objet entière, double flottant, etc. 

Syntaxe:

 Arraylist  al = new ArrayList  ;  
    Note:    ArrayList en Java (équivalent au vecteur en C++) ayant une taille dynamique. Il peut être réduit ou agrandi en fonction de sa taille. ArrayList fait partie du framework de collection et est présent dans    paquet java.util    .   
 
    Syntaxe:    
 
 ArrayList   list = new ArrayList  <> ();  
 La chose importante ici est que E représente ici un type de données d'objet, imaginez-le     Entier    ici. La classe Integer encapsule une valeur du type primitif     int    dans un objet. Un objet de type Integer contient un seul champ dont le type est int. Parcourez le concept de    cours d'emballage    en Java avant d'aller de l'avant car il servira ici au backend, rendant la compréhension plus claire si nous sommes bien conscients de    concepts d'autoboxing et de unboxing    . En effet, lors de l'exécution d'opérations sur les éléments de la liste, leur syntaxe sera différente, donc la compréhension du concept s'épuisera, comme supposez un scénario d'ajout d'éléments à une ArrayList personnalisée et notez les différences de syntaxe entre deux d'entre eux.   
 
    Syntaxe:    
 
 ArrayList        al     = new Arraylist  () ;   
    al.add(1)     ;  
    Syntaxe:    
 
 ArrayList      alobj     = new Arraylist() ;   
    alobj(new Integer(1))     ;  
 Prenons un exemple d'illustration pour percevoir comme indiqué ci-dessous comme suit :  
 
    Illustration:    
 
   
 
 nous avons ici tous les éléments du même type que nous utilisons en général souvent. Proposons maintenant le même flux schématique, ArrayList prend simplement en charge plusieurs données de la manière indiquée dans cette image.   
 
   
 
  
 Dans l'ArrayList ci-dessus, nous pouvons clairement voir que les éléments stockés sont de types différents. Cela fait donc éclater le concept de          restrictif. à un seul type et non seulement cette liste nous donne la flexibilité de créer une liste selon notre type où nous avons accès au type de types de données qui peuvent être présents dans notre ArrayList. Cette liste est appelée Custom ArrayList en Java     .    Une ArrayList personnalisée possède des attributs basés sur les besoins de l'utilisateur et peut contenir plusieurs types de données. Ces données sont fournies par une classe interne personnalisée formée par la combinaison de divers types de données d'objets primitifs.  
 
    Mise en œuvre:    Prenons un cas où nous devons prendre en compte les entrées comme     N    le nombre d'étudiants et les détails sont :   
 
 
    numéro de rôle    
 
    nom    
 
    marques    
 
    numéro de téléphone    
 
 
 Supposons que si nous ne connaissons pas le concept de liste de tableaux personnalisée en Java, nous créerions des listes de tableaux individuelles répertoriées ci-dessous. Comme nous définissons 4 ArrayLists et enregistrons les données en conséquence dans chacune d'elles.  
 
 ArrayList   roll = new ArrayList <>(); // roll number  
  ArrayList  name = new ArrayList <>(); // name  
 ArrayList   marks = new ArrayList <>(); // marks  
 ArrayList  phone = new ArrayList <>(); // phone number   
 Nous serions maintenant en train de parcourir chacun d'eux pour récupérer les données des étudiants, augmentant ainsi la complexité temporelle de notre programme, comme illustré ci-dessous.  
 
 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);   
 }  
 Faisons maintenant de même avec l'aide du concept appris ci-dessus en le mettant en œuvre. Ainsi, afin de construire notre ArrayList personnalisée, effectuez les étapes ci-dessous comme suit :  
 
    Procédure:    La construction d'une ArrayList personnalisée est la suivante :  
 
 
 Créez un objet ArrayList et placez son type en tant que données de classe.  
 
 Définissez une classe et placez les entités requises dans le constructeur.  
 
 Liez ces entités à des variables globales.  
 
 Les données reçues de ArrayList sont de ce type de classe qui stocke plusieurs données.  
 
 
    Exemple    
 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  );      }   }   
    
  Sortir   
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384 
 
 Une ArrayList personnalisée en Java peut être créée en étendant la classe java.util.AbstractList et en implémentant ses méthodes. Voici un exemple de la façon dont vous pouvez créer une ArrayList personnalisée :  
 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  );      }   }   
    
  Sortir   
CustomArrayList: [1 2 3] 
 
 Dans cet exemple, la ArrayList personnalisée est créée en étendant la classe AbstractList et en implémentant ses méthodes size get add et delete. L'ArrayList personnalisé possède également une méthode privée appelée EnsureCapacity qui double la taille de l'ArrayList si elle manque d'espace.  
 
 Avantages de l'utilisation d'une ArrayList personnalisée en Java :  
 
 
 Flexibilité : la création d'une ArrayList personnalisée vous permet de personnaliser le comportement de l'ArrayList pour répondre aux besoins spécifiques de votre application.  
 
 Compréhension : créer votre propre ArrayList à partir de zéro peut vous aider à comprendre comment fonctionnent les ArrayList et comment les utiliser efficacement.  
 
 
 Inconvénients de l'utilisation d'une ArrayList personnalisée en Java :  
 
 
 Consommation de temps : la création d'une ArrayList personnalisée peut prendre du temps et nécessite une bonne  
 
 
    
         Créer un quiz