Menu

Array Java - declarar, criar e inicializar um array em Java

  • Principal
  • Outro
  • Array Java - declarar, criar e inicializar um array em Java

java array declare

Experimente Nosso Instrumento Para Eliminar Problemas

Este tutorial detalhado explica várias maneiras de declarar, criar e inicializar um novo array com valores em Java com a ajuda de exemplos de código simples:

Em nosso tutorial anterior, discutimos os conceitos básicos de arrays em Java junto com os diferentes conceitos associados a arrays que aprenderemos em detalhes nesta série de tutoriais.

A primeira e mais importante etapa com matrizes é criá-las. Você precisa estar ciente de quais tipos de elementos e quantos elementos você armazenará em matrizes. Depois de declarar uma matriz, você pode querer inicializá-la fornecendo alguns valores iniciais e há vários métodos para fazer isso.

Declare criar array Java

Portanto, neste tutorial, vamos nos concentrar na criação e inicialização de arrays antes de passar para outros conceitos.

O que você aprenderá:

Como declarar um array em Java?

Em Java, uma matriz unidimensional é declarada de uma das seguintes maneiras:

data_type() array_name; {or} data_type array_name(); {or} data_type ()array_name;

Aqui, o ‘data_type’ especifica o tipo de dados que a matriz conterá. O ‘data_type’ pode ser um tipo de dados primitivo ou qualquer tipo derivado.

Por exemplo, uma matriz myarray do tipo inteiro é declarado da seguinte maneira:

int () myarray;
OU
int () myarray;
OU
int myarray ();

Isso significa que o array myarray conterá os elementos do tipo de dados int.

Observe que, como os arrays em Java são alocados dinamicamente, não especificamos nenhuma dimensão ou tamanho do array com a declaração. A declaração acima informa ao compilador que existe uma variável de matriz ‘myarray’ do tipo int que armazenará os valores do tipo inteiro nela.

O compilador não sabe o tamanho ou os valores reais armazenados em uma matriz. Ele só saberá disso depois de inicializarmos o array.

Instanciar e inicializar um array Java

Já declaramos um array na seção anterior. Mas isso é apenas uma referência. Para usar a variável de array declarada acima, você precisa instanciá-la e fornecer valores para ela. O array é instanciado usando ‘new’.

A sintaxe geral de instanciação é a seguinte:

array_name = new data_type (size);

Na instrução acima, array_name é o nome do array que está sendo instanciado.

data_type=> type of elements the array is going to store size=> the number of elements that will be stored in array

Portanto, quando você usa new com o array, na verdade está alocando o array com o tipo de dados e o número de elementos.

Portanto, o array myarray declarado acima pode ser instanciado da seguinte maneira:

myarray = new int(10)

Assim, a criação de uma matriz em Java envolve duas etapas, conforme mostrado abaixo:

int() myarray; //declaration myarray = new int(10); //instantiation

Depois que a matriz é criada, você pode inicializá-la com os seguintes valores:

myarray(0) = 1; myarray(1) = 3; ….and so on until all elements are initialized.

A expressão entre colchetes acima é chamada de índice da matriz. O índice da matriz é usado para acessar o valor real dos elementos, ou seja, a matriz acima myarray de 10 elementos int terá índices numerados de 0 a 9. Você pode acessar o elemento da matriz em uma posição particular especificando o índice como acima.

Observe que o índice do array sempre começa em 0. Alternativamente, você também pode fazer a inicialização usando um loop que veremos mais tarde.

Você também pode usar o literal de array e inicializar o array durante a própria declaração, conforme mostrado abaixo:

int() myarray = {1,3,5,7};

Na declaração acima, o comprimento da matriz é determinado pelo número de elementos. Além disso, como você pode ver, não há necessidade de usar 'novo'. Mais importante, a declaração, a instanciação e a inicialização do array são feitas em uma única instrução.

A seguir, é fornecido um exemplo de programação simples de declaração e inicialização do array.

public class Main { public static void main(String() args) { int() myarray; //declaration myarray = new int(5); //instantiation myarray(0) = 10; //initialization System.out.println('myarray(0) = ' + myarray(0)); //accessing and printing array elements System.out.println('myarray(1) = ' + myarray(1)); int () oddArray = {1,3,5,7}; //initialization with array literal System.out.println('oddArray(0) = ' + oddArray(0)); System.out.println('oddArray(1) = ' + oddArray(1)); System.out.println('oddArray(2) = ' + oddArray(2)); System.out.println('oddArray(3) = ' + oddArray(3)); } }

Resultado:

Declarando e inicializando o array_output

Este programa demonstrou uma declaração de array e sua instanciação, bem como inicialização. Observe que, como apenas inicializamos o oºvalor de myarray, o outro valor myarray (1) que é impresso tem um valor padrão, ou seja, 0.

A segunda matriz demonstra a variável literal da matriz. Mesmo se você não inicializar o array, o compilador Java não dará nenhum erro. Normalmente, quando a matriz não é inicializada, o compilador atribui valores padrão a cada elemento da matriz de acordo com o tipo de dados do elemento.

Demonstraremos esses valores padrão usando o programa a seguir.

class Main { public static void main(String() args) { System.out.println('=======Default Values======'); System.out.print('String Array:'); String() array_str = new String(5); //declaration and instantiation for (String str : array_str) //assumes default values System.out.print(str + ' '); System.out.println(' '); System.out.print('Integer array:'); //array only instantiated not initialized int() array_num = new int(5); for (intnum : array_num) System.out.print(num + ' '); System.out.println(' '); System.out.print('Double array:'); //array only instantiated not initialized doublearray_double() = new double(5); for (double dnum : array_double) System.out.print(dnum + ' '); System.out.println(' '); System.out.print('Boolean array:'); //array only instantiated not initialized booleanarray_bool() = new boolean(5); for (booleanbval : array_bool) System.out.print(bval + ' '); System.out.println(' '); } }

Resultado:

valores padrão_ saída

No programa acima, nós apenas os declaramos e instanciamos. Não os inicializamos com nenhum valor. Assim, quando exibimos o conteúdo dessas matrizes, dependendo do tipo de dados da matriz, os elementos terão valores padrão diferentes.

Como visto acima, a matriz de string tem o padrão como ‘nulo’, os valores inteiros são 0 e os valores duplos padrão são 0,0. Os valores booleanos têm seus valores padrão definidos como falsos.

Inicializando e acessando elementos do array

# 1) Usando For Loop

O programa escrito acima usa um literal de array para inicializar e os outros elementos do array são inicializados separadamente. Você também pode usar o loop for para inicializar os elementos do array.

Nós convertemos o array acima usando o literal do array para inicializá-lo usando o loop for no programa abaixo.

public class Main { public static void main(String() args) { int() oddArray; //declaration oddArray = new int(5); //instantiation for(int i=0;i<5;i++){ oddArray(i) = i+1; //initialization using for loop } System.out.println('oddArray(0) = ' + oddArray(0)); System.out.println('oddArray(1) = ' + oddArray(1)); System.out.println('oddArray(2) = ' + oddArray(2)); System.out.println('oddArray(3) = ' + oddArray(3)); System.out.println('oddArray(4) = ' + oddArray(4)); } }

Resultado:

Array literal para inicializá-lo usando for_loop

saída de entrada de arquivo c ++

Aqui, como você pode ver, inicializamos o array usando o loop for. Cada elemento ‘i’ da matriz é inicializado com valor = i + 1. Além de usar o método acima para inicializar arrays, você também pode usar alguns dos métodos da classe ‘Arrays’ do pacote ‘java.util’ para fornecer valores iniciais para o array.

Discutiremos alguns desses métodos a seguir.

# 2) Usando Arrays.fill ()

O método fill () da classe ‘Arrays’ pode ser usado para inicializar a matriz. Quando você inicializa uma matriz usando este método, a matriz é preenchida com os mesmos valores em todos os índices.

A seguir está o exemplo de programação.

import java.util.*; public class Main { public static void main(String() args) { int() oddArray; oddArray = new int(5); //fill the array with value 30 Arrays.fill(oddArray, 30); System.out.println('Array Elements initialised with Arrays.fill:'); for(int i=0;i<5;i++) System.out.println('oddArray(' + i +') = ' + oddArray(i)); } }

Resultado:

Método de preenchimento de Arrays_class

No programa acima, fornecemos 30 como o valor a ser preenchido para a matriz. A saída mostra que todos os elementos da matriz têm o valor 30.

# 3) Usando Arrays.copyOf ()

Usando o método ‘copyOf ()’, usamos uma matriz de origem e, em seguida, copiamos seus valores em uma nova matriz. Você pode especificar quantos valores devem ser copiados e, em seguida, os elementos restantes da matriz terão valores padrão.

Verifique o seguinte programa.

import java.util.*; public class Main { public static void main(String() args) { int evenArray() = { 2,4,6,8,10 }; //copy contents of evenArray to copyof_Array int() copyof_Array = Arrays.copyOf(evenArray,5); System.out.println('Array Elements initialised with Arrays.copyOf:'); //print the array elements for(int i=0;i<5;i++) System.out.println('copyof_Array(' + i +') = ' + copyof_Array(i)); } }

Resultado:

Using_Arrays.copyOf

Neste programa, usamos uma matriz de origem chamada ‘evenArray’. Usando o método copyOf, copiamos todos os elementos de evenArray para o novo array. Na saída, exibimos o conteúdo do novo array, que é o mesmo que evenArray.

Além dos dois métodos acima, acabamos de discutir que existem mais métodos como o método setAll () da classe Arrays e o método clone () de ArrayUtils que podem ser usados ​​para inicializar arrays. Vamos abordar esses métodos posteriormente nesta série de tutoriais nos respectivos tópicos.

perguntas frequentes

P # 1) Podemos declarar um Array sem tamanho?

Responda: Não. Não é possível declarar uma matriz sem especificar o tamanho. Se quiser fazer isso, você pode usar ArrayList, que é dinâmico por natureza.

Q # 2) O tamanho do array é fixo em Java?

Responda: sim. Os arrays são estáticos em Java e você declara um array com um tamanho especificado. Depois que esse tamanho for especificado, você não poderá alterá-lo novamente.

P # 3) É sempre necessário usar new ao inicializar arrays?

Responda: Não. Os arrays podem ser inicializados usando new ou atribuindo valores separados por vírgula entre chaves.

Portanto, quando inicializamos um array usando o literal Array, conforme mostrado abaixo. Você não precisa usar novos.

int() myarray = {1,2,3,4,5};

O número de elementos fornecidos determinará o tamanho da matriz.

P # 4) O Java Array é serializável?

Responda: sim. Internamente, o Array em Java implementa a interface serializável.

P # 5) É um tipo de dados Array Primitive?

Responda: Não. Na verdade, uma matriz não é um tipo de dados. Uma matriz é um objeto recipiente que contém os elementos de tipos de dados específicos em locais de memória contíguos.

Conclusão

Isso resume a criação e inicialização de arrays em Java. Uma vez que os arrays são criados e inicializados com alguns valores, precisamos imprimi-los. Para imprimir os elementos do array, precisamos percorrer todo o array e imprimir os elementos.

Veremos alguns dos métodos de impressão de elementos de array em nosso próximo tutorial.

Leitura recomendada

^