Preencher um array em Java

  2. HowTo
  3. Java Howtos
  4. Preencher um array em Java
Mohd Ebad Naqvi 12 outubro 2023
Java Java Array
  1. Use { } para preencher um array em Java
  2. Use o loop for para preencher um array em Java
  3. Use o método Arrays.copyOf() para preencher o elemento em um array Java
  4. Use o método Arrays.fill() para preencher elementos em um array Java
Preencher um array em Java

Com base na definição do usuário, o array será primitivo, ou as referências de objeto (ou não primitivas) de uma classe.

Em um array de tipo de dados primitiva, os elementos são armazenados em um local de memória contíguo. Em contraste, em um tipo de dados não primitivo, os elementos são armazenados na memória dinâmica (segmento Heap).

Neste tutorial, populamos um array em Java. Preencher aqui significa preencher o array com alguns valores.

Use { } para preencher um array em Java

É o método básico e um dos métodos mais simples de preencher um array. Chaves Curly {} são usadas para definir os elementos de um array.

Por exemplo,

import java.util.*;
public class Num {
  public static void main(String args[]) {
    int arr[] = {1, 3, 5, 7, 11}; // Declaration of elements using { }

    for (int j = 0; j < arr.length; j++) {
      System.out.print(array[j] + " ");
    }
  }
}

Resultado:

1 3 5 7 11

Use o loop for para preencher um array em Java

A classe Scanner é usada para varrer os elementos do array do usuário. Executamos um loop até que o comprimento do usuário e usando o objeto dos elementos da classe Scanner sejam inseridos em cada iteração.

Veja o seguinte código.

import java.util.Scanner;
public class ArrayInputUsingLoop {
  public static void main(String[] args) {
    int number;
    Scanner obj = new Scanner(System.in);
    System.out.print("Total number of elements: ");
    number = obj.nextInt();
    int[] array = new int[20];
    System.out.println("Enter the elements of the array: ");
    for (int i = 0; i < number; i++) {
      array[i] = obj.nextInt(); // reads elements from the user
    }
    System.out.println("Array elements you entered are: ");
    for (int i = 0; i < number; i++) {
      System.out.println(array[i]);
    }
  }
}

Resultado:

Total number of elements: 5
Enter the elements of the array: 
5
4
3
2
1
Array elements you entered are: 
5
4
3
2
1

Use o método Arrays.copyOf() para preencher o elemento em um array Java

O método Array.copyOf() pertence à classe java.util.Arrays. Esta função copia a matriz específica e a trunca com zeros ou valores nulos, se necessário, para manter o comprimento fornecido do array de cópia.

Haverá valores idênticos para todos os índices válidos no array original e copiado.

Por exemplo,

import java.util.Arrays;

public class Main {
  public static void main(String[] args) {
    int[] array1 = new int[] {8, 9, 10, 11, 12};

    System.out.println("First array is:");
    for (int i = 0; i < array1.length; i++) {
      System.out.println(array1[i]);
    }

    int[] array2 = Arrays.copyOf(array1, 7);
    array2[5] = 6;
    array2[6] = 7;

    System.out.println("New array after copying elements is:");
    for (int i = 0; i < array2.length; i++) {
      System.out.println(array2[i]);
    }
  }
}

Resultado:

First array is:
8
9
10
11
12
New array after copying elements is:
8
9
10
11
12
6
7

Se o comprimento exceder a matriz original, os elementos extras serão compensados ​​com valor 0.

Por exemplo,

import java.util.Arrays;

public class ArrayCopy {
  public static void main(String args[]) {
    int[] originalarray = new int[] {7, 8, 9};
    System.out.println("The Original Array is : \n");
    for (int i = 0; i < originalarray.length; i++) System.out.print(originalarray[i] + " ");

    int[] copyarray = Arrays.copyOf(originalarray, 5);

    System.out.print("\nNew Array copy of greater length is:\n");
    for (int i = 0; i < copyarray.length; i++) System.out.print(copyarray[i] + " ");
  }
}

Resultado:

The Original Array is : 
7 8 9 
New Array copy of greater length is:
7 8 9 0 0

Use o método Arrays.fill() para preencher elementos em um array Java

O método Arrays.fill() pertence à classe java.util.Arrays.

Usando este método, podemos substituir todos os elementos em um determinado array pelo elemento recém-inserido. Todas as posições do array serão substituídas ou preenchidas pelo elemento de valor especificado.

Por exemplo,

import java.util.Arrays;

public class ArrayFill {
  public static void main(String[] args) {
    int array[] = {6, 7, 8, 9, 10};

    Arrays.fill(array, 5);
    System.out.println(Arrays.toString(array));
  }
}

Resultado:

[5, 5, 5, 5, 5]

A matriz original pode ser preenchida parcialmente pelos novos elementos, especificando o índice.

Por exemplo,

import java.util.Arrays;

public class ArrayFill2 {
  public static void main(String[] args) {
    int array[] = {7, 8, 9, 10, 11};

    Arrays.fill(array, 2, 5, 0); // Replace elements from index 2 to index 4 by 0

    System.out.println(Arrays.toString(array));
  }
}

Resultado:

[7, 8, 0, 0, 0]

Artigo relacionado - Java Array