Zanim przejdziemy dalej, przyjrzyjmy się szybko koncepcji tablice I Lista tablic szybko. Tak więc w Javie widzieliśmy, że tablice są liniowymi strukturami danych zapewniającymi funkcjonalność ciągłego dodawania elementów w przestrzeni adresowej pamięci, podczas gdy ArrayList jest klasą należącą do frameworka Collection. Będąc dobrym programistą, wiesz już, jak używać ArrayList na tablicach, pomimo znajomości różnic między nimi. Teraz, nawet w przypadku ArrayList dostępna jest funkcja przekazywania typu danych elementów, które mają być przechowywane w ArrayList, niezależnie od tego, czy jest to ciąg obiektowy, liczba całkowita, podwójny float itp. 

Składnia:

 Arraylist  al = new ArrayList  ;  
    Notatka:    ArrayList w Javie (odpowiednik wektora w C++) o dynamicznym rozmiarze. Można go zmniejszyć lub rozszerzyć w zależności od rozmiaru. ArrayList jest częścią struktury kolekcji i jest obecna w    pakiet java.util    .   
 
    Składnia:    
 
 ArrayList   list = new ArrayList  <> ();  
 Ważną rzeczą jest to, że E reprezentuje obiektowy typ danych, jaki sobie wyobrazisz     Liczba całkowita    Tutaj. Klasa Integer otacza wartość typu pierwotnego     wew    w obiekcie. Obiekt typu Integer zawiera jedno pole typu int. Zapoznaj się z koncepcją    klasy wrapperów    w Javie przed przejściem dalej, ponieważ będzie to służyć tutaj, na zapleczu, dzięki czemu zrozumienie będzie jaśniejsze, jeśli będziemy tego świadomi    koncepcje automatycznego pakowania i rozpakowywania    . Dzieje się tak dlatego, że podczas wykonywania operacji na elementach na liście ich składnia będzie się różnić, więc uchwycenie koncepcji wyczerpie się, jak załóżmy, że rozważymy scenariusz dodawania elementów do niestandardowej ArrayList i zwrócimy uwagę na różnice w składni między dwoma z nich.   
 
    Składnia:    
 
 ArrayList        al     = new Arraylist  () ;   
    al.add(1)     ;  
    Składnia:    
 
 ArrayList      alobj     = new Arraylist() ;   
    alobj(new Integer(1))     ;  
 Weźmy przykładową ilustrację, aby postrzegać ją w następujący sposób:  
 
    Ilustracja:    
 
   
 
 tutaj mamy wszystkie elementy tego samego typu, których generalnie często używamy. Zaproponujmy teraz ten sam schematyczny przepływ. ArrayList po prostu obsługuje wiele danych w sposób pokazany na tym obrazku.   
 
   
 
  
 Na powyższej ArrayList wyraźnie widać, że elementy, w których były przechowywane, są różnych typów. Zatem pojawia się koncepcja          ograniczające. do jednego typu, a nie tylko tej listy, daje nam elastyczność tworzenia listy według naszego typu, gdzie mamy dostęp do tego, jakiego rodzaju typy danych mogą znajdować się w naszej ArrayList. Ta lista jest nazywana w języku Java niestandardową listą tablic     .    Niestandardowa lista ArrayList ma atrybuty oparte na wymaganiach użytkownika i może zawierać więcej niż jeden typ danych. Dane te są dostarczane przez niestandardową klasę wewnętrzną, która jest utworzona przez kombinację różnych typów danych obiektów pierwotnych.  
 
    Realizacja:    Rozważmy przypadek, w którym musimy przyjąć dane wejściowe jako     N    liczba uczniów i szczegóły:   
 
 
    numer rolki    
 
    nazwa    
 
    znaki    
 
    numer telefonu    
 
 
 Załóżmy, że jeśli nie jesteśmy świadomi koncepcji niestandardowej listy tablic w Javie, utworzymy poniżej wymienione indywidualne listy tablic. Definiujemy 4 ArrayLists i odpowiednio zapisujemy dane w każdym z nich.  
 
 ArrayList   roll = new ArrayList <>(); // roll number  
  ArrayList  name = new ArrayList <>(); // name  
 ArrayList   marks = new ArrayList <>(); // marks  
 ArrayList  phone = new ArrayList <>(); // phone number   
 Teraz będziemy iterować po każdym z nich, aby pobrać dane uczniów, zwiększając w większym stopniu złożoność czasową naszego programu, jak pokazano poniżej.  
 
 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);   
 }  
 Teraz zróbmy to samo, korzystając z koncepcji poznanej powyżej, wdrażając ją. Aby więc skonstruować naszą niestandardową ArrayList, wykonaj poniższe kroki w następujący sposób:  
 
    Procedura:    Konstruowanie niestandardowej listy ArrayList wygląda następująco:  
 
 
 Zbuduj obiekt ArrayList i umieść jego typ jako Dane klasy.  
 
 Zdefiniuj klasę i umieść wymagane elementy w konstruktorze.  
 
 Połącz te elementy ze zmiennymi globalnymi.  
 
 Dane otrzymane z ArrayList są tego typu klasy, który przechowuje wiele danych.  
 
 
    Przykład    
 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  );      }   }   
    
  Wyjście   
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384 
 
 Niestandardową listę ArrayList w Javie można utworzyć, rozszerzając klasę java.util.AbstractList i implementując jej metody. Oto przykład tworzenia niestandardowej listy ArrayList:  
 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  );      }   }   
    
  Wyjście   
CustomArrayList: [1 2 3] 
 
 W tym przykładzie niestandardowa lista ArrayList jest tworzona poprzez rozszerzenie klasy AbstractList i zaimplementowanie jej metod size get add i Remove. Niestandardowa ArrayList ma również prywatną metodę o nazwie requireCapacity, która podwaja rozmiar ArrayList, jeśli zabraknie miejsca.  
 
 Zalety korzystania z niestandardowej listy ArrayList w Javie:  
 
 
 Elastyczność: utworzenie niestandardowej listy ArrayList umożliwia dostosowanie zachowania listy ArrayList do specyficznych potrzeb aplikacji.  
 
 Zrozumienie: Tworzenie od podstaw własnej listy ArrayList może pomóc w zrozumieniu, jak działa ArrayLists i jak efektywnie z nich korzystać.  
 
 
 Wady korzystania z niestandardowej listy ArrayList w Javie:  
 
 
 Zużycie czasu: Tworzenie niestandardowej listy ArrayList może być czasochłonne i wymaga dobrego  
 
 
    
         Utwórz quiz