Antes de continuar, revisemos rápidamente el concepto de matrices y Lista de matrices rápidamente. Entonces, en Java hemos visto que las matrices son estructuras de datos lineales que brindan funcionalidad para agregar elementos de manera continua en el espacio de direcciones de memoria, mientras que ArrayList es una clase que pertenece al marco de la Colección. Ser un buen programador ya es consciente del uso de ArrayList sobre matrices a pesar de conocer las diferencias entre estos dos. Ahora, avanzando incluso con ArrayList, viene una funcionalidad para pasar el tipo de tipo de datos de los elementos que se supone que deben almacenarse en ArrayList, ya sea un objeto cadena entero doble flotante, etc. 

Sintaxis:

 Arraylist  al = new ArrayList  ;  
    Nota:    ArrayList en Java (equivalente al vector en C++) que tiene tamaño dinámico. Se puede reducir o ampliar según el tamaño. ArrayList es parte del marco de la colección y está presente en    paquete java.util    .   
 
    Sintaxis:    
 
 ArrayList   list = new ArrayList  <> ();  
 Lo importante aquí es que E aquí representa un tipo de datos de objeto, ya sea     Entero    aquí. La clase Integer envuelve un valor del tipo primitivo     entero    en un objeto. Un objeto de tipo Integer contiene un único campo cuyo tipo es int. Repase el concepto de    clases contenedoras    en Java antes de seguir adelante, ya que servirá aquí en el backend para aclarar la comprensión si somos conscientes de    conceptos de autoboxing y unboxing    . Esto se debe a que al realizar operaciones sobre elementos en la lista, su sintaxis será diferente, por lo que comprender el concepto se agotará, como supongamos que considere un escenario de agregar elementos a una ArrayList personalizada y observe las diferencias en la sintaxis entre dos de ellos.   
 
    Sintaxis:    
 
 ArrayList        al     = new Arraylist  () ;   
    al.add(1)     ;  
    Sintaxis:    
 
 ArrayList      alobj     = new Arraylist() ;   
    alobj(new Integer(1))     ;  
 Tomemos una ilustración de muestra para percibir lo que se proporciona a continuación de la siguiente manera:  
 
    Ilustración:    
 
   
 
 aquí tenemos todos los elementos del mismo tipo que en general utilizamos a menudo. Ahora propongamos el mismo flujo esquemático. ArrayList simplemente admite múltiples datos de la forma que se muestra en esta imagen.   
 
   
 
  
 En el ArrayList anterior podemos ver claramente que los elementos almacenados son de diferentes tipos. Entonces surge el concepto de          restringiendo. a un solo tipo y no solo esta Lista nos da la flexibilidad de hacer una Lista según nuestro tipo donde tenemos acceso a qué tipo de tipos de datos pueden estar en nuestra ArrayList. Esta lista se conoce como Custom ArrayList en Java     .    Una ArrayList personalizada tiene atributos basados ​​en los requisitos del usuario y puede tener más de un tipo de datos. Estos datos los proporciona una clase interna personalizada que está formada por la combinación de varios tipos de datos de objetos primitivos.  
 
    Implementación:    Consideremos un caso en el que tenemos que tomar la entrada como     norte    El número de estudiantes y los detalles son:   
 
 
    número de rollo    
 
    nombre    
 
    marcas    
 
    número de teléfono    
 
 
 Supongamos que si no conocemos el concepto de Arraylist personalizado en Java, entonces crearíamos ArrayLists individuales que se enumeran a continuación. Como definimos 4 ArrayLists y guardamos los datos en consecuencia en cada uno de ellos.  
 
 ArrayList   roll = new ArrayList <>(); // roll number  
  ArrayList  name = new ArrayList <>(); // name  
 ArrayList   marks = new ArrayList <>(); // marks  
 ArrayList  phone = new ArrayList <>(); // phone number   
 Ahora estaríamos iterando sobre cada uno de ellos para obtener datos de los estudiantes, lo que aumentaría la complejidad temporal de nuestro programa en mayor medida, como se ilustra a continuación.  
 
 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);   
 }  
 Ahora hagamos lo mismo con la ayuda del concepto aprendido anteriormente implementando el mismo. Entonces, para construir nuestra ArrayList personalizada, realice los pasos que se enumeran a continuación de la siguiente manera:  
 
    Procedimiento:    La construcción de ArrayList personalizada es la siguiente:  
 
 
 Cree un objeto ArrayList y coloque su tipo como datos de clase.  
 
 Defina una clase y coloque las entidades requeridas en el constructor.  
 
 Vincula esas entidades a variables globales.  
 
 Los datos recibidos de ArrayList son de ese tipo de clase que almacena múltiples datos.  
 
 
    Ejemplo    
 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  );      }   }   
    
  Producción   
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384 
 
 Se puede crear una ArrayList personalizada en Java extendiendo la clase java.util.AbstractList e implementando sus métodos. A continuación se muestra un ejemplo de cómo puede crear una ArrayList personalizada:  
 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  );      }   }   
    
  Producción   
CustomArrayList: [1 2 3] 
 
 En este ejemplo, la ArrayList personalizada se crea extendiendo la clase AbstractList e implementando sus métodos size get add y remove. El ArrayList personalizado también tiene un método privado llamado sureCapacity que duplica el tamaño del ArrayList si se queda sin espacio.  
 
 Ventajas de utilizar un ArrayList personalizado en Java:  
 
 
 Flexibilidad: la creación de una ArrayList personalizada le permite personalizar el comportamiento de ArrayList para satisfacer las necesidades específicas de su aplicación.  
 
 Comprensión: Crear su propia ArrayList desde cero puede ayudarlo a comprender cómo funcionan las ArrayList y cómo usarlas de manera efectiva.  
 
 
 Desventajas de usar un ArrayList personalizado en Java:  
 
 
 Consumo de tiempo: crear una ArrayList personalizada puede llevar mucho tiempo y requiere una buena  
 
 
    
         Crear cuestionario