Array vs ArrayList en Java

Analicemos el concepto de arrays y ArrayList brevemente en el encabezado para incorporar la comprensión en los programas de Java y luego aterrizar en las diferencias concluyentes entre ellos. Como todos sabemos, 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. 

Nota: Como nota al margen, ArrayList en Java puede verse como un vector en C++ . 

Métodos de creación de arrays

En Java, las siguientes son dos formas diferentes de crear una array. 

1. Arreglos simples de tamaño fijo
2. Arrays de tamaño dinámico

int arr[] = new int[10]   

Sintaxis: declarar una array estática 

Se puede definir además por dos tipos:

• Tipo 1 : declaración e inicialización al mismo tiempo
• Tipo 2: declarar que inicializar elementos más tarde.

 Tipo 1

Type array_name [array_size] ;
Type array_name = { Element1, Element2, Element3, Element4,...., ElementN } ;
// It is preferable if we have very limited array elements 

Tipo 2

int arr [100] ;
// This does means we are declaring a memory block named 'arr' 
// which is containing continuous 100 block associated in it

Nota: arr(0) devuelve el primer elemento de la array, por lo que significa que si tratamos de imprimir arr(0), obtendremos el Elemento1. Es una declaración muy importante y se deja sin revelar cuando se trata de una comprensión profunda del almacenamiento de memoria en arreglos.

Ahora detengámonos en el siguiente concepto de ArrayList que es el siguiente 

Sintaxis: declaración de una lista de arreglos

Arraylist<Type> al = new ArrayList<Type> ;
// Here Type is the type of elements in ArrayList to be created

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 . 

Ahora permítanos ilustrar ejemplos con la ayuda de las diferencias entre Array y ArrayList 

Base 1: una array es una funcionalidad básica proporcionada por Java. ArrayList es parte del marco de colección en Java. Por lo tanto, se accede a los miembros de la array usando [], mientras que ArrayList tiene un conjunto de métodos para acceder a los elementos y modificarlos. 

Ejemplo:

// Java program to demonstrate differences between
// Array and ArrayList
 
// Importing required classes
import java.util.ArrayList;
import java.util.Arrays;
 
// Main class
class GFG {
   
    // Main driver method
    public static void main(String args[])
    {
        // Input array
        int[] arr = new int[2];
        arr[0] = 1;
        arr[1] = 2;
 
        // Printing first element of array
        System.out.println(arr[0]);
 
        // ArrayList
        // Creating an arrayList with initial capacity
        // say bi it 2
        ArrayList<Integer> arrL = new ArrayList<Integer>(2);
 
        // Adding elements to ArrayList
        // using add() method
        arrL.add(1);
        arrL.add(2);
 
        // Printing alongside accessing
        // elements of ArrayList
        System.out.println(arrL.get(0));
    }
}

1
1

Base 2: la array es una estructura de datos de tamaño fijo, mientras que ArrayList no lo es. No es necesario mencionar el tamaño de ArrayList al crear su objeto. Incluso si especificamos alguna capacidad inicial, podemos agregar más elementos.

Ejemplo:

// Java program to demonstrate differences between
// Array and ArrayList
 
// Importing required classes
import java.util.ArrayList;
import java.util.Arrays;
 
// Main class
class GFG {
    // Main driver method
    public static void main(String args[])
    {
        // Normal Array
        // Need to specify the size for array
        int[] arr = new int[3];
        arr[0] = 1;
        arr[1] = 2;
        arr[2] = 3;
 
        // We cannot add more elements to array arr[]
 
        // ArrayList
        // Need not to specify size
 
        // Declaring an Arraylist of Integer type
        ArrayList<Integer> arrL = new ArrayList<Integer>();
 
        // Adding elements to ArrayList object
        arrL.add(1);
        arrL.add(2);
        arrL.add(3);
        arrL.add(4);
 
        // We can add more elements to arrL
 
        // Print and display Arraylist elements
        System.out.println(arrL);
        // Print and display array elements
        System.out.println(Arrays.toString(arr));
    }
}

[1, 2, 3, 4]
[1, 2, 3]

Base 3: una array puede contener tanto tipos de datos primitivos como objetos de una clase según la definición de la array. Sin embargo, ArrayList solo admite entradas de objetos, no los tipos de datos primitivos. 

Nota: Cuando hacemos arraylist.add(1), convierte el tipo de datos int primitivo en un objeto Integer, como se ilustra en el siguiente ejemplo.

Ejemplo:

import java.util.ArrayList;
class Test
{
    public static void main(String args[])
    {
       // allowed
        int[] array = new int[3];
 
        // allowed, however, need to be initialized
        Test[] array1 = new Test[3];
 
        // not allowed (Uncommenting below line causes
        // compiler error)
        // ArrayList<char> arrL = new ArrayList<char>();
 
        // Allowed
        ArrayList<Integer> arrL1 = new ArrayList<>();
        ArrayList<String> arrL2 = new ArrayList<>();
        ArrayList<Object> arrL3 = new ArrayList<>();
       
        System.out.println("Successfully compiled and executed");
    }
}

Successfully compiled and executed

Base 4: dado que ArrayList no se puede crear para tipos de datos primitivos, los miembros de ArrayList siempre son referencias a objetos en diferentes ubicaciones de memoria (consulte esto para obtener más detalles). Por lo tanto, en ArrayList, los objetos reales nunca se almacenan en ubicaciones contiguas. Las referencias de los objetos reales se almacenan en ubicaciones contiguas. 

Por otro lado, en el arreglo, depende si el arreglo es de tipo primitivo o de tipo objeto. En el caso de los tipos primitivos, los valores reales son ubicaciones contiguas, pero en el caso de los objetos, la asignación es similar a ArrayList. Java ArrayList admite muchas operaciones adicionales como indexOf(), remove() , etc. Arrays no admite estas funciones.

Hemos implementado y visto las diferencias entre ellos como se perciben a partir de los resultados. Ahora terminemos el artículo trazando diferencias concluyentes en un formato tabular como se muestra a continuación de la siguiente manera:

Este artículo es una contribución de Pranjal Mathur . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo y enviarlo 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.