Aprendizagem Java: Arrays Java

3. Matriz Java

3.1 Visão geral dos arrays

Array (Array) é uma coleção de vários dados do mesmo tipo dispostos em uma determinada ordem e é nomeado com um nome , e esses dados são gerenciados uniformemente por numeração .

• A própria matriz é um tipo de dados de referência e os elementos na matriz podem ser de qualquer tipo de dados , incluindo tipos de dados primitivos e tipos de dados de referência.
• A criação de um objeto array abrirá todo um espaço contínuo na memória, e o nome do array refere-se ao primeiro endereço desse espaço contínuo.
• Depois que o comprimento da matriz é determinado, ele não pode ser modificado .
• Podemos chamar diretamente o elemento na posição especificada por subscrito (ou índice), o que é muito rápido.
• Classificação de matrizes:

De acordo com a dimensão: array unidimensional, array bidimensional, array tridimensional, ...
De acordo com o tipo de dados do elemento: o array de elementos do tipo de dados básicos, o array de elementos do tipo de dados de referência (isto é , matriz de objetos)

3.2 Uso de arrays unidimensionais

① Como declarar um array unidimensional
type var[] 或 type[] var;
Por exemplo:

int a[];
int[] a1;
double b[];
String[] c; //引用类型变量数组

Ao declarar um array na linguagem Java, seu comprimento (número de elementos do array) não pode ser especificado , por exemplo: int a[5]; //Ilegal

②Inicialização do array unidimensional

• Inicialização dinâmica: declaração de array e alocação de espaço para elementos de array e operações de atribuição são executadas separadamente

   int[] arr = new intr[3];
   arr[0] = 3;
   arr[1] = 9;
   arr[2] = 8;
   
   String names[];
   names =new =String[3];
   names[0] = "钱学森";
   names[1] = "邓稼先";
   names[2] = "袁隆平";
  

• Inicialização estática: aloca espaço e atribui valores aos elementos do array enquanto define o array .

  int arr[] = new int []{3,9,8};
  int [] arr = {3,9,8};
   
  String names[] = {
  "李四光”,"茅以升","华罗庚"
  }
  

③Referência do elemento Array

• definir e usar operadornovoDepois de alocar espaço para ele, você pode se referir a cada elemento da matriz;
• O método de referência do elemento da matriz: nome da matriz [subscrito do elemento da matriz]
  o subscrito do elemento da matriz pode ser uma constante inteira ou uma expressão inteira. Tal como a[3], b[i], c[6*i]; o
  subscrito do elemento da matriz começa em 0; o intervalo de valor subscrito legal de uma matriz com um comprimento de n: 0 —>n-1 ; como int a[] =new int[3]; Os elementos do array que podem ser referenciados são a[0], a[1], a[2]
• Cada array possui um atributo length para indicar seu comprimento, por exemplo: a.length indica o comprimento (número de elementos) do array a.Uma
  vez que o array é inicializado, seu comprimento é imutável .

④ Valor de inicialização padrão dos elementos do array
Array é um tipo de referência, e seus elementos são equivalentes às variáveis ​​membro da classe . Portanto, uma vez que o espaço é alocado no array, cada elemento nele também é inicializado implicitamente da mesma forma que membro variáveis. Por exemplo:

public class Test {
    
    
	public static void main(String args[]){
    
    
	int a[]= new int[5];
	System.out.println(a[3]); //a[3]的默认值为0
}
}
>对于基本数据类型而言，默认初始化值各有不同
>对于引用数据类型而言，默认初始化值为null(注意与0不同！)

tipo de elemento de matriz	Valor inicial padrão do elemento
byte	0
curto	0
int	0
longo	0L
flutuador	0,0F
dobro	0,0
Caracteres	0 ou escrito como: '\u0000' (expresso como vazio)
boleano	falso
tipo de referência	nulo

⑤ Crie uma matriz de tipos de dados básicos

• Usando palavras-chave em Javanovopara criar a matriz
• O seguinte é criar uma matriz unidimensional de elementos de tipo de dados básicos

public class Tset{
    
    
	public static void main(String args[]){
    
    
		int[] s;   //处内存状态
		s = new int[10];
		for(int i=0;i<10;i++){
    
    
		s[i] = 2*i+1;
		System.out.println(s[i]);
		}
	}
}

public class Test{
    
    
	public static void main(String args[]){
    
    
		int[] s;
		s = new int[10];   //处内存状态
		//int[] s=new int[10];
		//基本数据类型数组在显式赋值之前，Java会自动给他们赋默认值。
		for ( int i=0; i<10; i++ ) {
    
    
			s[i] =2*i+1;
			System.out.println(s[i]);
		}
	}
}

public class Test{
    
    
	public static void main(String args[]){
    
    
		int[] s;
		s = new int[10];
		for ( int i=0; i<10; i++ ) {
    
    
			s[i] =2*i+1;   //处内存状态
			System.out.println(s[i]);
		}
	}
}

prática

/*
从键盘输入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序
*/
import java.util.Scanner;
class Test 
{
    
    
	public static void main(String[] args) {
    
    
        //1.使用scanner，读取学生个数
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入学生人数：");
        int number=scanner.nextInt();
        //2.创建数组，存储学生成绩；动态初始化
        int[] scores=new int[number];
        //3.给数组中的元素赋值
        System.out.println("请输入"+number+"个学生成绩:");
        int maxScore=0;
        for (int i = 0; i < scores.length; i++) {
    
    
            scores[i]=scanner.nextInt();
            //4.获取数组中的元素最大值：最高分
            if (maxScore<scores[i]){
    
    
                maxScore=scores[i];
            }
        }
        //5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
        char level;
        for (int i = 0; i < scores.length; i++) {
    
    
            if (maxScore-scores[i]<=10){
    
    
                level='A';
            }else if (maxScore-scores[i]<=20){
    
    
                level='B';
            }else if (maxScore-scores[i]<=30){
    
    
                level='C';
            }else {
    
    
                level='D';
            }
            System.out.println("student "+i+"score is "+scores[i]+",gread is "+level);
        }
    }
}

>运行结果
请输入学生人数：
5
请输入5个学生成绩:
55
77
67
59
81
student 0score is 55,gread is C
student 1score is 77,gread is A
student 2score is 67,gread is B
student 3score is 59,gread is C
student 4score is 81,gread is A

3.3 Uso de arrays multidimensionais

• A linguagem Java fornece sintaxe para suportar matrizes multidimensionais.
• Se as matrizes unidimensionais podem ser consideradas gráficos lineares em geometria, as matrizes bidimensionais são equivalentes a uma tabela, como a tabela no Excel à direita.
• Para a compreensão dos arrays bidimensionais, podemos ver que o array unidimensional array1 existe como um elemento de outro array unidimensional array2. Na verdade, do ponto de vista do mecanismo operacional subjacente do array, não existe um array multidimensional.
  
  
  prática

/*1.获取arr数组中所有元素的和。*/

package test1j.ava;

public class shuzu {
    
    
	public static void main(String[] args) {
    
    
		int [][] arr = new int[][] {
    
    {
    
    3,5,8},{
    
    12,9},{
    
    7,0,6,4}};
		int num = 0;
		for(int i=0;i<arr.length;i++){
    
    
		    for(int j=0;j<arr[i].length;j++){
    
    
		        num += arr[i][j];
		    }
		}
		System.out.println(num);
	}
}

>运行结果 54

/*2.使用二维数组打印一个 10 行杨辉三角*/

package test1j.ava;

public class yanghui {
    
    
    public static void main(String[] args) {
    
    
        int n = 10; // 控制打印的行数

        int[][] arr = new int[n][];
        for (int i = 0; i < n; i++) {
    
    
            arr[i] = new int[i + 1];
            arr[i][0] = 1;
            arr[i][arr[i].length - 1] = 1;

            // 计算该行的数据
            for (int j = 1; j < arr[i].length - 1; j++) {
    
    
                arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
            }
        }

        // 打印杨辉三角
        for (int i = 0; i < n; i++) {
    
    
            for (int j = 0; j < arr[i].length; j++) {
    
    
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

>运行结果
1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 
1 6 15 20 15 6 1 
1 7 21 35 35 21 7 1 
1 8 28 56 70 56 28 8 1 
1 9 36 84 126 126 84 36 9 1 

/*3.创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求元素的值各不相同。*/

package test1j.ava;

import java.util.Random;
public class randnumber {
    
    
    public static void main(String[] args) {
    
    
        int[] nums = new int[6]; // 创建一个长度为6的int型数组
        Random rand = new Random(); // 创建一个伪随机数生成器

        // 循环生成一个数字，直到符合要求为止（1-30之间，且和数组中已有的数字不同）
        for (int i = 0; i < nums.length; i++) {
    
    
		int num;
		do {
    
    
		    num = rand.nextInt(30) + 1;
		} while (contains(nums, num, i));

		nums[i] = num; // 将符合条件的数字赋值给数组
        }

        // 打印数组的元素
    	System.out.print("随机生成的数组为{");
        for (int s=0;s<6;s++) {
    
    
        	if(s==5){
    
    
        		System.out.print(nums[s]);
        	}else
            System.out.print(nums[s]+",");
        }System.out.print("}");
        
    }

    // 判断一个数字是否已存在于数组中
    private static boolean contains(int[] nums, int num, int length) {
    
    
        for (int i = 0; i < length; i++) {
    
    
            if (nums[i] == num) {
    
    
                return true;
            }
        }
        return false;
    }
}

>运行结果
随机生成的数组为{
    
    9,15,13,17,21,11}

3.4 Algoritmos comuns envolvidos em arrays

1. Atribuição de elementos de matriz (triângulo Yanghui, número redondo, etc.)
2. Encontre o máximo, mínimo, média, soma, etc. de elementos em uma matriz numérica
3. Cópia de matriz, inversão, pesquisa (pesquisa linear, pesquisa binária)
4. Algoritmo para classificar elementos de array

Introdução ao algoritmo
Cinco características do algoritmo

recurso	significado
Entrada	Existem 0 ou mais dados de entrada, essas entradas devem ser claramente descritas e definidas
Saída	Pelo menos um ou mais resultados de saída, nenhum resultado de saída não é permitido
Finitude (Finitude)	O algoritmo termina automaticamente após um número finito de etapas sem loops infinitos e cada etapa pode ser concluída em um tempo aceitável
definitividade	Cada passo no algoritmo tem um significado definido sem ambigüidade
Viabilidade (eficácia, eficácia)	Cada passo do algoritmo é claro e viável, permitindo que os usuários calculem a resposta com caneta e papel

prática

/*定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
要求：所有随机数都是两位数。*/

package test1j.ava;

import java.util.Random;

public class suanfa1 {
    
    
	public static void main(String[] args ){
    
    
	int[] arr = new int [10];// 创建一个长度为10的int型数组
	Random rand = new Random(); // 创建一个伪随机数生成器
	// 循环生成一个数字，直到符合要求为止(两位数，>=10&&<=99)
	for(int i = 0;i<10;i++){
    
    
		int num = rand.nextInt(90)+10;
		arr[i] = num;
	}

	// 求出所有元素的最大值，最小值，和值，平均值
	 int max = arr[0], min = arr[0], sum = 0;
     for (int num : arr) {
    
    //遍历数组快捷方式
         if (num > max) {
    
    
             max = num;
         }
         if (num < min) {
    
    
             min = num;
         }
         sum += num;
     }
     double average = (double) sum / arr.length;

     // 输出结果
     System.out.println("数组元素为：");
     for (int num : arr) {
    
    
         System.out.print(num + " ");
     }
     System.out.println();
     System.out.println("最大值为：" + max);
     System.out.println("最小值为：" + min);
     System.out.println("和值为：" + sum);
     System.out.println("平均值为：" + average);
 }
}

>运行结果
数组元素为：
83 26 95 85 49 38 37 94 72 19 
最大值为：95
最小值为：19
和值为：598
平均值为：59.8

① Algoritmo de busca binária

//二分法查找：要求此数组必须是有序的。

package test1j.ava;

public class erfen {
    
    

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		int[] arr3 = new int[]{
    
    -99,-54,-2,0,2,33,43,256,999};
		boolean isFlag = true;
		int number = 256;
		//int number = 25;
		int head = 0;//首索引位置
		int end = arr3.length - 1;//尾索引位置
		while(head <= end){
    
    
			int middle = (head + end) / 2;
			if(arr3[middle] == number){
    
    
				System.out.println("找到指定的元素，索引为：" + middle);
				isFlag = false;
				break;
			}else if(arr3[middle] > number){
    
    
				end = middle - 1;
			}else{
    
    //arr3[middle] < number
				head = middle + 1;
			}
		}
		if(isFlag){
    
    
		System.out.println("未找打指定的元素");
		}

	}

}

>运行结果
找到指定的元素，索引为：7

②Sorting Algorithm
Sorting:
Assuma que a sequência contendo n registros é {R1, R2,...,Rn}, e sua sequência de teclas correspondente é {K1, K2,...,Kn}. Reordene esses registros em {Ri1, Ri2,...,Rin}, de modo que os valores de chave correspondentes satisfaçam a condição Ki1<=Ki2<=...<=Kin, tal operação é chamada de classificação.

De um modo geral, o objetivo da classificação é encontrar arquivos .

Meça os prós e contras dos algoritmos de ordenação:

• Complexidade de tempo: analise o número de comparações de palavras-chave e o número de movimentos de registros
• Complexidade do espaço: analise quanta memória auxiliar é necessária no algoritmo de ordenação
• Estabilidade: Se os valores-chave de dois registros A e B forem iguais, mas a ordem de A e B permanecer inalterada após a classificação, o algoritmo de classificação é considerado estável.

Classificação dos algoritmos de ordenação: ordenação interna e ordenação externa.

• Classificação interna: Todo o processo de classificação não requer armazenamento externo (como discos, etc.) e todas as operações de classificação são concluídas na memória .
• Classificação externa: há muitos dados envolvidos na classificação e a quantidade de dados é muito grande. O computador não pode concluir todo o processo de classificação na memória e deve contar com armazenamento externo (como disco). A classificação externa mais comum é a classificação por mesclagem multidirecional . Pode-se considerar que a ordenação externa é composta por múltiplas ordenações internas.

Dez principais algoritmos de classificação

• ordenação por seleção
  ordenação por seleção direta, ordenação por heap
• Trocar Ordenação Ordenação
  por Bolha Ordenação Rápida
• Classificação por inserção
  Classificação por inserção direta, classificação por meia inserção, classificação por shell
• classificação de mesclagem
• tipo de balde
• classificação radix

③Classificação de bolhas

Introdução:
O princípio da classificação por bolhas é muito simples: ele visita repetidamente o array a ser classificado, compara dois elementos por vez e os troca se a ordem deles estiver errada.

Classificar ideias:

1. Comparar elementos adjacentes. Se o primeiro for maior que o segundo (em ordem crescente), troque os dois.
2. Faça o mesmo para cada par de elementos adjacentes, desde o primeiro par no início até o último par no final. Depois que essa etapa for concluída, o último elemento será o maior número.
3. Repita as etapas acima para todos os elementos, exceto o último.
4. Continue repetindo as etapas acima para cada vez menos elementos até que não haja pares de números para comparar.

④ classificação rápida

Introdução:
A classificação rápida geralmente é significativamente mais rápida do que outros algoritmos com o mesmo O(nlogn), por isso é frequentemente usada, e a classificação rápida adota a ideia de dividir e conquistar , para que você possa ver frequentemente a sombra da classificação rápida em muitas entrevistas de testes escritos. Pode-se ver a importância de dominar a ordenação rápida.

Inventado pelo vencedor do Turing Award, Tony Hoare, o Quick Sort está listado como um dos dez melhores algoritmos do século 20 e é de longe o mais rápido de todos os algoritmos de classificação interna. Uma versão atualizada do tipo de bolha, uma espécie de tipo de troca. A complexidade de tempo da ordenação rápida éO(nlog(n))。

Classificar ideias:

1. Escolha um elemento da sequência, chamado de " pivô " (pivot),
2. Reordene a matriz, todos os elementos menores que o valor de referência são colocados na frente da referência e todos os elementos maiores que o valor de referência são colocados atrás da referência (o mesmo número pode ir para qualquer um dos lados). Terminada essa divisão, o benchmark fica no meio da sequência. Isso é chamado de operação de partição. //Frente grande e costas pequenas
3. Classifique recursivamente submatrizes com elementos menores que o valor base e submatrizes com elementos maiores que o valor base.
4. O caso inferior da recursão é que o tamanho da sequência é zero ou um, ou seja, ela sempre foi classificada. Embora tenha ocorrido recursivamente, este algoritmo sempre terminará, pois a cada iteração (iteração), ele colocará pelo menos um elemento em sua última posição.

⑤Comparação de desempenho do algoritmo de classificação

1. Em termos de tempo médio : o quicksort é o melhor. Mas, no pior caso, o desempenho do tempo não é tão bom quanto o heap sort e o merge sort.
2. Do ponto de vista da simplicidade do algoritmo : Como os algoritmos de classificação por seleção direta, classificação por inserção direta e classificação por bolhas são relativamente simples, eles são considerados algoritmos simples. Para os algoritmos de classificação Shell, classificação de heap, classificação rápida e classificação de mesclagem, seus algoritmos são mais complexos e são considerados classificação complexa.
3. Do ponto de vista da estabilidade : classificação por inserção direta, classificação por bolhas e classificação por mesclagem são estáveis; enquanto classificação por seleção direta, classificação rápida, classificação por shell e classificação por heap são classificações instáveis
4. Do tamanho do número n de registros a serem classificados : quando n é pequeno, deve ser usada a classificação simples; e quando n é grande, deve ser usada a classificação melhorada.

Selecção do Algoritmo de Ordenação

1. Se n compararPequeno(como n≤50), pode ser usadoinserir diretamenteouordenação por seleção direta.
   Quando o tamanho do registro é pequeno, a classificação por inserção direta é melhor; caso contrário, como o número de registros movidos pela seleção direta é menor que o da inserção direta, a classificação por seleção direta deve ser selecionada.
2. Se o estado inicial do arquivo for basicamenteordenadamente, você deve escolherInserção, bolha ou quicksort aleatórioapropriado;
3. Se n comparargrande, o método de ordenação com complexidade de tempo de O(nlgn) deve ser adotado:Classificação rápida, classificação por pilha ou classificação por mesclagem

3.5 Exceções comuns no uso de arrays

3.6 Uso da classe de ferramentas Arrays

A classe java.util.Arrays é uma classe de ferramenta para manipular matrizes, que contém vários métodos para manipular matrizes (como classificação e pesquisa).