Em Java, a seguir estão duas maneiras diferentes de criar um array.

  1. Array : Arrays simples de tamanho fixo que criamos em Java, como abaixo
          int arr [] = novo int [10]
  2. ArrayList : Arrays de tamanho dinâmico em Java que implementam a interface List.
          ArrayList <Type> arrL = new ArrayList <Type>();
      Aqui, Type é o tipo de elemento em ArrayList para
      Ser criado

Diferenças entre Array e ArrayList

  • Um array é uma funcionalidade básica fornecida pelo Java. ArrayList é parte da estrutura de coleção em Java. Portanto, os membros da matriz são acessados ​​usando [], enquanto ArrayList tem um conjunto de métodos para acessar os elementos e modificá-los.




    // A Java program to demonstrate differences between array
    // and ArrayList
    import java.util.ArrayList;
    import java.util.Arrays;
      
    class Test
    {
        public static void main(String args[])
        {
            /* ........... Normal Array............. */
            int[] arr = new int[2];
            arr[0] = 1;
            arr[1] = 2;
            System.out.println(arr[0]);
      
            /*............ArrayList..............*/
            // Create an arrayList with initial capacity 2
            ArrayList<Integer> arrL = new ArrayList<Integer>(2);
      
            // Add elements to ArrayList
            arrL.add(1);
            arrL.add(2);
      
            // Access elements of ArrayList
            System.out.println(arrL.get(0));
        }
    }
    Saída:
    1
1
    .
  • Array é uma estrutura de dados de tamanho fixo, enquanto ArrayList não é. Não é preciso mencionar o tamanho do Arraylist ao criar seu objeto. Mesmo se especificarmos alguma capacidade inicial, podemos adicionar mais elementos.



    // A Java program to demonstrate differences between array
    // and ArrayList
    import java.util.ArrayList;
    import java.util.Arrays;
    class Test
    {
        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 
            ArrayList<Integer> arrL = new ArrayList<Integer>();
            arrL.add(1);
            arrL.add(2);
            arrL.add(3);
            arrL.add(4);
            // We can add more elements to arrL
      
            System.out.println(arrL);
            System.out.println(Arrays.toString(arr));
        }
    }
    Saída:
    [1, 2, 3, 4]
[1, 2, 3]
    .
  • Array pode conter tanto tipos de dados primitivos quanto objetos de uma classe, dependendo da definição do array. No entanto, ArrayList suporta apenas entradas de objeto, não os tipos de dados primitivos. 
    Nota: Quando fazemos arraylist.add (1); : converte o tipo de dados int primitivo em um objeto Integer. Código de amostra:



    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<>();
        }
    }
    .
  • Uma vez que ArrayList não pode ser criado para tipos de dados primitivos, os membros de ArrayList são sempre referências a objetos em diferentes localizações de memória (veja isto para obter detalhes). Portanto, em ArrayList, os objetos reais nunca são armazenados em locais contíguos. As referências dos objetos reais são armazenadas em locais contíguos. 
    Em array, depende se os arrays são do tipo primitivo ou do tipo de objeto. No caso de tipos primitivos, os valores reais são localizações contíguas, mas no caso de objetos, a alocação é semelhante a ArrayList.
  • Java ArrayList suporta muitas operações adicionais como indexOf() , remove() , etc. Essas funções não são suportadas por Arrays.


Como observação lateral, ArrayList em Java pode ser visto como semelhante ao vetor em C++ .


Este artigo é uma contribuição de Pranjal Mathur . Se você gosta de GeeksforGeeks e gostaria de contribuir, você também pode escrever um artigo e enviá-lo para contrib@geeksforgeeks.org. Veja o seu artigo na página principal do GeeksforGeeks e ajude outros Geeks.


Escreva comentários se encontrar algo incorreto ou se quiser compartilhar mais informações sobre o tópico discutido acima