Antes de prosseguirmos, vamos revisar rapidamente o conceito de matrizes e ListaArray rapidamente. Portanto, em Java, vimos que arrays são estruturas de dados lineares que fornecem funcionalidade para adicionar elementos de maneira contínua no espaço de endereço da memória, enquanto ArrayList é uma classe pertencente à estrutura Collection. Sendo um bom programador, você já sabe como usar ArrayList em vez de arrays, apesar de conhecer as diferenças entre os dois. Agora, avançando, mesmo com ArrayList, surge uma funcionalidade para passar o tipo de tipo de dados dos elementos que devem ser armazenados no ArrayList, seja um objeto string inteiro duplo float etc. 

Sintaxe:

 Arraylist  al = new ArrayList  ;  
    Observação:    ArrayList em Java (equivalente a vetor em C++) com tamanho dinâmico. Ele pode ser reduzido ou expandido com base no tamanho. ArrayList faz parte da estrutura de coleção e está presente em    pacote java.util    .   
 
    Sintaxe:    
 
 ArrayList   list = new ArrayList  <> ();  
 O importante aqui é que E aqui representa um tipo de dados de objeto, imagine seja     Inteiro    aqui. A classe Integer envolve um valor do tipo primitivo     interno    em um objeto. Um objeto do tipo Integer contém um único campo cujo tipo é int. Analise o conceito de    classes de wrapper    em java antes de prosseguir pois servirá aqui no backend deixando o entendimento mais claro se estivermos bem cientes    conceitos de autoboxing e unboxing    . Isso ocorre porque, ao executar operações sobre os elementos da lista, sua sintaxe será diferente, então a compreensão do conceito será esgotada, supondo que considere um cenário de adição de elementos ao ArrayList personalizado e observe as diferenças na sintaxe entre dois deles.   
 
    Sintaxe:    
 
 ArrayList        al     = new Arraylist  () ;   
    al.add(1)     ;  
    Sintaxe:    
 
 ArrayList      alobj     = new Arraylist() ;   
    alobj(new Integer(1))     ;  
 Tomemos um exemplo de ilustração para perceber o que é fornecido abaixo:  
 
    Ilustração:    
 
   
 
 aqui temos todos os elementos do mesmo tipo que em geral usamos com frequência. Agora vamos propor o mesmo fluxo diagramático que ArrayList simplesmente suporta vários dados da maneira mostrada nesta imagem.   
 
   
 
  
 No ArrayList acima, podemos ver claramente que os elementos armazenados são de tipos diferentes. Então surge o conceito de          restringindo. para um único tipo e não apenas esta Lista nos dá a flexibilidade de fazer Lista de acordo com nosso tipo, onde temos acesso a que tipo de dados podem estar presentes em nosso ArrayList. Esta lista é conhecida como Custom ArrayList em java     .    Um ArrayList personalizado tem atributos baseados nos requisitos do usuário e pode ter mais de um tipo de dados. Esses dados são fornecidos por uma classe interna personalizada que é formada pela combinação de vários tipos de dados de objetos primitivos.  
 
    Implementação:    Considere um caso em que temos que considerar a entrada como     N    número de alunos e detalhes são:   
 
 
    número do rolo    
 
    nome    
 
    marcas    
 
    número de telefone    
 
 
 Suponha que, se não tivermos conhecimento do conceito de Arraylist customizado em java, estaríamos criando ArrayLists individuais listados abaixo. À medida que definimos 4 ArrayLists e salvamos os dados de acordo em cada um deles.  
 
 ArrayList   roll = new ArrayList <>(); // roll number  
  ArrayList  name = new ArrayList <>(); // name  
 ArrayList   marks = new ArrayList <>(); // marks  
 ArrayList  phone = new ArrayList <>(); // phone number   
 Agora estaríamos iterando cada um deles para buscar os dados dos alunos, aumentando ainda mais a complexidade de tempo do nosso programa, conforme ilustrado abaixo.  
 
 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);   
 }  
 Agora vamos fazer o mesmo com a ajuda do conceito aprendido acima, implementando-o. Portanto, para construir nosso ArrayList personalizado, execute as etapas listadas abaixo:  
 
    Procedimento:    A construção de ArrayList personalizado é a seguinte:  
 
 
 Construa um objeto ArrayList e coloque seu tipo como uma classe de dados.  
 
 Defina uma classe e coloque as entidades necessárias no construtor.  
 
 Vincule essas entidades a variáveis ​​globais.  
 
 Os dados recebidos do ArrayList são daquele tipo de classe que armazena vários dados.  
 
 
    Exemplo    
 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  );      }   }   
    
  Saída   
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384 
 
 Um ArrayList customizado em Java pode ser criado estendendo a classe java.util.AbstractList e implementando seus métodos. Aqui está um exemplo de como você pode criar um ArrayList personalizado:  
 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  );      }   }   
    
  Saída   
CustomArrayList: [1 2 3] 
 
 Neste exemplo, o ArrayList customizado é criado estendendo a classe AbstractList e implementando seus métodos size get add e remove. O ArrayList personalizado também possui um método privado chamado garantirCapacity que dobra o tamanho do ArrayList se ficar sem espaço.  
 
 Vantagens de usar um ArrayList personalizado em Java:  
 
 
 Flexibilidade: a criação de um ArrayList personalizado permite personalizar o comportamento do ArrayList para atender às necessidades específicas do seu aplicativo.  
 
 Compreensão: Criar seu próprio ArrayList do zero pode ajudá-lo a entender como os ArrayLists funcionam e como usá-los de maneira eficaz.  
 
 
 Desvantagens de usar um ArrayList personalizado em Java:  
 
 
 Consumo de tempo: Criar um ArrayList personalizado pode ser demorado e requer uma boa  
 
 
    
         Criar questionário