logo

TechCodeview

ArrayList personalizado em Java

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 . 



apache

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:

ArrayList personalizado em Java

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. 

ArrayList personalizado em Java


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: 

rudyard kipling se explicaçã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:

  1. Construa um objeto ArrayList e coloque seu tipo como uma classe de dados.
  2. Defina uma classe e coloque as entidades necessárias no construtor.
  3. Vincule essas entidades a variáveis ​​globais.
  4. 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:

criação de thread java
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:

  1. Flexibilidade: a criação de um ArrayList personalizado permite personalizar o comportamento do ArrayList para atender às necessidades específicas do seu aplicativo.
  2. 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:

  1. Consumo de tempo: Criar um ArrayList personalizado pode ser demorado e requer uma boa

Criar questionário