que ¿Cómo declaro e inicializo una matriz en Java?




que es un array en java (16)

Otra forma de declarar e inicializar ArrayList:

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

¿Cómo declaro e inicializo una matriz en Java?


Declarar e inicializar para Java 8 y versiones posteriores. Crear una matriz entera entera:

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]

Cree una matriz aleatoria para enteros entre [-50, 50] y para dobles [0, 1E17]:

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

Secuencia del poder de dos:

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 [] debes especificar un constructor:

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

Arreglos multidimensionales:

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]]

Para crear matrices de objetos de clase, puede usar java.util.ArrayList . para definir una matriz:

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

Asignar valores a la matriz:

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

Leer de la matriz:

ClassName variableName = arrayName.get(index);

Nota:

variableName es una referencia a la matriz, lo que significa que manipular variableName manipulará arrayName

para bucles:

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

para bucle que le permite editar arrayName (convencional para bucle):

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

int[] SingleDimensionalArray = new int[2]

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

Type[] variableName = new Type[capacity];

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



Type variableName[] = new Type[capacity]; 

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

también es válido, pero prefiero los corchetes después del tipo, porque es más fácil ver que el tipo de la variable es en realidad una matriz.


Declarar una matriz de referencias de 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
    }
}

Hay varias formas en que puede declarar una matriz en Java:

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

Puede encontrar más información en el sitio de tutoriales de Sun y en JavaDoc .


Hay dos tipos de matriz.

Matriz unidimensional

Sintaxis para los valores por defecto:

int[] num = new int[5];

O (menos preferido)

int num[] = new int[5];

Sintaxis con valores dados (inicialización de variable / campo):

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

O (menos preferido)

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

Nota: por conveniencia, int [] num es preferible porque claramente indica que está hablando aquí sobre array. De lo contrario no hay diferencia. De ningún modo.

Array multidimensional

Declaración

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

O

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

O

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

Inicialización

 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;

O

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

Matriz desigual (o matriz no rectangular)

 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];

Así que aquí estamos definiendo columnas explícitamente.
De otra manera:

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

Para el acceso:

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);
  }
}

Las matrices desiguales son matrices multidimensionales.
Para una explicación, vea detalles de matrices multidimensionales en los tutoriales oficiales de java


Array es una lista secuencial de elementos

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 }
};

Si es un objeto, entonces es el mismo concepto.

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() }
};

En el caso de los objetos, debe asignarlo a null para inicializarlos utilizando el new Type(..) , las clases como String y Integer son casos especiales que se manejarán de la siguiente manera

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) };

En general, puedes crear matrices que sean M dimensionales.

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

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

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

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

Es digno de notar que crear una matriz dimensional es costoso en términos de espacio. Ya que cuando creas una matriz dimensional M con N en todas las dimensiones, el tamaño total de la matriz es mayor que N^M , ya que cada matriz tiene una referencia, y en la dimensión M hay una (M-1) - Array dimensional de referencias. El tamaño total es el siguiente

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

Además, en caso de que quieras algo más dinámico, está la interfaz de la lista. Esto no funcionará tan bien, pero es más flexible:

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

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

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

En java 9

Usando diferentes métodos IntStream.iterate e IntStream.takeWhile :

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]

En java 10

Usando la inferencia de tipo de variable local :

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

Si desea crear matrices utilizando reflexiones, puede hacer lo siguiente:

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

A continuación se muestra la declaración de una matriz, pero la matriz no se inicializa:

 int[] myIntArray = new int[3];

A continuación se muestra la declaración, así como la inicialización de la matriz:

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

Ahora, lo siguiente también muestra la declaración, así como la inicialización de la matriz:

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

Pero este tercero muestra la propiedad de la creación anónima de objetos de matriz que está señalada por una variable de referencia "myIntArray", por lo que si escribimos simplemente "new int [] {1,2,3};" entonces así es como se puede crear un objeto de matriz anónimo.

Si acabamos de escribir:

int[] myIntArray;

esto no es una declaración de matriz, pero la siguiente declaración completa la declaración anterior:

myIntArray=new int[3];

Me parece útil si entiendes cada parte:

Type[] name = new Type[5];

Type[] es el tipo de la variable llamada nombre ("nombre" se llama el identificador ). El literal "Tipo" es el tipo base, y los paréntesis significan que este es el tipo de matriz de esa base. Los tipos de matrices son a su vez tipos propios, lo que le permite crear matrices multidimensionales como el Type[][] (el tipo de matriz del Tipo []). La palabra clave new dice que se asigne memoria para la nueva matriz. El número entre el corchete indica qué tan grande será la nueva matriz y cuánta memoria se debe asignar. Por ejemplo, si Java sabe que el tipo de tipo base toma 32 bytes, y desea una matriz de tamaño 5, debe asignar internamente 32 * 5 = 160 bytes.

También puede crear matrices con los valores que ya están allí, como

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

que no solo crea el espacio vacío sino que lo llena con esos valores. Java puede decir que los primitivos son enteros y que hay 5 de ellos, por lo que el tamaño de la matriz se puede determinar implícitamente.


Alternativamente,

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

Eso declara una matriz llamada arrayName de tamaño 10 (tiene elementos de 0 a 9 para usar).


En Java 8 puedes usar así.

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






declare