Bevor wir fortfahren, lassen Sie uns das Konzept kurz überarbeiten Arrays Und ArrayList schnell. In Java haben wir gesehen, dass Arrays lineare Datenstrukturen sind, die die Funktionalität bieten, Elemente kontinuierlich im Speicheradressraum hinzuzufügen, während ArrayList eine Klasse ist, die zum Collection-Framework gehört. Als guter Programmierer ist man sich der Verwendung von ArrayList anstelle von Arrays bereits bewusst, obwohl man die Unterschiede zwischen diesen beiden kennt. Nun gibt es auch bei ArrayList eine Funktion zum Übergeben des Datentyps von Elementen, die in der ArrayList gespeichert werden sollen, sei es eine Objektzeichenfolge, eine Ganzzahl, ein Double-Float usw. 

Syntax:

 Arraylist  al = new ArrayList  ;  
    Notiz:    ArrayList in Java (entspricht dem Vektor in C++) mit dynamischer Größe. Es kann je nach Größe verkleinert oder erweitert werden. ArrayList ist Teil des Sammlungsframeworks und in vorhanden    java.util-Paket    .   
 
    Syntax:    
 
 ArrayList   list = new ArrayList  <> ();  
 Das Wichtige hier ist, dass E hier einen Objektdatentyp darstellt, stellen Sie sich das vor     Ganze Zahl    Hier. Die Integer-Klasse umschließt einen Wert des primitiven Typs     int    in einem Objekt. Ein Objekt vom Typ Integer enthält ein einzelnes Feld vom Typ int. Gehen Sie das Konzept durch    Wrapper-Klassen    in Java, bevor wir fortfahren, da es hier im Backend dazu dienen wird, das Verständnis zu verdeutlichen, wenn wir uns darüber im Klaren sind    Autoboxing- und Unboxing-Konzepte    . Dies liegt daran, dass bei der Ausführung von Operationen an Elementen in der Liste deren Syntax unterschiedlich ist und sich auch das Verständnis für das Konzept verringert. Stellen Sie sich beispielsweise ein Szenario vor, bei dem Elemente zu einer benutzerdefinierten ArrayList hinzugefügt werden, und beachten Sie die Unterschiede in der Syntax zwischen zwei von ihnen.   
 
    Syntax:    
 
 ArrayList        al     = new Arraylist  () ;   
    al.add(1)     ;  
    Syntax:    
 
 ArrayList      alobj     = new Arraylist() ;   
    alobj(new Integer(1))     ;  
 Nehmen wir eine Beispielillustration, um sie wie folgt wahrzunehmen:  
 
    Illustration:    
 
   
 
 Hier haben wir alle Elemente des gleichen Typs, die wir im Allgemeinen oft verwenden. Lassen Sie uns nun denselben schematischen Fluss vorschlagen. ArrayList unterstützt einfach mehrere Daten auf die in diesem Bild gezeigte Weise.   
 
   
 
  
 In der obigen ArrayList können wir deutlich erkennen, dass die darin gespeicherten Elemente unterschiedlichen Typs sind. Es bricht also das Konzept von aus          einschränkend. auf einen einzelnen Typ und nicht nur auf diese Liste, sondern gibt uns die Flexibilität, eine Liste gemäß unserem Typ zu erstellen, wobei wir Zugriff auf die Art von Datentypen haben, die in unserer ArrayList vorhanden sein können. Diese Liste wird in Java als Custom ArrayList bezeichnet     .    Eine benutzerdefinierte ArrayList verfügt über Attribute, die auf Benutzeranforderungen basieren, und kann mehr als einen Datentyp enthalten. Diese Daten werden von einer benutzerdefinierten inneren Klasse bereitgestellt, die durch die Kombination verschiedener primitiver Objektdatentypen gebildet wird.  
 
    Durchführung:    Stellen Sie sich einen Fall vor, in dem wir Eingaben als annehmen müssen     N    Anzahl der Studierenden und Details sind:   
 
 
    Rollennummer    
 
    Name    
 
    Markierungen    
 
    Telefonnummer    
 
 
 Angenommen, wir kennen das Konzept der benutzerdefinierten Arraylist in Java nicht, dann würden wir die unten aufgeführten einzelnen ArrayLists erstellen. Da wir 4 ArrayLists definieren und in jeder von ihnen entsprechend Daten speichern.  
 
 ArrayList   roll = new ArrayList <>(); // roll number  
  ArrayList  name = new ArrayList <>(); // name  
 ArrayList   marks = new ArrayList <>(); // marks  
 ArrayList  phone = new ArrayList <>(); // phone number   
 Jetzt würden wir jeden von ihnen durchlaufen, um Schülerdaten abzurufen, was die zeitliche Komplexität unseres Programms in größerem Maße erhöht, wie unten dargestellt.  
 
 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);   
 }  
 Lassen Sie uns nun dasselbe mit Hilfe des oben erlernten Konzepts tun, indem wir dasselbe umsetzen. Um unsere benutzerdefinierte ArrayList zu erstellen, führen Sie die unten aufgeführten Schritte wie folgt aus:  
 
    Verfahren:    Die Erstellung einer benutzerdefinierten ArrayList erfolgt wie folgt:  
 
 
 Erstellen Sie ein ArrayList-Objekt und platzieren Sie seinen Typ als Klassendaten.  
 
 Definieren Sie eine Klasse und fügen Sie die erforderlichen Entitäten in den Konstruktor ein.  
 
 Verknüpfen Sie diese Entitäten mit globalen Variablen.  
 
 Die von der ArrayList empfangenen Daten gehören zu dem Klassentyp, der mehrere Daten speichert.  
 
 
    Beispiel    
 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  );      }   }   
    
  Ausgabe   
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384 
 
 Eine benutzerdefinierte ArrayList in Java kann durch Erweitern der Klasse java.util.AbstractList und Implementieren ihrer Methoden erstellt werden. Hier ist ein Beispiel dafür, wie Sie eine benutzerdefinierte ArrayList erstellen können:  
 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  );      }   }   
    
  Ausgabe   
CustomArrayList: [1 2 3] 
 
 In diesem Beispiel wird die benutzerdefinierte ArrayList durch Erweitern der AbstractList-Klasse und Implementieren ihrer Methoden „size get add“ und „remove“ erstellt. Die benutzerdefinierte ArrayList verfügt außerdem über eine private Methode namens „sureCapacity“, die die Größe der ArrayList verdoppelt, wenn nicht mehr genügend Speicherplatz vorhanden ist.  
 
 Vorteile der Verwendung einer benutzerdefinierten ArrayList in Java:  
 
 
 Flexibilität: Durch das Erstellen einer benutzerdefinierten ArrayList können Sie das Verhalten der ArrayList an die spezifischen Anforderungen Ihrer Anwendung anpassen.  
 
 Verstehen: Das Erstellen einer eigenen ArrayList von Grund auf kann Ihnen helfen zu verstehen, wie ArrayLists funktionieren und wie Sie sie effektiv nutzen.  
 
 
 Nachteile der Verwendung einer benutzerdefinierten ArrayList in Java:  
 
 
 Zeitaufwand: Das Erstellen einer benutzerdefinierten ArrayList kann zeitaufwändig sein und erfordert eine gute Arbeit  
 
 
    
         Quiz erstellen