Java Academy · Aula

Arrays.fill e copyOf

Preencha e redimensione matrizes

Arrays.fill e copyOf é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Preenchendo arrays

Arrays.fill define todos os elementos de um array como o mesmo valor. Ele modifica o array no próprio lugar e é útil para inicializar ou redefinir dados.

Um preenchimento básico

Preencha um array inteiro com um único valor.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = new int[5];
        Arrays.fill(nums, 7);
        System.out.println(Arrays.toString(nums));
    }
}

Preenchendo um intervalo

Arrays.fill(array, from, to, value) preenche apenas parte do array. O intervalo inclui from e não inclui to.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = new int[6];
        Arrays.fill(nums, 2, 5, 9);
        System.out.println(Arrays.toString(nums));
    }
}

Preenchendo arrays de objetos

fill também funciona em arrays de objetos. Observe que cada posição aponta para a mesma referência quando você preenche o array com um objeto.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] grid = new String[4];
        Arrays.fill(grid, "empty");
        System.out.println(Arrays.toString(grid));
    }
}

Redimensionando com copyOf

Arrays têm comprimento fixo. Para obter um array maior ou menor, Arrays.copyOf(array, newLength) retorna um novo array com o tamanho solicitado.

Aumentando um array

Quando o novo comprimento é maior, as posições extras recebem o valor padrão: 0 para tipos numéricos, false para booleanos e null para objetos.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        int[] bigger = Arrays.copyOf(nums, 5);
        System.out.println(Arrays.toString(bigger));
    }
}

Reduzindo um vetor

Quando o novo comprimento é menor, o vetor é truncado e os elementos finais são descartados.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        int[] smaller = Arrays.copyOf(nums, 3);
        System.out.println(Arrays.toString(smaller));
    }
}

Copiando um intervalo

Arrays.copyOfRange(array, from, to) copia um segmento para um novo vetor. Novamente, from é inclusivo e to é exclusivo.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30, 40, 50};
        int[] middle = Arrays.copyOfRange(nums, 1, 4);
        System.out.println(Arrays.toString(middle));
    }
}

copyOf Não Modifica

Ao contrário de fill, copyOf deixa o vetor original intacto e retorna um vetor completamente novo. O original e a cópia são independentes.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] original = {1, 2, 3};
        int[] copy = Arrays.copyOf(original, 3);
        copy[0] = 99;
        System.out.println("Original: " + Arrays.toString(original));
        System.out.println("Copy:     " + Arrays.toString(copy));
    }
}

Uma Forma Manual de Redimensionar

Antes de ArrayList, os programas aumentavam vetores copiando seus elementos para um vetor maior. copyOf duplica a capacidade em uma única chamada.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] data = {1, 2, 3, 4};
        data = Arrays.copyOf(data, data.length * 2);
        data[4] = 5;
        System.out.println(Arrays.toString(data));
    }
}

fill vs copyOf

Lembre-se da diferença: fill sobrescreve os espaços existentes no próprio vetor e retorna void; copyOf cria uma cópia redimensionada e a retorna. Escolha com base na necessidade ou não de um novo comprimento.

Verificação Rápida

Teste sua compreensão de fill e copyOf.

Recapitulação

Você aprendeu a preencher e redimensionar vetores.

Arrays.fill atribui um único valor a todos os elementos ou a um intervalo deles, no próprio vetor.
Arrays.copyOf retorna um novo vetor com um comprimento determinado, preenchendo ou truncando conforme necessário.
Arrays.copyOfRange copia um segmento.
copyOf não é destrutivo; fill modifica.

Perguntas Frequentes

A aula “Arrays.fill e copyOf” é grátis?

Sim — o texto completo de “Arrays.fill e copyOf” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Arrays.fill e copyOf”?

Preencha e redimensione matrizes Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Arrays.fill e copyOf”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy