logo

TechCodeview

Aangepaste ArrayList in Java

Voordat we verder gaan, moeten we eerst even het concept van de arrays En ArrayLijst snel. Dus in Java hebben we gezien dat arrays lineaire datastructuren zijn die functionaliteit bieden om elementen op een continue manier toe te voegen aan de geheugenadresruimte, terwijl ArrayList een klasse is die behoort tot het Collection-framework. Als goede programmeur ben je al op de hoogte van het gebruik van ArrayList over arrays, ondanks dat je de verschillen tussen deze twee kent. Nu we verder gaan, zelfs met ArrayList, komt er een functionaliteit om het type datatype van elementen door te geven dat in de ArrayList zou moeten worden opgeslagen, of het nu een objectstring geheel getal dubbele float enz. is. 

Syntaxis: 

Arraylist al = new ArrayList ;

Opmerking: ArrayList in Java (equivalent aan vector in C++) met dynamische grootte. Het kan worden verkleind of uitgebreid op basis van de grootte. ArrayList maakt deel uit van het verzamelingsframework en is aanwezig in java.util-pakket . 



Syntaxis: 

ArrayList  list = new ArrayList <> ();

Het belangrijkste hier is dat E hier een objectdatatype vertegenwoordigt, stel je voor dat het zo is Geheel getal hier. De klasse Integer omhult een waarde van het primitieve type int in een voorwerp. Een object van het type Integer bevat één veld waarvan het type int is. Neem het concept door van wrap klassen in Java voordat we verder gaan, omdat het hier aan de achterkant zal dienen om het begrip duidelijker te maken als we ons er goed van bewust zijn autoboxing- en unboxing-concepten . Het is omdat tijdens het uitvoeren van bewerkingen op elementen in de lijst hun syntaxis zal verschillen, zodat het begrip over het concept zal afnemen, bijvoorbeeld als u een scenario overweegt waarin u elementen aan aangepaste ArrayList toevoegt en de verschillen in syntaxis tussen twee ervan opmerkt. 

Syntaxis:

watermerk in woord 
ArrayList       al    = new Arraylist  () ;  
    al.add(1)    ;

Syntaxis: 

ArrayList     alobj    = new Arraylist() ;  
    alobj(new Integer(1))    ;

Laten we een voorbeeldillustratie nemen om het hieronder als volgt waar te nemen:

Illustratie:

Aangepaste ArrayList in Java

hier hebben we alle elementen van hetzelfde type die we over het algemeen vaak gebruiken. Laten we nu dezelfde schematische stroom voorstellen. ArrayList ondersteunt eenvoudigweg meerdere gegevens op de manier die in deze afbeelding wordt weergegeven. 

Aangepaste ArrayList in Java


In de bovenstaande ArrayList kunnen we duidelijk zien dat de elementen waarin zijn opgeslagen van verschillende typen zijn. Dus het barst los van het concept van beperkend. naar een enkel type en niet alleen deze lijst geeft ons de flexibiliteit om een ​​lijst te maken volgens ons type, waarbij we toegang hebben tot wat voor soort gegevenstypen er in onze ArrayList kunnen voorkomen. Deze lijst wordt in Java Custom ArrayList genoemd . Een aangepaste ArrayList heeft kenmerken die zijn gebaseerd op gebruikersvereisten en kan meer dan één gegevenstype bevatten. Deze gegevens worden geleverd door een aangepaste innerlijke klasse die wordt gevormd door de combinatie van verschillende primitieve objectgegevenstypen.

Uitvoering: Beschouw een geval waarin we input moeten nemen als N aantal studenten en details zijn: 

  • rolnummer
  • naam
  • merken
  • telefoonnummer

Stel dat als we ons niet bewust zijn van het concept van aangepaste Arraylist in Java, we de onderstaande individuele ArrayListen zouden maken. Terwijl we 4 ArrayLists definiëren en gegevens dienovereenkomstig in elk ervan opslaan.

ArrayList   roll = new ArrayList<>(); // roll number
 ArrayList name = new ArrayList<>(); // name
ArrayList   marks = new ArrayList<>(); // marks
ArrayList phone = new ArrayList<>(); // phone number

Nu zouden we elk van deze herhalen om leerlinggegevens op te halen, waardoor de tijdscomplexiteit van ons programma in grotere mate toeneemt, zoals hieronder als volgt wordt geïllustreerd.

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);  
}

Laten we nu hetzelfde doen met behulp van het hierboven geleerde concept door hetzelfde te implementeren. Dus om onze aangepaste ArrayList samen te stellen, voert u de onderstaande stappen als volgt uit:

Procedure: Het construeren van een aangepaste ArrayList gaat als volgt:

  1. Bouw een ArrayList-object en plaats het type ervan als Class Data.
  2. Definieer een klasse en plaats de vereiste entiteiten in de constructor.
  3. Koppel deze entiteiten aan globale variabelen.
  4. Gegevens ontvangen van de ArrayList zijn van dat klassetype waarin meerdere gegevens worden opgeslagen.

Voorbeeld

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);  } }

Uitvoer 
1 Shubham 100 8762357381 2 Atul 99 8762357382 3 Ayush 93 8762357383 4 Rupesh 94 8762357384

Een aangepaste ArrayList in Java kan worden gemaakt door de klasse java.util.AbstractList uit te breiden en de methoden ervan te implementeren. Hier is een voorbeeld van hoe u een aangepaste ArrayList kunt maken:

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);  } }

Uitvoer 
CustomArrayList: [1 2 3]

In dit voorbeeld wordt de aangepaste ArrayList gemaakt door de klasse AbstractList uit te breiden en de methoden size get add en remove te implementeren. De aangepaste ArrayList heeft ook een privémethode genaamd sureCapacity, die de grootte van de ArrayList verdubbelt als er onvoldoende ruimte is.

Voordelen van het gebruik van een aangepaste ArrayList in Java:

  1. Flexibiliteit: Door een aangepaste ArrayList te maken, kunt u het gedrag van de ArrayList aanpassen aan de specifieke behoeften van uw toepassing.
  2. Begrijpen: Door uw eigen ArrayList helemaal opnieuw te maken, kunt u beter begrijpen hoe ArrayLists werken en hoe u ze effectief kunt gebruiken.

Nadelen van het gebruik van een aangepaste ArrayList in Java:

  1. Tijdverbruik: het maken van een aangepaste ArrayList kan tijdrovend zijn en vereist een goede voorbereiding

Quiz maken