Introdução ao uso de arrays JAVA

Autor：Eve Cole Data da Última Atualização：2024-11-19 16:12:02

Existem três diferenças principais entre arrays JAVA e classes de contêiner: eficiência, tipo e capacidade de salvar tipos básicos . Em JAVA, arrays são a maneira mais eficiente de armazenar e acessar aleatoriamente uma sequência de referências de objetos. Um array é uma sequência linear simples, o que torna o acesso aos elementos muito rápido. Mas o preço pago por isso é que o tamanho do array é fixo e não pode ser alterado durante sua vida útil.

Graças aos genéricos e aos mecanismos de empacotamento automático, os contêineres agora podem ser usados com tipos primitivos quase tão facilmente quanto com arrays. Tanto os arrays quanto os contêineres podem impedir que você abuse deles até certo ponto. Se eles saírem dos limites, você receberá uma RuntimeException. A única vantagem remanescente dos arrays é a eficiência. No entanto, se você quiser resolver problemas mais gerais, os arrays podem ser muito restritivos, portanto, neste caso, a maioria das pessoas ainda escolherá contêineres.

Portanto, se você estiver usando versões JAVA recentes, você deve preferir contêineres a arrays. Os programas só devem ser refatorados para arrays se o desempenho for comprovado como um problema e a mudança para arrays melhorar o desempenho.

【inicialização】
JAVA possui regulamentações muito rígidas sobre inicialização de array, o que pode prevenir efetivamente o abuso de arrays. Se houver um erro de inicialização, você obterá CompileException em vez de RuntimeException diretamente. Nada pode ser feito com esta referência de array até que o array seja inicializado corretamente.
As definições de array incluem int[] array e int array[]. Geralmente, o primeiro estilo é usado para separar o tipo do nome da variável.
Existem duas maneiras de inicializar um array: inicialização estática e inicialização dinâmica. O comprimento deve ser especificado durante a inicialização. O comprimento da primeira dimensão do array multidimensional deve ser apontado e deve ser definido de dimensões altas para baixas. A ação de inicialização pode estar em qualquer lugar do código, mas o método {} só pode aparecer onde a matriz é criada. Consulte o programa para métodos de inicialização específicos:

Copie o código do código da seguinte forma:

classe pública javaArrayInit{
public static void main(String args[]){
int[] arrayA; //não inicializado
int[] arrayB = new int[5]; //inicialização estática
//System.out.println(arrayA.length); //CompileException
System.out.println("arrayB length: " + arrayB.length); //Não é possível obter o número real de elementos salvos;

arrayA = new int[10]; //Inicialização dinâmica
System.out.println("comprimento do arrayA: " + arrayA.length);

int[] matrizC = new int[]{1,2,3,4};
System.out.println("comprimento do arrayC: " + arrayC.length);

//int[] arrayD = new int[1]{1}; //Inicialização, dimensões e valores de inicialização errados não podem ser definidos ao mesmo tempo

int[][] arrayE = new int[1][];
System.out.println("comprimento do arrayE: " + arrayE.length);

//int[][] arrayF = new int[][2] //O comprimento da dimensão alta deve ser especificado primeiro;

int[][] matrizG = novo int[][]{{1,2,3,4},{5,6,7},{7,24,23,24}};
System.out.println("comprimento do arrayG: " + arrayG.length);

int[][][] matrizH = novo int[][][]{{{1,2,3},{4,5,6},{7,8,9},{10,11,12} }};
System.out.println("comprimento do arrayH: " + arrayH.length);

dummyArray[] arrayI = {new dummyArray(),new dummyArray()} //Tipo de array personalizado
System.out.println("comprimento do arrayI: " + arrayI.length);
System.out.println("arrayI[1]: " + arrayI[1].getValue());

dummyArray[] arrayK = new dummyArray[5];
System.out.println("arrayK[0]: " + arrayK[0]);
for(int i = 0; i < arrayK.length; i++){
arrayK[i] = new dummyArray();
}
System.out.println("arrayK[0]: " + arrayK[0].getValue());
}
}
classe dummyArray{
temperatura interna estática privada;
private final int arrayValue = temp++;
public int getValor(){
return arrayValor;
}
}

Saída:

comprimento da matrizB: 5
comprimento da matrizA: 10
comprimento da matrizC: 4
comprimento da matrizE: 1
comprimento da matrizG: 3
comprimento da matrizH: 1
comprimento da matrizI: 2
matrizI[1]: 1
matrizK[0]: nulo
matrizK[0]: 2

【comprimento】
O comprimento do membro somente leitura faz parte do objeto array (embora esta variável não seja realmente declarada na API e seja gerada dinamicamente em tempo de execução). Este é o único campo ou método que pode ser acessado. A sintaxe [] é a única maneira de acessar objetos array, e os contêineres são acessados através do método get(). Você pode usar Array.length para obter o tamanho do array. Observe que é diferente de String.length() do tipo String. Array usa variáveis de membro, enquanto String usa métodos de membro. Ao mesmo tempo, Array.length só pode obter o tamanho do array, mas não quantos elementos o array realmente possui. O comprimento de uma matriz multidimensional calcula apenas o comprimento da primeira dimensão.

Copie o código do código da seguinte forma:

classe pública javaArrayLength{
public static void main(String args[]){
int[] matrizA = new int[15];
matrizA[1] = 1;
matrizA[2] = 2;
matrizA[3] = 3;
System.out.println("comprimento do arrayA: " + arrayA.length);

int[][] matrizB = new int[10][];
System.out.println("comprimento do arrayB: " + arrayB.length);

int[][] matrizC = novo int[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7} ,};//Preste atenção na vírgula depois
System.out.println("comprimento do arrayC: " + arrayC.length);

int[][] arrayD = novo int[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7} ,{}};
System.out.println("comprimento do arrayD: " + arrayD.length);
}
}
Saída:

comprimento da matrizA: 15
comprimento da matrizB: 10
comprimento da matrizC: 3
comprimento da matrizD: 4

【Arrays.fill】
Arrays.fill é um método muito limitado porque só pode preencher cada posição com o mesmo valor (ou, no caso de um objeto, copiar a mesma referência para preencher). Usar Arrays.fill pode preencher todo o array ou uma determinada área do array, mas como Arrays.fill só pode ser chamado com um único valor, não é muito útil.

[Atribuição e Referência]
Quando um array JAVA é inicializado, ele possui apenas uma referência ao array e nenhum espaço de armazenamento é alocado para o array. Portanto, a cópia entre arrays não pode simplesmente usar a atribuição "=", porque o mesmo objeto é operado. O seguinte procedimento:

Copie o código do código da seguinte forma:

classe pública javaArrayQuote{
public static void main(String args[]){
String testeA = "testeA";
String testeB = "testeB";
String[] arrayA = new String[]{"arrayA"};
String[] matrizB = new String[]{"arrayB"};
testeB = testeA;
testeB = "alteração testeB";
System.out.println("Sou testA, não mudei: " + testA);
matrizB = matrizA;
arrayB[0] = "arrayB foi alterado";
System.out.println("Sou arrayA, não mudei: " + arrayA[0]);

}
}
Saída:

Sou testA, não mudei:testA
Sou arrayA, não mudei:arrayB mudou

Pode-se ver que quando alteramos o valor de arrayB[0], alteramos o array referenciado, então geramos arrayA[0], que na verdade é o mesmo que arrayB[0].

[Cópia da matriz]
Como copiar um array em JAVA:

1. Use o loop FOR para copiar todos os elementos ou elementos especificados, o que é menos eficiente.
2. Use o método clone para obter o valor do array em vez de uma referência. No entanto, o clone não pode copiar elementos especificados e tem baixa flexibilidade.
3. Use o método System.arraycopy(src, srcPos, dest, destPos, length) A biblioteca de classes padrão Java fornece o método estático System.arraycopy(). .arraycopy() é para todos os tipos estão sobrecarregados. Tanto os arrays de tipo básico quanto os arrays de objetos podem ser copiados usando System.arraycopy(), mas os arrays de objetos apenas copiam referências e não haverá duas cópias de objetos. Isso é chamado de cópia superficial.
src: matriz de origem;
srcPos: a posição inicial do array de origem a ser copiado;
dest: matriz de destino;
destPos: a posição inicial onde o array de destino é colocado;
comprimento: O comprimento da cópia.
Nota: System.arraycopy() não realiza empacotamento e descompactação automáticos, portanto os dois arrays devem ser do mesmo tipo ou podem ser convertidos em arrays do mesmo tipo. Ao mesmo tempo, este método também pode ser usado para copiar o próprio array.
int[] teste ={0,1,2,3,4,5,6};
System.arraycopy(teste,0,teste,3,3);
O resultado é: {0,1,2,0,1,2,6};
O procedimento de teste é o seguinte:

Copie o código do código da seguinte forma:

classe pública javaArrayCopy{
public static void main(String args[]){
int[] matriz = {1,2,3,4,5,6,7,8,9};
//para método de loop
int[] matrizA = new int[9];
for(int i = 0; i < arrayA.length; i++){
matrizA[i] = matriz[i];
System.out.print(arrayA[i] + ",");
}
//teste
System.out.println("");
matrizA[1] = 19;
for(int i = 0; i < arrayA.length; i++){
System.out.print(arrayA[i] + ",");
}
System.out.println("");
for(int i = 0; i < array.length; i++){
System.out.print(array[i] + ",");
}
System.out.println("");

//clonar método
int[] matrizB = new int[9];
arrayB = array.clone();
//teste
matrizB[1] = 19;
for(int i = 0; i < arrayB.length; i++){
System.out.print(arrayB[i] + ",");
}
System.out.println("");
for(int i = 0; i < array.comprimento; i++){
System.out.print(array[i] + ",");
}
System.out.println("");

//Método System.arrayCopy
int[] matrizC = new int[9];
System.arraycopy(array, 0, arrayC, 0, arrayC.length);
//teste
matrizC[1] = 19;
for(int i = 0; i < arrayC.length; i++){
System.out.print(arrayC[i] + ",");
}
System.out.println("");
for(int i = 0; i < array.comprimento; i++){
System.out.print(array[i] + ",");
}
}
}

[Comparação de matrizes]
Arrays fornece um método equals() sobrecarregado, que é sobrecarregado para todos os tipos e tipos de objetos para comparar o array inteiro. A condição para a igualdade da matriz é que o número de elementos seja igual e os elementos nas posições correspondentes também sejam iguais. O método deepEquals() é usado para comparação de arrays multidimensionais. Os dois arrays comparados pelo método Array.equals() devem ser arrays do mesmo tipo.

Copie o código do código da seguinte forma:

importar java.util.Arrays;
classe pública javaArrayEquals{
public static void main(String args[]){
int[] matrizA = {1,2,3};
int[] matrizB = {1,2,3,};
int[] arrayC = new int[4]; //se int[] arrayC = new int[3],return true
matrizC[0] = 1;
matrizC[1] = 2;
matrizC[2] = 3;
System.out.println(Arrays.equals(arrayA, arrayB));
System.out.println(Arrays.equals(arrayA, arrayC));

String[][] arrayD = {{"a","b"},{"c","d"}};
String[][] arrayE = {{"a","b"},{"c","d"}};
System.out.println(Arrays.deepEquals(arrayD, arrayE));
}
}

[Classificação e pesquisa de array]
Os arrays fornecem um método de classificação integrado sort(), que pode classificar qualquer array de tipo básico ou array de objetos (o objeto deve implementar a interface Comparable ou ter um Comparator associado). JAVA fornece diferentes métodos de classificação para diferentes tipos - classificação rápida projetada para tipos básicos e "classificação de mesclagem estável" projetada para objetos, portanto, não há necessidade de se preocupar com a eficiência da classificação de array.
binarySearch() é usado para encontrar rapidamente elementos em um array classificado. Se binarySearch() for usado em um array não classificado, ocorrerão resultados imprevisíveis.

[matriz de retorno]
C e C++ não podem retornar um array, apenas um ponteiro para o array, porque retornar um array dificulta o controle do ciclo de vida do array e pode facilmente causar vazamentos de memória. Java permite retornar um array diretamente, e ele pode ser reciclado pelo mecanismo de coleta de lixo.

[Conversão de array e contêiner] [Não é possível converter array de tipo básico]

Converter array em lista:

Copie o código do código da seguinte forma:

importar java.util.*;
classe pública arrayToList{
public static void main(String args[]){
String[] matrizA = {"a","b","c"};
Lista listaA = java.util.Arrays.asList(arrayA);
System.out.println("listaA: " + listaA);

int[] matrizB = {1,2,3};
Lista listaB = java.util.Arrays.asList(arrayB);
System.out.println("listaB: " + listaB);

Inteiro[] matrizC = {1,2,3};
Lista listaC = java.util.Arrays.asList(arrayC);
System.out.println("listaC: " + listaC);
}
}
Saída:

listaA: [a, b, c]
listaB: [[I@de6ced]
listaC: [1, 2, 3]

Por que as saídas int e Integer são diferentes?

Converter lista em array

Copie o código do código da seguinte forma:

importar java.util.*;
classe pública listToArray{
public static void main(String args[]){
Lista<String> lista = new ArrayList<String>();
matriz de string[];
list.add("testeA");
list.add("testeB");
list.add("testeC");
System.out.println("lista: " + lista);

String[] strings = new String[list.size()];
matriz = lista.toArray(strings);
for(int i = 0, j = array.length; i < j; i++){
System.out.print(array[i] + ",");
}
}
}
A saída é:

lista: [testeA, testeB, testeC]
testeA,testeB,testeC

【Remover dados duplicados】
A conversão de array e contêiner pode remover facilmente dados duplicados de um array, mas se o array for muito grande, a eficiência será um problema.

Copie o código do código da seguinte forma:

importar java.util.*;
classe pública javaArrayUnique{
public static void main(String args[]){
String[] matriz = {"a","b","a","a","c","b"};
arrayÚnico(matriz);
//teste
for(int i = 0, j = arrayUnique(array).length; i < j; i++){
System.out.print(arrayUnique(array)[i] + ",");
}
}

public static String[] arrayUnique(String[] array){
Lista<String> lista = new ArrayList<String>();
for(int i = 0, j = array.length; i < j; i++){
if(!list.contains(array[i])){
lista.add(matriz[i]);
}
}
String[] strings = new String[list.size()];
String[] arrayUnique = list.toArray(strings);
retornar arrayÚnico;
}
}

Em relação à questão da eficiência, fiz uma comparação. A execução de um array de 100.000 dados em meu computador leva cerca de 577 ms, enquanto a execução de um array de um milhão de dados leva cerca de 5.663 ms. Isso também está relacionado às capacidades de execução do computador, mas obviamente aumenta com o tamanho do array.

Copie o código do código da seguinte forma:

importar java.util.*;
classe pública javaArrayUnique{
public static void main(String args[]){
Matriz Dupla[] = new Dupla[100000];
for(int i = 0, j = array.length; i < j; i++){
array[i] = Math.ceil(Math.random()*1000);
}

Double[] matrizB = new Double[1000000];
for(int i = 0, j = arrayB.length; i < j; i++){
arrayB[i] = Math.ceil(Math.random()*1000);
}

System.out.println("iniciar");
startTime longo = System.currentTimeMillis();
arrayÚnico(matriz);
endTime longo = System.currentTimeMillis();
System.out.println("tempo de execução exclusivo da matriz: " +(endTime - startTime) +"ms");

startTimeB longo = System.currentTimeMillis();
matrizÚnica(matrizB);
endTimeB longo = System.currentTimeMillis();
System.out.println("tempo de execução exclusivo do arrayB: " +(endTimeB - startTimeB) +"ms");
}

public static Double[] arrayUnique(Double[] array){
Lista<Duplo> lista = new ArrayList<Duplo>();
for(int i = 0, j = array.length; i < j; i++){
if(!list.contains(array[i])){
lista.add(matriz[i]);
}
}
Double[] dobra = new Double[list.size()];
Double[] arrayUnique = list.toArray(doubles);
retornar arrayÚnico;
}
}
Saída:

começar
tempo de execução exclusivo da matriz: 577 ms
Tempo de execução exclusivo do arrayB: 5663 ms