Declarando Arreglos

aca hay una forma de no depender del tamaño del Array.

import java.util.ArrayList;
import java.util.List;

public class ArraysTest {
    public static void main(String[] args) {
        List<String> Days = new ArrayList<>();
        Days.add("Monday");
        Days.add("Tuesday");

        Days.forEach((n) -> System.out.println(n));
    }
}

Los arreglos en JavaScript no tienen limitantes en cuanto a la cantidad de elementos que pueden guardar (o al menos no un límite que afecte nuestro desarrollo).

Yo solo digo… 😅😏

Array

/*
* +------------------------------+
* |  Country    |  City          |
* --------------------------------
* | México      | CDMX           |
* | México      | Guadalajara    |
* | Colombia    | Bogotá         |
* | Colombia    | Medellín       |
* +------------------------------+
* */ 

siento que aprendí más de los comentarios que de la clase misma haha 😂

Y si mi arrays contiene valores mixtos ¿Que tipo de datos utilizaría?

Por ejemplo en TypeScript se utiliza only

public class Array {
    public static void main(String[] args) {
        String[] androidVersions = new String[17];
        String days[] = new String[7];
        String[][] cities = new String[4][2];
        int[][][] numbers = new int[2][2][2];
        int[][][][] numbers4 = new int[3][3][3][3];
    }
}

Con ArrayList no es necesario tener un limite!

• Unidimensional
  
  
• Bidimensional
  
  
• Tridimensional y N-dimensional
  
  

Amo las clases de Anahí 💚

🐱‍💻 Los arreglos son estructuras de datos que pueden ser mutables o inmutables.

Es mejor solo usar arreglos de 3 dimensiones. Por metodos practicos.

public class Arrays {
    public static void main(String[] args) {
        
        // El valor que pongamos es un valor fijo
        String[] androidVersion = new String[17];
        String[] days = new String[7];

        // Arreglo de dos dimensiones 
        String[][] cities = new String[4][2];

        // Arreglos de tres dimensiones
        int[][][] numbers = new int[2][2][2];

        // Arreglos de cuatro dimensiones
        int[][][][] numebrss = new int[2][2][2][2];
    }
}

Me ha parecido Genial esta clase…

String[][] cities=new String[4][2];

cities[0][0]="Colombia";
cities[1][0]="Colombia";
cities[2][0]="Brasil";
cities[3][0]="Brasil";
cities[0][1]="Pasto";
cities[1][1]="Armenia";
cities[2][1]="Sao Paolo";
cities[3][1]="Rio de Janeiro";

System.out.println("|"+cities[0][0]+"|"+cities[0][1]+"|\n");
System.out.println("|"+cities[1][0]+"|"+cities[1][1]+"|\n");
System.out.println("|"+cities[2][0]+"|"+cities[2][1]+"|\n");
System.out.println("|"+cities[3][0]+"|"+cities[3][1]+"|\n");

En algunos sistemas vas a encontrar que primero se declaran los array como variables y luego se los Instanica con la palabra new.

Un buen uso de los arreglos es usar arreglos cuyo contenido sabemos que es limitado.

Mi clase favorita con los arrays.

public class Arrays {

    public static void main(String[] args) {

        //String [][] cities = new String[4][2];
        String[][] cities = {
                {"Mexico","Monterrey"},
                {"Mexico", "Juarez"},
                {"Colombia", "Bogota"},
                {"Colombia", "Cali"}
        };
        System.out.println("|" + cities[0][0]+"|"+ cities[0][1]+"|");
        System.out.println("|" + cities[1][0]+"|"+ cities[1][1]+"|");
        System.out.println("|" + cities[2][0]+"|"+ cities[2][1]+"|");
        System.out.println("|" + cities[3][0]+"|"+ cities[3][1]+"|");

Comparto mi codigo de esta clase
…
public class Arrays {
public static void main(String[] args) {
String[] androidVersions = new String[17];
String daysWeek[] = new String[7];

    String [][] cities = new String[4][2];

    int [][][] numbers = new int[2][2][2];
    int [][][][] numersv2 = new int[2][2][2][2];

    //convencion de nombres siempre es en prural
}

}
…

en teoria si es verdad que 4*2 = 8 pero nuestra matriz no tiene 8 espacios ya que existe en el caso de un arreglo bidimensional la posicion [0][0] y [0][1], esas no las cuenta en la multiplicacion.

Es la mejor explicación de como imaginar los arreglos de varias dimensiones que he visto D:

Entendible.

Osea que es recomendable usar arrglos cuando nuestros datos será constantes, asi como : meses del año, dias de la semana etc.

Igual siempre es bueno tener en cuenta que existen los arreglos de 3 elementos , pero siendo honesto muy rara vez los he usado.

Me recuerda a como funciona las matrices en numpy xD

El cuarto arreglo en donde se declara numbers puede ser representado gráficamente como un cubo de rubik 2x2 👇:
.

.
En donde se puede visualizar las filas, columnas y la “segunda página” tal cual lo señaló la maestra.

Pero si le asignas 17 lugares tendrias 18 o no? el lugar ‘0’ cuenta como 1 posicion en el arreglo.

ejercicio de clase:
String[] androidVersions = new String[17];
String days[] = new String[7];

    String[][] cities = new String[4][2]; //4 * 2 = 8

    int [][][] numbers = new  int[2][2][2];
    int [][][] numbers4 = new int[2][2][2];

/**
 * Descripción: Creación de arrays
 */
public class Arrays {
    public static void main(String[] args) {
        String[] androidVersions = new String[17];
        String days[] = new String[7];

        String[][] cities = new String[4][2];   //4 * 2 = 8

        int [][][] numbers = new int [2][2][2];
        int [][][][] numbers4 = new int [2][2][2][2];
    }
}```

excelente curso

Muchas gracias instructora Anahí por la explicación de cómo generar arreglos desde 1 a hasta 4 dimensiones y destacar que lo ideal es ser denominados de forma plural.

entonces siempre que sea un objeto usamos new?

Super!! Aprendí mucho en esta clase!

Muy interesante los array de 4 dimensiones, hubiese sido bueno ver un ejemplito a ver que tal!

Excelente clase.

Excelente explicación de la declaración de los arreglos

Si todo muy bonito el hecho de declarar arreglos de 4, 5 dimensiones, ¿Pero como se recorren y se manipulan para un uso practico?

public class Arrays {
	
	 public static void main(String[] args) {
		 String[] endroidVersions = new String [17];
		 String days[] = new String[17];
		 
		 String[] [] cities= new String [4][2];   //4*2=8
		
		 /*
		  * +-----------------------------+
		  * |  Country     |   City       |
		  * -------------------------------
		  * |  Mexico      |  CDMX        |
		  * |  Mexicop     |  Guadalajara |
		  * |  Colombia    |  Bogota      |
		  * |  Colombia    |  Medellin    |
		  * +-----------------------------+
		  * 
		  */
		 int [][][]  number = new int [2] [2] [2];
		 int [][][][] numbers4 = new int [2][2][2][2];
		 
	 }

}

Lo que necesito para mi proyecto final 😃

Todo muy claro.

Genial.

public class Arrays {
    public static void main(String[] args) {
        String[] androidVersions = new String[17];

        String days[] = new String[7];

        String[][] cities= new String[4][2];//4x2=8

        int[][][] numbers = new int[2][2][2];
        int[][][][] numbers4= new int[2][2][2][2];
    }
}

Super 😃

public static void main(String[ ] args) {
    String[ ] androiVersions = new String[17];
    String days[ ] = new String[7];

    //Arreglo de dos dimensiones son un pares de datos
    String [ ][ ] cities = new String[4][2]; //4 *2 = 8
    /**
     * Country      City
     * México       CMDX
     * México       Guadalajara
     * Colombia     Bogotá
     * Colombia     Medellin
     */
    int [ ][ ][ ] numbers = new int[2][2][2];
    int [ ][ ][ ][ ] numbers4 = new int [2][2][2][2];
    
}

Muy bueno, gracias

En Java no hay nada como la función “Push” que tienen otros lenguajes como JavaScript?

public class Arrays {
    public static void main(String[] args) {
        //Vectores
        String[] androidVersions = new String[9];
        String dias[] = new String[7];

        //Matriz de 8 espacios
        String[][] ciudades = new String[4][2];

        //De 3 y 4 dimenciones dimenciones
        int [][][] numeros = new int[2][2][2];
        int [][][][] num4 = new int[2][2][2][2];
    }
}```

public class ArraysClass
{
    public static void main(String[] args)
    {
        String androidVersions[] =new String[17];
        String days[] =new String[7];
        String [][] cities = new String[4][2]; // [renglon], [columna]

        int [][][] numeros = new int [2][2][2]; //[renglon][columna][altura]
        int [][][][] Numeros4d =  new int [2][2][2][2];
    }
}```

Todo clarísimo. Gracias

En la clase “Declarando Arreglos” ¿por qué inicializas un dato primitivo si no es un objeto?

int [][][] numbers = new int[2][2][2];

public class Arrays {
    public static void main(String[] args) {
        String[] androidVersion= new String[17];
        String mesesAnno[]=new String[12];
        String [][] cities= new String[4][2];

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

    }
}

Para declarar un Array: tipo_dato [] nombre_array = new tipo_dato[tamaño]

cool

Necesito aprender de Android vengo del futuro y según yo solo hay hasta Android 11 🤯

Supongo que lo que mas se utiliza son las listas y demas.