ArrayList personalizado en Java

Antes de continuar, revisemos rápidamente el concepto de arrays y ArrayList rápidamente. Entonces, en Java, hemos visto que las arrays son estructuras de datos lineales que brindan funcionalidad para agregar elementos de manera continua en el espacio de direcciones de la memoria, mientras que ArrayList es una clase que pertenece al marco Collection. Al ser un buen programador, uno ya sabe usar ArrayList sobre arreglos a pesar de conocer las diferencias entre estos dos. Ahora, avanzando, incluso con ArrayList, viene una funcionalidad para pasar el tipo de tipo de datos de los elementos que se supone que deben almacenarse en ArrayList, ya sea un objeto, string, entero, doble, flotante, etc. 

Sintaxis:

Arraylist<DataType> al = new ArrayList<Datatype> ;

Nota: ArrayList en Java (equivalente a vector en C++) con tamaño dinámico. Se puede encoger o expandir según el tamaño. ArrayList es parte del marco de la colección y está presente en el paquete java.util . 

Sintaxis:

ArrayList <E> list = new ArrayList <> ();

Lo importante aquí es que E aquí representa un tipo de datos de objeto, imagínate que sea Integer aquí. La clase Integer envuelve un valor del tipo primitivo int en un objeto. Un objeto de tipo Integer contiene un solo campo cuyo tipo es int. Examine el concepto de clases contenedoras en Java antes de seguir adelante, ya que servirá aquí en el backend, lo que hará que la comprensión sea más clara si somos conscientes de los conceptos de autoboxing y unboxing . Se debe a que, al realizar operaciones sobre elementos en la lista, su sintaxis será diferente, por lo que la comprensión del concepto se agotará, ya que supongamos que considera un escenario de agregar elementos a ArrayList personalizado y observe las diferencias en la sintaxis entre dos de ellos. 

Sintaxis:

ArrayList<Integer> al = new Arraylist<Integer>() ;
al.add(1) ;

Sintaxis:

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

Tomemos una ilustración de muestra para percibir lo que se proporciona a continuación de la siguiente manera:

Ilustración:

aquí tenemos todos los elementos del mismo tipo que en general solemos usar. Ahora propongamos el mismo flujo esquemático ArrayList simplemente admite múltiples datos en la forma que se muestra en esta imagen. 

En el ArrayList anterior, podemos ver claramente que los elementos almacenados son de diferentes tipos. Así que surge el concepto de restricción. a un solo tipo y no solo esta lista nos da la flexibilidad de hacer una lista según nuestro tipo donde tenemos acceso a qué tipo de datos puede haber en nuestro ArrayList. Esta lista se conoce como Custom ArrayList en java . Una ArrayList personalizada tiene atributos basados ​​en los requisitos del usuario y puede tener más de un tipo de datos. Estos datos son proporcionados por una clase interna personalizada que está formada por la combinación de varios tipos de datos de objetos primitivos.

Implementación: Considere un caso en el que tenemos que tomar la entrada como N número de estudiantes y los detalles son: 

• número de rollo
• nombre
• marcas
• número de teléfono

Supongamos que si no conocemos el concepto de Arraylist personalizado en Java, entonces estaríamos haciendo ArrayLists individuales enumerados a continuación. Como definimos 4 ArrayLists y guardamos datos en consecuencia en cada uno de ellos.

ArrayList<Integer> roll = new ArrayList<>();  // roll number

 ArrayList<String> name = new ArrayList<>(); // name

ArrayList<Integer> marks = new ArrayList<>(); //  marks

ArrayList<Long> phone = new ArrayList<>();  // phone number 

Ahora estaríamos iterando sobre cada uno de ellos para obtener datos de los estudiantes aumentando la complejidad de tiempo de nuestro programa en mayor medida, como se ilustra a continuación.

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

Ahora hagamos lo mismo con la ayuda del concepto aprendido anteriormente implementando el mismo. Entonces, para construir nuestra ArrayList personalizada, realice los pasos enumerados a continuación de la siguiente manera:

Procedimiento: la construcción de ArrayList personalizado es la siguiente:

1. Cree un objeto ArrayList y coloque su tipo como datos de clase.
2. Defina una clase y coloque las entidades requeridas en el constructor.
3. Vincule esas entidades a variables globales.
4. Los datos recibidos de ArrayList son de ese tipo de clase que almacena múltiples datos.

Ejemplo

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

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

Este artículo es una contribución de Shubham Saxena . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.