05-matriz de Java

Formación

El llamado array (Array) es una colección de elementos del mismo tipo de datos dispuestos en un orden determinado, es decir, se nombra un número limitado de variables del mismo tipo para gestionarlas de manera uniforme, y luego se distinguen por números. Este nombre se llama nombre de matriz. El número se llama subíndice o índice. Las variables que componen una matriz se denominan elementos de la matriz. El número de elementos de una matriz se denomina longitud de la matriz.

Características de la matriz:

• Una vez que se determina la longitud de la matriz, no se puede modificar

• La creación de un objeto de matriz abrirá todo un espacio contiguo en la memoria. El nombre de la matriz se refiere a la primera dirección de este espacio continuo.

• Es rápido atravesar la matriz y obtener un elemento, porque puede ubicar directamente cualquier elemento a través del nombre de la matriz + subíndice.

Clasificación de la matriz:

• Las matrices se dividen en matrices unidimensionales, matrices bidimensionales y matrices multidimensionales según sus dimensiones

• Las matrices se clasifican según los tipos de datos de los elementos: datos de elementos de tipo de datos básicos, matrices de elementos de tipo de datos de referencia

1. Matriz unidimensional

1.1 Declaración de matriz unidimensional

Declaración de matriz:

1. Tipo de matriz nombre de matriz, es decir, tipo de datos del elemento [] nombre de matriz;

P.ej:

int[] arr1; //格式1
char arr2[];//格式2

1.2 Inicialización de matriz unidimensional

El propósito de la inicialización:

• Determine la longitud de la matriz
• Asignar valores a elementos

1. Inicialización estática

Cuando los elementos de la matriz son conocidos y finitos, se puede utilizar la inicialización estática.

数据类型[] 数组名 = new 元素的数据类型[]{
    
    值列表};
数据类型[] 数组名 ={
    
    值列表}；//更简洁
int[] arr = {
    
    1,2,3,4};

2. Inicialización dinámica

数据类型 数组名 = new 元素数据类型[数组的长度];
int[] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

La longitud de la matriz durante la inicialización dinámica se especifica en [] y debe especificarse

Cada elemento tiene un valor predeterminado durante la inicialización dinámica

(1) Tipos de datos básicos

Byte, corto, int, largo: 0

Flotar, doble: 0.0

Char ： \ u0000

Booleano: falso

(2) Tipo de datos de referencia

Todos son nulos

Nota:

• Tanto si se trata de una inicialización estática como de una dinámica, se debe determinar la longitud de la matriz.

• La inicialización dinámica especifica explícitamente la longitud al crear un objeto de matriz, la inicialización estática, la longitud de la matriz está determinada por el número de elementos enumerados

1.3 Recorrido de matrices unidimensionales

El bucle for atraviesa la matriz:

for(int i=0; i<数组名.lenght; i++){
    
    
    //或赋值
    数组名[i] = 值;
    //或显示
    System.out.println(数组名[i])；
    //或其他操作
    //例如：判断是否是偶数
    if(数组名[i]%2==0){
    
    
          //...
    }
}

1.4 Análisis de memoria de matrices unidimensionales

int[] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

1.5 Inversión de matrices unidimensionales

1. Con una nueva matriz

int[] arr = {
    
    1,2,3,4,5,6,7,8,9};

//(1)先创建一个新数组
int[] newArr = new int[arr.length];

//(2)复制元素
int len = arr.length;
for(int i=0; i<newArr.length; i++){
    
    
    newArr[i] = arr[len -1 - i];
}

//(3)舍弃旧的，让arr指向新数组
arr = newArr;//这里把新数组的首地址赋值给了arr

//(4)遍历显示
for(int i=0; i<arr.length; i++){
    
    
    System.out.println(arr[i]);
}

2. Primer intercambio de correspondencia

int[] arr = {
    
    1,2,3,4,5,6,7,8,9};

//(1)计算要交换的次数：  次数 = arr.length/2
//(2)首尾交换
for(int i=0; i<arr.length/2; i++){
    
    //循环的次数就是交换的次数
    //首  与  尾交换
    int temp = arr[i];
    arr[i] = arr[arr.length-1-i];
	arr[arr.length-1-i] = temp;
}

//（3）遍历显示
for(int i=0; i<arr.length; i++){
    
    
    System.out.println(arr[i]);
}

1.6 Encontrar

1. Búsqueda secuencial : no se requiere matriz

int[] arr = {
    
    4,5,6,1,9};
int value = 1;
int index = -1;

for(int i=0; i<arr.length; i++){
    
    
    if(arr[i] == value){
    
    
        index = i;
        break;
    }
}

if(index==-1){
    
    
    System.out.println(value + "不存在");
}else{
    
    
    System.out.println(value + "的下标是" + index);
}

2. Búsqueda binaria : doblar por la mitad y luego doblar por la mitad

   Hay requisitos para la matriz, los elementos deben estar en orden de tamaño

class Test{
    
    
	public static void main(String[] args){
    
    
		int[] arr = {
    
    1,2,3,4,5,6,7,8,9};//数组是有序的
		int value = 2;
		
        int index = -1;
		int left = 0;
        int right = arr.length - 1;
        int mid = (left + right)/2;
        while(left<=right){
    
    
            //找到结束
            if(value == arr[mid]){
    
    
                index = mid;
                break;
            }//没找到
            else if(value > arr[mid]){
    
    //往右继续查找
                //移动左边界，使得mid往右移动
                left = mid + 1;
            }else if(value < arr[mid]){
    
    //往左边继续查找
                right = mid - 1;
            }
            
            mid = (left + right)/2;
        }
        
        if(index==-1){
    
    
    		System.out.println(value + "不存在");
		}else{
    
    
    		System.out.println(value + "的下标是" + index);
		}
        
	}
}

1.7 Clasificación de burbujas

De pequeño a grande, compare en pares de izquierda a derecha

int[] arr = {
    
    5,4,6,3,1};
for(int i=1; i<arr.length; i++){
    
    //外循环的次数 = 轮数 = 数组的长度-1
    for(int j=0; j<arr.length-i; j++){
    
    
    	//内循环的次数为length-i
    
        //两两比较
        //从小到大，说明前面的比后面的大，就交换
        if(arr[j] > arr[j+1]){
    
    
            int temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}

1.8 excepciones comunes de matrices

• 越界ArrayIndexOutOfBoundsException

• Puntero nulo NullPointerException

 

2. Matriz bidimensional

Comprensión popular:

La matriz unidimensional se asemeja a un bungalow, solo un piso, hay varias habitaciones

Una matriz bidimensional se asemeja a un edificio, hay varios pisos y cada piso tiene varias habitaciones.

2.1 Declaración de matriz bidimensional

Formato: tipo de datos del elemento [] [] nombre de matriz bidimensional;

  //推荐
  元素的数据类型[][] 二维数组的名称;

 //不推荐
 元素的数据类型  二维数组名[][];
 //不推荐
  元素的数据类型[]  二维数组名[];

2.2 Inicialización de matriz bidimensional

1. Inicialización estática

元素的数据类型[][] 二维数组的名称 = {
    
    
			{
    
    第一行的值列表}, 
			{
    
    第二行的值列表},
			...
			{
    
    第n行的值列表}
		};

int[][] arr = {
    
    {
    
    1,2,3},{
    
    4,5,6},{
    
    7,8,9,10}};

2. Inicialización dinámica

La creación de objetos de matriz se realiza por separado de la asignación de elementos.

//1.每行的列数相等
数据类型[][] 数组名 = new 元素的数据类型[行数][列数];
数组名[行下标][列下标] = 值;

//2.每行的列数不确定
数据类型[][] 数组名 = new 元素的数据类型[行数][];
数组名[行下标] = new 元素的数据类型[该行的总列数];
数组名[行下标][列下标] = 值;

2.3 Recorrido de matriz bidimensional

for(int i=0; i<二维数组名.length; i++){
    
    
    for(int j=0; j<二维数组名[i].length; j++){
    
    
        System.out.print(二维数组名[i][j]);
    }
    System.out.println();
}

2.4 Análisis de memoria de matriz bidimensional

int[][] arr = new int[2][];
arr[0] = new int[3];
arr[1] = new int[2];
arr[0][1] = 1;

3. Recurrencia

La técnica de programación de un programa que se llama a sí mismo se llama recursividad.

Por lo general, transforma un problema grande y complejo en un problema más pequeño similar al problema original para resolver. La estrategia recursiva solo necesita una pequeña cantidad de programas para describir los múltiples cálculos repetitivos requeridos en el proceso de resolución del problema. Reducir la cantidad de programa código.

Encuentra recursivamente la secuencia de Fibonacci: 1, 1, 2, 3, 5, 8, 13, 21 ... el enésimo término

import java.util.Scanner;

public class Fibonacci {
    
    
    public static void main(String[] args) {
    
    
        System.out.println("请输入n:");
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        System.out.println(fib(n));

    }
    public static int fib(int n){
    
    
        if(n==1||n==2){
    
    
            return 1;
        }
        return fib(n-2)+fib(n-1);
    }
}