Java matriz cero entrada básica a competente

Este es el cuarto original de JavaMemo.

En la sección anterior, comprendimos a fondo los tipos de datos básicos en Java . En esta sección, aprenderemos más sobre las matrices en Java.

Una matriz es un tipo de datos que se encuentra en casi todos los lenguajes de programación y es en sí misma una estructura de datos. Cuando se trata de arreglos, lo primero que viene a la mente es que un arreglo es un espacio de memoria contiguo en la memoria, por lo que podemos acceder directamente a sus elementos por índice.

Este artículo sacará los puntos de conocimiento común de las matrices en Java para aprender juntos. Dado que está dirigido a principiantes, deducirá algunos detalles técnicos con dichos comunes que son más adecuados para que la gente común los entienda. Todos mueven el pequeño banco. Veamos primero el esquema de su contenido.

Reconocer matrices

Una matriz en Java es una colección de variables del mismo tipo, por ejemplo, una matriz de int es una colección de variables de tipo int. Las variables en la matriz están ordenadas y cada una tiene un índice.

Características de las matrices

• Una matriz es una colección de variables del mismo tipo, todos los elementos son del mismo tipo
• Puede especificar el número de elementos contenidos en la matriz, hasta el valor máximo de int
• Cada elemento tiene un número fijo, llamado índice (index), que aumenta desde 0, y el tipo de índice es int
• Puedes leer y escribir cualquier elemento en el arreglo como si estuvieras manipulando variables, si la variable anterior es una hoja de papel con un nombre, puedes leer y escribir la variable a través de este nombre, el arreglo es un libro con un nombre. El libro tiene un nombre y cada página tiene un número de página. Puede leer y escribir los elementos de matriz correspondientes a través del nombre y el número de página del libro.
• Después de crear la matriz con una longitud fija, la longitud no se puede cambiar.

sintaxis de matriz

• Sintaxis para crear una matriz:

元素类型[] 变量名 = new 元素类型[数组长度]
复制代码

• Sintaxis para usar arreglos:

通过：数组变量名[索引]， 
可以使用这个变量，可以读取也可以给它赋值
复制代码

Veamos un ejemplo para ayudar a comprender estas dos sintaxis básicas para matrices.

public class CreateArray {
    public static void main(String[] args) {
        int[] intArray = new int[9];

        intArray[2] = 16;

        System.out.println(intArray[2]);

        double[] doubleArray = new double[100];

        System.out.println(doubleArray[66]);
        
        // 也可以在创建数组的时候，指定数组包含的所有元素
        String[] strArray = new String[]{"one", "two"};
        
		System.out.println(strArray[0]);
    }
}
复制代码

Ejemplo: manejo de calificaciones para varios cursos con una matriz

public class ScoreArrayMaxScore {
    public static void main(String[] args) {
        // 声明六个变量， 分别代表六门科目的成绩
        int YuWenIndex = 0;
        int ShuXueIndex = 1;
        int WaiYuIndex = 2;
        int WuLiIndex = 3;
        int HuaXueIndex = 4;
        int ShengWuIndex = 5;

        // 每门课的名字
        String[] names = new String[6];
        names[YuWenIndex] = "语文";
        names[ShuXueIndex] = "数学";
        names[WaiYuIndex] = "外语";
        names[WuLiIndex] = "物理";
        names[HuaXueIndex] = "化学";
        names[ShengWuIndex] = "生物";

        // 每门课的成绩
        double[] scores = new double[6];

        // 用随机数给成绩赋值
        for (int i = 0; i < 6; i++) {
            scores[i] = 80 + Math.random() * 20;
        }

        // 计算最高成绩和最高成绩对应的科目的索引
        double maxScore = -1;
        int maxScoreIndex = -1;
        for (int i = 0; i < 6; i++) {
            System.out.println(names[i] + "的成绩为" + scores[i]);
            if (maxScore < scores[i]) {
                maxScore = scores[i];
                maxScoreIndex = i;
            }
        }

        // 输出最高成绩科目和成绩
        System.out.println("最高分的科目为" + names[maxScoreIndex] + "，成绩为：" + maxScore);

    }
}
复制代码

entender matrices

Comprender cómo las computadoras usan la memoria y realizan funciones variables

• La memoria es como un libro con una pila de papel blanco, al que solo se puede acceder por el número de página, que es la llamada dirección de memoria.
• Una variable utiliza una dirección fija más la memoria correspondiente a esta dirección. La computadora cumple la función de asignar y acceder a variables a través de la dirección, leyendo y escribiendo en el espacio de memoria correspondiente a la dirección. Parece posible escribir en papel blanco designado de acuerdo con el número de página, o borrar y volver a escribir.
• El nombre de la variable es la dirección, y el valor real de la variable es el valor en la memoria al que apunta la dirección.

Comprender los nombres y las realidades de las matrices.

• Lo "real" de una matriz es una pieza de memoria con direcciones consecutivas, como una pila de papel blanco con números consecutivos.
• 数组的名，就是这个块连续内存的第一个内存的地址。
• 数组的变量和基本类型的变量一样，本身代表一个地址。但是与基本变量不一样的是，这个地址的值，是数组的第一个元素所在的内存地址。
• 通过 **数组变量名[索引] **方式访问数组元素的实质，就是在数组原有地址（第一个元素）的基础上，加上索引，获得想要的元素位于内存的地址后进行访问。

数组的初始值

数组里的每个元素都有初始值，初始值和元素类型有关，是元素类型的默认值，对于数字类型，初始值就是0，对于boolean类型，初始值是 false。

数组的操作

数组的长度

• 数组变量的length 属性，可以获取数组的长度。

int[] array = new int[10];

// 通过.length获取数组的长度
system.out.println(array.length);
复制代码

• 数组是定长的，创建之后，长度不可以改变。

数组越界问题

• 使用数组常见的一个错误是 IndexOutOfBoundException 数组越界，比如下面就是一个越界的例子

public class IndexOutOfBoundExample {
    public static void main(String[] args) {
        int[] array = new int[5];
        System.out.println(array[array.length]);
    }
}
复制代码

• 如果没有把握数组是否会越界，可以把索引和数组长度做比较，注意索引是从 0 开始的，不是从 1 开始的。

public class CompareIndex {
    public static void main(String[] args) {
        int size = 60;
        double[] array = new double[size];

        for (int i = 0; i < 10; i++) {
            int index = (int) (Math.random() * size * 3);
            if (index >= 0 && index < array.length) {
                System.out.println(array[index]);
            } else {
                System.out.println("数组出界！");
            }
        }
    }
}
复制代码

数组变量指向新数组

• 数组变量可以指向新的数组实体。这时候，数组变量的值就是新的数组实体的地址了，这种数组变量的赋值操作，叫做让变量指向新的数组。

public class AssignArray {
    public static void main(String[] args) {
        int[] array = new int[3];

        array[0] = 9;

        System.out.println("array长度为" + array.length + "。array[0] = " + array[0] + " array 指向的地址为：" + array);

        array = new int[32];

        System.out.println("array长度为" + array.length + "。array[0] = " + array[0] + " array 指向的地址为：" + array);
    }
}
复制代码

上面的例程的输出是

array长度为3。array[0] = 9 array 指向的地址为：[I@78e03bb5
array长度为32。array[0] = 0 array 指向的地址为：[I@5e8c92f4
复制代码

可以看到数组变量指向新数组后，变量值保存的数组地址发生了变化。

• 如果没有别的数组变量指向原来的数组实体，也就是说，如果没有数组变量“记得”原来数组的地址，原来的数组实体就再也不可访问，也就好像“消失”了。后面会被GC回收。

多维数组

• 二维数组是一维数组的延伸。
• 二维数组定义的语法，比如定义一个doubule类型的二维数组 double[][] = new doube[3][6]，第一维有三个元素，每个元素的值都是指向的double一维数组的地址，第二维数组的长度为6。
• 一般写代码时最多就用到二维数组，再多维，写的程序太难让人理解，不推荐使用。

public class MultiDimensionArray {
    public static void main(String[] args) {
        // 创建一个double类型的二维数组
        double[][] multiDimensionArr = new double[3][5];

        // 循环查看每个数组元素的值，在给数组元素赋值前，数组元素的值其实都是每种类型的初始值。
        for (int i = 0; i < multiDimensionArr.length; i++) {
            for (int j = 0; j < multiDimensionArr[i].length; j++) {
                System.out.println("multiDimensionArr[" + i + "][" + j + "]=" + multiDimensionArr[i][j]);
            }
        }

        // 其实第一维的数组，每个元素都是一个下一维度的属于的变量。在这里我们可以改变这个变量的值
        // 也就是让它指向一个新的变量。
        multiDimensionArr[2] = new double[100];

        // 检查每个的数组的长度，发现最后一个的长度不一样了，因为它指向了新的数组。
        for (int i = 0; i < multiDimensionArr.length; i++) {
            System.out.println("multiDimensionArr[" + i + "].length=" + multiDimensionArr[i].length);
        }

    }
}
复制代码

例子-利用二维数组存储多年的成绩

import java.util.Scanner;

public class OneArrayForAll {
    public static void main(String[] args) {

        // 声明六个变量， 分别代表六门科目的成绩
        int YuWenIndex = 0;
        int ShuXueIndex = 1;
        int WaiYuIndex = 2;
        int WuLiIndex = 3;
        int HuaXueIndex = 4;
        int ShengWuIndex = 5;

        // 每门课的名字
        String[] names = new String[6];
        names[YuWenIndex] = "语文";
        names[ShuXueIndex] = "数学";
        names[WaiYuIndex] = "外语";
        names[WuLiIndex] = "物理";
        names[HuaXueIndex] = "化学";
        names[ShengWuIndex] = "生物";

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入共有多少年的成绩：");

        int yearCount = scanner.nextInt();

        double[][] scores = new double[yearCount][names.length];

        for (int i = 0; i < yearCount; i++) {
            for (int j = 0; j < names.length; j++) {
                scores[i][j] = 80 + Math.random() * 20;
            }
        }

        System.out.println("请问要查看第几年的成绩？");

        int yearToUse = scanner.nextInt() - 1;

        System.out.println("请问要查看第几科的成绩？");

        int scoreToUse = scanner.nextInt() - 1;

        System.out.println("第" + (yearToUse + 1) + "年的第" + (scoreToUse + 1) + "门的成绩是：" + scores[yearToUse][+scoreToUse]);

    }
}
复制代码

总结

关于数组方面的基础内容差不多就是这些，学会后，掌握常规的数组使用方法完全不再话下。

De hecho, cuando realmente usa Java para desarrollar programas, la mayoría de las veces, no usará matrices directamente, y más utilizará ArrayList para admitir la expansión automática y contenedores genéricos, pero también se implementa sobre la base de matrices. es como comer un bocado, toma un bocado, y cuando hayamos dominado los conocimientos más básicos, habrá un capítulo especial para aprender sobre contenedores como ArrayList.

Hoy sigue siendo un contenido para personas de base cero. Si necesitas empezar a usar Java en el trabajo, o tienes amigos que acaban de empezar a aprender Java, te invitamos a compartir el artículo con ellos.