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 😂

• Unidimensional
  
  
• Bidimensional
  
  
• Tridimensional y N-dimensional
  
  

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

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

Con ArrayList no es necesario tener un limite!

Podemos declarar e inicializar un array directamente de la siguiente forma:

String[] cars = {“Volvo”, “BMW”, “Ford”, “Mazda”};

Amo las clases de Anahí 💚

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

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.

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]+"|");

Se puso violenta la clase xD

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

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

</*
         * +-------------------------+---
         * | Country  |  City        |
         * --------------------------+--
         * | Mexico   |  CDMX        |
         * | Mexico   |  Guadalajara |
         * | Colombia |  Bogota      |
         * | Colombia |  Medellin    |
         * +-------------------------+---
         */> 

Así lo pude entender yo

Hice una version donde se piden los paises y las ciudades para luego imprimirlos en la consola:

import java.util.Scanner;
public class _014_Arrays {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        String [][] arregloCiudades = new String [4][2];
        for(int x=0;x<arregloCiudades.length;x++){
            for (int y=0;y< arregloCiudades[x].length;y++){
                if(y==0){
                    System.out.print("Ingrese el Pais...: ");
                }else{
                    System.out.print("Ingrese la Ciudad.: ");
                }
                arregloCiudades[x][y]=teclado.nextLine();
            }
        }
        for (int x = 0 ; x< arregloCiudades.length;x++){
            for(int j=0;j< arregloCiudades[x].length;j++){
                if(j==0){System.out.print("Pais: ");}else{System.out.print(", Ciudad: ");}
                System.out.print(arregloCiudades[x][j]+" ");
            }
            System.out.println();
        }
    }
}

Salida:

Muy bien explicado el tema de Arrays.

7u7

Código de la clase:

Los arreglos son fundamentales para sintetizar codigo y objetos, trata de que en la logica de tu negocio utilizarlo cuando el tamaño del arreglo no se modifique, por ejemplo, dias de la semana, departamentos o estados de un pais determinado,

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        System.out.println("Ingresa la Diemcion del Array");
        int Tam = teclado.nextInt();
        //Declaracion de Arrays
        String[] DaysWeken = new String[Tam];
        teclado.nextLine();
        //Almacenamos los dias de la semana ingresados por teclado
        for(int i = 0;i < DaysWeken.length;i++){
            System.out.println("Ingresa el dia de la Semana " + (i+1) );
            DaysWeken[i]= teclado.nextLine();
        }
        //Mostramos los dias de la Semana
        MostraDias(DaysWeken,Tam);
    }
    public static void MostraDias(String[] DaysWeken, int Tam) {
        //creamos otro array
        //String[] DiasSemana = new String[Tam];
        System.out.println("Los dias de la Semana son: ");
        for(int i = 0;i < DaysWeken.length;i++){
            System.out.println(DaysWeken[i]);
           // DiasSemana[i] = DaysWeken[i];
        }
       // return DiasSemana[i];
    }
}

Arrays

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

Mi clase favorita con los arrays.

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

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.