Como declarar e inicializar uma matriz em Java?

Você pode usar declaração de matriz ou literal de matriz (mas somente quando você declara e afeta a variável imediatamente, os literais de matriz não podem ser usados ​​para redesignar uma matriz).

Para tipos primitivos:

int[] myIntArray = new int[3];
int[] myIntArray = {1, 2, 3};
int[] myIntArray = new int[]{1, 2, 3};

// Since Java 8. Doc of IntStream: https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.html

int [] myIntArray = IntStream.range(0, 100).toArray(); // From 0 to 99
int [] myIntArray = IntStream.rangeClosed(0, 100).toArray(); // From 0 to 100
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).toArray(); // The order is preserved.
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).sorted().toArray(); // Sort 

Para aulas, por exemplo String, é o mesmo:

String[] myStringArray = new String[3];
String[] myStringArray = {"a", "b", "c"};
String[] myStringArray = new String[]{"a", "b", "c"};

A terceira maneira de inicializar é útil quando você declara a matriz primeiro e depois a inicializa. O elenco é necessário aqui.

String[] myStringArray;
myStringArray = new String[]{"a", "b", "c"};

Existem dois tipos de matriz.

Matriz unidimensional

Sintaxe para valores padrão:

int[] num = new int[5];

Ou (menos preferido)

int num[] = new int[5];

Sintaxe com os valores fornecidos (inicialização de variável / campo):

int[] num = {1,2,3,4,5};

Ou (menos preferido)

int num[] = {1, 2, 3, 4, 5};

Nota: Por conveniência, int [] num é preferível porque indica claramente que você está falando aqui sobre array. Caso contrário, não há diferença. De modo nenhum.

Matriz multidimensional

Declaração

int[][] num = new int[5][2];

Ou

int num[][] = new int[5][2];

Ou

int[] num[] = new int[5][2];

Inicialização

 num[0][0]=1;
 num[0][1]=2;
 num[1][0]=1;
 num[1][1]=2;
 num[2][0]=1;
 num[2][1]=2;
 num[3][0]=1;
 num[3][1]=2;
 num[4][0]=1;
 num[4][1]=2;

Ou

 int[][] num={ {1,2}, {1,2}, {1,2}, {1,2}, {1,2} };

Matriz irregular (ou matriz não retangular)

 int[][] num = new int[5][];
 num[0] = new int[1];
 num[1] = new int[5];
 num[2] = new int[2];
 num[3] = new int[3];

Então, aqui estamos definindo colunas explicitamente.
Outra maneira:

int[][] num={ {1}, {1,2}, {1,2,3,4,5}, {1,2}, {1,2,3} };

Para acessar:

for (int i=0; i<(num.length); i++ ) {
    for (int j=0;j<num[i].length;j++)
        System.out.println(num[i][j]);
}

Alternativamente:

for (int[] a : num) {
  for (int i : a) {
    System.out.println(i);
  }
}

Matrizes irregulares são matrizes multidimensionais.
Para obter uma explicação, consulte os detalhes da matriz multidimensional nos tutoriais oficiais do java

Type[] variableName = new Type[capacity];

Type[] variableName = {comma-delimited values};



Type variableName[] = new Type[capacity]; 

Type variableName[] = {comma-delimited values};

também é válido, mas eu prefiro os colchetes após o tipo, porque é mais fácil ver que o tipo da variável é realmente uma matriz.

Existem várias maneiras pelas quais você pode declarar uma matriz em Java:

float floatArray[]; // Initialize later
int[] integerArray = new int[10];
String[] array = new String[] {"a", "b"};

Você pode encontrar mais informações no site de tutoriais da Sun e no JavaDoc .

Acho útil se você entender cada parte:

Type[] name = new Type[5];

Type[]é o tipo da variável chamada nome ("nome" é chamado identificador ). O "Tipo" literal é o tipo de base, e os colchetes significam que este é o tipo de matriz dessa base. Os tipos de matriz são por sua vez tipos próprios, o que permite criar matrizes multidimensionais como Type[][](o tipo de matriz de Type []). A palavra-chave newdiz para alocar memória para a nova matriz. O número entre os colchetes indica o tamanho da nova matriz e a quantidade de memória a ser alocada. Por exemplo, se Java sabe que o tipo base Typeocupa 32 bytes e você deseja uma matriz de tamanho 5, ele precisa alocar internamente 32 * 5 = 160 bytes.

Você também pode criar matrizes com os valores já existentes, como

int[] name = {1, 2, 3, 4, 5};

que não apenas cria o espaço vazio, mas o preenche com esses valores. Java pode dizer que as primitivas são números inteiros e que existem cinco, portanto o tamanho da matriz pode ser determinado implicitamente.

A seguir, mostra a declaração de uma matriz, mas a matriz não é inicializada:

 int[] myIntArray = new int[3];

A seguir, são mostradas a declaração e a inicialização da matriz:

int[] myIntArray = {1,2,3};

Agora, o seguinte também mostra a declaração e a inicialização da matriz:

int[] myIntArray = new int[]{1,2,3};

Mas este terceiro mostra a propriedade da criação anônima de objeto de matriz, apontada por uma variável de referência "myIntArray"; portanto, se escrevermos apenas "new int [] {1,2,3}"; então é assim que um objeto de matriz anônimo pode ser criado.

Se apenas escrevermos:

int[] myIntArray;

isso não é declaração de matriz, mas a seguinte declaração completa a declaração acima:

myIntArray=new int[3];

Alternativamente,

// Either method works
String arrayName[] = new String[10];
String[] arrayName = new String[10];

Isso declara uma matriz chamada arrayNamede tamanho 10 (você tem elementos de 0 a 9 para usar).

Além disso, caso você queira algo mais dinâmico, existe a interface List. Isso não terá bom desempenho, mas é mais flexível:

List<String> listOfString = new ArrayList<String>();

listOfString.add("foo");
listOfString.add("bar");

String value = listOfString.get(0);
assertEquals( value, "foo" );

Existem duas maneiras principais de criar uma matriz:

Este, para uma matriz vazia:

int[] array = new int[n]; // "n" being the number of spaces to allocate in the array

E este, para uma matriz inicializada:

int[] array = {1,2,3,4 ...};

Você também pode criar matrizes multidimensionais, assim:

int[][] array2d = new int[x][y]; // "x" and "y" specify the dimensions
int[][] array2d = { {1,2,3 ...}, {4,5,6 ...} ...};

Pegue o tipo primitivo, intpor exemplo. Existem várias maneiras de declarar e intagrupar:

int[] i = new int[capacity];
int[] i = new int[] {value1, value2, value3, etc};
int[] i = {value1, value2, value3, etc};

onde em tudo isso, você pode usar em int i[]vez de int[] i.

Com reflexão, você pode usar (Type[]) Array.newInstance(Type.class, capacity);

Observe que nos parâmetros do método, ...indica variable arguments. Essencialmente, qualquer número de parâmetros é bom. É mais fácil explicar com o código:

public static void varargs(int fixed1, String fixed2, int... varargs) {...}
...
varargs(0, "", 100); // fixed1 = 0, fixed2 = "", varargs = {100}
varargs(0, "", 100, 200); // fixed1 = 0, fixed2 = "", varargs = {100, 200};

Dentro do método, varargsé tratado como normal int[]. Type...só pode ser usado em parâmetros de método, portanto int... i = new int[] {}, não será compilado.

Observe que ao passar int[]para um método (ou qualquer outro Type[]), você não pode usar a terceira maneira. Na declaração int[] i = *{a, b, c, d, etc}*, o compilador assume que os {...}meios an int[]. Mas isso é porque você está declarando uma variável. Ao passar uma matriz para um método, a declaração deve ser new Type[capacity]ounew Type[] {...} .

Matrizes multidimensionais

Matrizes multidimensionais são muito mais difíceis de lidar. Essencialmente, uma matriz 2D é uma matriz de matrizes. int[][]significa uma matriz de int[]s. A chave é que, se um int[][]é declarado como int[x][y], o índice máximo é i[x-1][y-1]. Essencialmente, um retangular int[3][5]é:

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

No Java 9

Usando diferentes IntStream.iteratee IntStream.takeWhilemétodos:

int[] a = IntStream.iterate(10, x -> x <= 100, x -> x + 10).toArray();

Out: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]


int[] b = IntStream.iterate(0, x -> x + 1).takeWhile(x -> x < 10).toArray();

Out: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

No Java 10

Usando a inferência de tipo de variável local :

var letters = new String[]{"A", "B", "C"};

Se você deseja criar matrizes usando reflexões, pode fazer o seguinte:

 int size = 3;
 int[] intArray = (int[]) Array.newInstance(int.class, size ); 

Declarando uma matriz de referências a objetos:

class Animal {}

class Horse extends Animal {
    public static void main(String[] args) {

        /*
         * Array of Animal can hold Animal and Horse (all subtypes of Animal allowed)
         */
        Animal[] a1 = new Animal[10];
        a1[0] = new Animal();
        a1[1] = new Horse();

        /*
         * Array of Animal can hold Animal and Horse and all subtype of Horse
         */
        Animal[] a2 = new Horse[10];
        a2[0] = new Animal();
        a2[1] = new Horse();

        /*
         * Array of Horse can hold only Horse and its subtype (if any) and not
           allowed supertype of Horse nor other subtype of Animal.
         */
        Horse[] h1 = new Horse[10];
        h1[0] = new Animal(); // Not allowed
        h1[1] = new Horse();

        /*
         * This can not be declared.
         */
        Horse[] h2 = new Animal[10]; // Not allowed
    }
}

Matriz é uma lista seqüencial de itens

int item = value;

int [] one_dimensional_array = { value, value, value, .., value };

int [][] two_dimensional_array =
{
  { value, value, value, .. value },
  { value, value, value, .. value },
    ..     ..     ..        ..
  { value, value, value, .. value }
};

Se é um objeto, então é o mesmo conceito

Object item = new Object();

Object [] one_dimensional_array = { new Object(), new Object(), .. new Object() };

Object [][] two_dimensional_array =
{
  { new Object(), new Object(), .. new Object() },
  { new Object(), new Object(), .. new Object() },
    ..            ..               ..
  { new Object(), new Object(), .. new Object() }
};

No caso de objetos, você precisa atribuí-lo para nullinicializá-los usando new Type(..)classes como Stringe Integersão casos especiais que serão tratados da seguinte maneira

String [] a = { "hello", "world" };
// is equivalent to
String [] a = { new String({'h','e','l','l','o'}), new String({'w','o','r','l','d'}) };

Integer [] b = { 1234, 5678 };
// is equivalent to
Integer [] b = { new Integer(1234), new Integer(5678) };

Em geral, você pode criar matrizes Mdimensionais

int [][]..[] array =
//  ^ M times [] brackets

    {{..{
//  ^ M times { bracket

//            this is array[0][0]..[0]
//                         ^ M times [0]

    }}..}
//  ^ M times } bracket
;

Vale ressaltar que a criação de uma Mmatriz dimensional é cara em termos de espaço. Desde quando você cria uma Mmatriz dimensional com Ntodas as dimensões, o tamanho total da matriz é maior que N^M, uma vez que cada matriz tem uma referência e, na dimensão M, existe uma matriz de referências (M-1) dimensional. O tamanho total é o seguinte

Space = N^M + N^(M-1) + N^(M-2) + .. + N^0
//      ^                              ^ array reference
//      ^ actual data

No Java 8, você pode usar assim.

String[] strs = IntStream.range(0, 15)  // 15 is the size
    .mapToObj(i -> Integer.toString(i))
    .toArray(String[]::new);

Para criar matrizes da classe Objects, você pode usar o java.util.ArrayList. para definir uma matriz:

public ArrayList<ClassName> arrayName;
arrayName = new ArrayList<ClassName>();

Atribua valores à matriz:

arrayName.add(new ClassName(class parameters go here);

Leia a partir da matriz:

ClassName variableName = arrayName.get(index);

Nota:

variableNameé uma referência à matriz, o que significa que manipular variableNamemanipularáarrayName

para loops:

//repeats for every value in the array
for (ClassName variableName : arrayName){
}
//Note that using this for loop prevents you from editing arrayName

loop for que permite editar arrayName(convencional para loop):

for (int i = 0; i < arrayName.size(); i++){
    //manipulate array here
}

Declare e inicialize para Java 8 e posterior. Crie uma matriz inteira simples:

int [] a1 = IntStream.range(1, 20).toArray();
System.out.println(Arrays.toString(a1));
// Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Crie uma matriz aleatória para números inteiros entre [-50, 50] e para duplos [0, 1E17]:

int [] a2 = new Random().ints(15, -50, 50).toArray();
double [] a3 = new Random().doubles(5, 0, 1e17).toArray();

Sequência de potência de dois:

double [] a4 = LongStream.range(0, 7).mapToDouble(i -> Math.pow(2, i)).toArray();
System.out.println(Arrays.toString(a4));
// Output: [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0]

Para String [], você deve especificar um construtor:

String [] a5 = Stream.generate(()->"I will not squeak chalk").limit(5).toArray(String[]::new);
System.out.println(Arrays.toString(a5));

Matrizes multidimensionais:

String [][] a6 = List.of(new String[]{"a", "b", "c"} , new String[]{"d", "e", "f", "g"})
    .toArray(new String[0][]);
System.out.println(Arrays.deepToString(a6));
// Output: [[a, b, c], [d, e, f, g]]

Outra maneira de declarar e inicializar ArrayList:

private List<String> list = new ArrayList<String>(){{
    add("e1");
    add("e2");
}};

Há muitas respostas aqui. Estou adicionando algumas maneiras complicadas de criar matrizes (do ponto de vista do exame , é bom saber disso)

1. Declarar e definir uma matriz

   int intArray[] = new int[3];

   Isso criará uma matriz de comprimento 3. Como contém um tipo primitivo, int, todos os valores são definidos como 0 por padrão. Por exemplo,

   intArray[2]; // Will return 0

2. Usando colchetes [] antes do nome da variável

   int[] intArray = new int[3];
   intArray[0] = 1;  // Array content is now {1, 0, 0}

3. Inicialize e forneça dados para a matriz

   int[] intArray = new int[]{1, 2, 3};

   Desta vez, não há necessidade de mencionar o tamanho no suporte da caixa. Mesmo uma variante simples disso é:

   int[] intArray = {1, 2, 3, 4};

4. Uma matriz de comprimento 0

   int[] intArray = new int[0];
   int length = intArray.length; // Will return length 0

   Semelhante para matrizes multidimensionais

   int intArray[][] = new int[2][3];
   // This will create an array of length 2 and
   //each element contains another array of length 3.
   // { {0,0,0},{0,0,0} }
   int lenght1 = intArray.length; // Will return 2
   int length2 = intArray[0].length; // Will return 3

Usando colchetes antes da variável:

    int[][] intArray = new int[2][3];

É absolutamente bom se você colocar um suporte de caixa no final:

    int[] intArray [] = new int[2][4];
    int[] intArray[][] = new int[2][3][4]

Alguns exemplos

    int [] intArray [] = new int[][] {{1,2,3},{4,5,6}};
    int [] intArray1 [] = new int[][] {new int[] {1,2,3}, new int [] {4,5,6}};
    int [] intArray2 [] = new int[][] {new int[] {1,2,3},{4,5,6}}
    // All the 3 arrays assignments are valid
    // Array looks like {{1,2,3},{4,5,6}}

Não é obrigatório que cada elemento interno seja do mesmo tamanho.

    int [][] intArray = new int[2][];
    intArray[0] = {1,2,3};
    intArray[1] = {4,5};
    //array looks like {{1,2,3},{4,5}}

    int[][] intArray = new int[][2] ; // This won't compile. Keep this in mind.

Você precisa se certificar de que está usando a sintaxe acima e que a direção a seguir deve especificar os valores entre colchetes. Caso contrário, não será compilado. Alguns exemplos:

    int [][][] intArray = new int[1][][];
    int [][][] intArray = new int[1][2][];
    int [][][] intArray = new int[1][2][3];

Outra característica importante é a covariância

    Number[] numArray = {1,2,3,4};   // java.lang.Number
    numArray[0] = new Float(1.5f);   // java.lang.Float
    numArray[1] = new Integer(1);    // java.lang.Integer
   // You can store a subclass object in an array that is declared
   // to be of the type of its superclass.
   // Here 'Number' is the superclass for both Float and Integer.

   Number num[] = new Float[5]; // This is also valid

IMPORTANTE: Para tipos referenciados, o valor padrão armazenado na matriz é nulo.

Você também pode fazer isso com java.util.Arrays:

List<String> number = Arrays.asList("1", "2", "3");

Out: ["1", "2", "3"]

Este é bem simples e direto.

Com a inferência de tipo de variável local, você precisa especificar o tipo apenas uma vez:

var values = new int[] { 1, 2, 3 };

Ou

int[] values = { 1, 2, 3 }

Matriz tem dois tipos básicos.

Matriz estática: matriz de tamanho fixo (seu tamanho deve ser declarado no início e não pode ser alterado posteriormente)

Matriz dinâmica: nenhum limite de tamanho é considerado para isso. (Matrizes dinâmicas puras não existem em Java. Em vez disso, a Lista é mais recomendada)

Para declarar uma matriz estática de Inteiro, string, float, etc ... use as instruções de declaração e inicialização abaixo.

    int[] intArray = new int[10]; 
    String[] intArray = new int[10]; 
    float[] intArray = new int[10]; 
    
   // here you have 10 index starting from 0 to 9

Para usar recursos dinâmicos, você precisa usar List ... List é pura matriz dinâmica e não há necessidade de declarar tamanho no início. Abaixo está a maneira correta de declarar uma lista em JAVA>

        ArrayList<String> myArray = new ArrayList<String>();
        myArray.add("Value 1: something");
        myArray.add("Value 2: something more");

Declarar matriz: int[] arr;

Initialize Array: int[] arr = new int[10];10 representa o número de elementos permitidos na matriz

Declarar matriz multidimensional: int[][] arr;

Inicializar matriz multidimensional: int[][] arr = new int[10][17]; 10 linhas e 17 colunas e 170 elementos porque 10 vezes 17 é 170.

Inicializar uma matriz significa especificar o tamanho dela.

É muito fácil declarar e inicializar uma matriz. Por exemplo, você deseja salvar cinco elementos inteiros 1, 2, 3, 4 e 5 em uma matriz. Você pode fazer isso da seguinte maneira:

a)

int[] a = new int[5];

ou

b)

int[] a = {1, 2, 3, 4, 5};

portanto, o padrão básico é para inicialização e declaração pelo método a) é:

datatype[] arrayname = new datatype[requiredarraysize];

datatype deve estar em minúsculas.

Portanto, o padrão básico é para inicialização e declaração pelo método a é:

Se for uma matriz de string:

String[] a = {"as", "asd", "ssd"};

Se for uma matriz de caracteres:

char[] a = {'a', 's', 'w'};

Para float double, o formato da matriz será igual ao número inteiro.

Por exemplo:

double[] a = {1.2, 1.3, 12.3};

mas quando você declara e inicializa a matriz pelo "método a", terá que inserir os valores manualmente ou por loop ou algo assim.

Mas quando você faz isso pelo "método b", não precisará inserir os valores manualmente.

A matriz pode conter tipos de dados primitivos e objetos de uma classe, dependendo da definição de matriz. No caso de tipos de dados primitivos, os valores reais são armazenados em locais de memória contíguos. No caso de objetos de uma classe, os objetos reais são armazenados no segmento de heap.

Matrizes
unidimensionais : a forma geral de uma declaração de matriz unidimensional é

type var-name[];
OR
type[] var-name;

Instanciando uma matriz em Java

var-name = new type [size];

Por exemplo

    int intArray[];    //declaring array
    intArray = new int[20];  // allocating memory to array
    // the below line is equals to line1 + line2
    int[] intArray = new int[20]; // combining both statements in one
     int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 }; 
    // accessing the elements of the specified array
    for (int i = 0; i < intArray.length; i++)
    System.out.println("Element at index " + i + " : "+ intArray[i]);

Ref: https://www.geeksforgeeks.org/arrays-in-java/

outro exemplo completo com a classe de filmes 😋

public class A {

        public static void main(String[] args) {

                class Movie{

                    String movieName;
                    String genre;
                    String movieType;
                    String year;
                    String ageRating;
                    String rating;

                    public Movie(String [] str)
                    {
                        this.movieName = str[0];
                        this.genre = str[1];
                        this.movieType = str[2];
                        this.year = str[3];
                        this.ageRating = str[4];
                        this.rating = str[5];    
                    }

                }

                String [] movieDetailArr = {"Inception", "Thriller", "MovieType", "2010", "13+", "10/10"};

                Movie mv = new Movie(movieDetailArr);

                System.out.println("Movie Name: "+ mv.movieName);
                System.out.println("Movie genre: "+ mv.genre);
                System.out.println("Movie type: "+ mv.movieType);
                System.out.println("Movie year: "+ mv.year);
                System.out.println("Movie age : "+ mv.ageRating);
                System.out.println("Movie  rating: "+ mv.rating);


            }

        } 

int[] x=new int[enter the size of array here];

exemplo:

int[] x=new int[10];

ou

int[] x={enter the elements of array here];

exemplo:

int[] x={10,65,40,5,48,31};

int[] SingleDimensionalArray = new int[2]

int[][] MultiDimensionalArray = new int[3][4]