Hay tres diferencias principales entre las matrices JAVA y las clases de contenedores: eficiencia, tipo y capacidad de guardar tipos básicos . En JAVA, las matrices son la forma más eficaz de almacenar y acceder aleatoriamente a una secuencia de referencias de objetos. Una matriz es una secuencia lineal simple, lo que hace que el acceso a los elementos sea muy rápido. Pero el precio que se paga por esto es que el tamaño de la matriz es fijo y no se puede cambiar durante su vida útil.
Gracias a los genéricos y a los mecanismos de empaquetado automático, los contenedores ahora se pueden utilizar con tipos primitivos casi tan fácilmente como con las matrices. Tanto las matrices como los contenedores pueden evitar que usted abuse de ellos hasta cierto punto. Si se salen de los límites, obtendrá una RuntimeException. La única ventaja restante de las matrices es la eficiencia. Sin embargo, si desea resolver problemas más generales, las matrices pueden ser demasiado restrictivas, por lo que en este caso la mayoría de la gente seguirá eligiendo contenedores.
Por lo tanto, si está utilizando versiones recientes de JAVA, debería preferir los contenedores a las matrices. Los programas solo deben refactorizarse en matrices si se ha demostrado que el rendimiento es un problema y el cambio a matrices mejora el rendimiento.
【inicialización】
JAVA tiene regulaciones muy estrictas sobre la inicialización de matrices, que pueden prevenir eficazmente el abuso de matrices. Si hay un error de inicialización, obtendrá CompileException en lugar de RuntimeException directamente. No se puede hacer nada con esta referencia de matriz hasta que la matriz se inicialice correctamente.
Las definiciones de matriz incluyen int[] array e int array[]. Generalmente, el primer estilo se utiliza para separar el tipo del nombre de la variable.
Hay dos formas de inicializar una matriz: inicialización estática e inicialización dinámica. La longitud debe especificarse durante la inicialización. Se debe señalar la longitud de la primera dimensión de la matriz multidimensional y se debe definir de dimensiones superiores a inferiores. La acción de inicialización puede estar en cualquier parte del código, pero el método {} solo puede aparecer donde se crea la matriz. Consulte el programa para conocer métodos de inicialización específicos:
arrayA = new int[10]; //Inicialización dinámica
System.out.println("arrayA length: " + arrayA.length);
int[] matrizC = nuevo int[]{1,2,3,4};
System.out.println("longitud de matrizC: " + longitud de matrizC);
//int[] arrayD = new int[1]{1}; //La inicialización, las dimensiones y los valores de inicialización incorrectos no se pueden definir al mismo tiempo
int[][] matrizE = nuevo int[1][];
System.out.println("longitud matrizE: " + matrizE.longitud);
//int[][] arrayF = new int[][2] //La longitud de la dimensión alta debe especificarse primero
int[][] arrayG = nuevo int[][]{{1,2,3,4},{5,6,7},{7,24,23,24}};
System.out.println("longitud de matrizG: " + longitud de matrizG);
int[][][] arrayH = nuevo int[][][]{{{1,2,3},{4,5,6},{7,8,9},{10,11,12} }};
System.out.println("longitud de matrizH: " + longitud de matrizH);
dummyArray[] arrayI = {new dummyArray(),new dummyArray()} //Tipo de matriz personalizado;
System.out.println("longitud de la matrizI: " + longitud de la matrizI);
System.out.println("arrayI[1]: " + arrayI[1].getValue());
dummyArray[] arrayK = nuevo dummyArray[5];
System.out.println("arrayK[0]: " + arrayK[0]);
for(int i = 0; i < arrayK.length; i++){
arrayK[i] = nuevo dummyArray();
}
System.out.println("arrayK[0]: " + arrayK[0].getValue());
}
}
clase matriz ficticia{
temperatura interna estática privada;
privado final int arrayValue = temp++;
público int getValue(){
devolver valormatriz;
}
}
Producción:
longitud de la matriz B: 5
longitud de la matriz A: 10
longitud de la matriz C: 4
longitud de la matriz E: 1
longitud de la matriz G: 3
longitud de la matriz H: 1
longitud de la matriz I: 2
matrizI[1]: 1
matrizK[0]: nulo
matrizK[0]: 2
int[][] matrizB = nuevo int[10][];
System.out.println("longitud matrizB: " + longitud matrizB);
int[][] matrizC = nuevo int[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7} ,};//Presta atención a la coma después
System.out.println("longitud de matrizC: " + longitud de matrizC);
int[][] arrayD = nuevo int[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7} ,{}};
System.out.println("longitud de matrizD: " + longitud de matrizD);
}
}
Producción:
longitud de la matriz A: 15
longitud de la matriz B: 10
longitud de la matriz C: 3
longitud de la matrizD: 4
[Asignación y referencia]
Cuando se inicializa una matriz JAVA, solo tiene una referencia a la matriz y no se le asigna espacio de almacenamiento. Por lo tanto, la copia entre matrices no puede simplemente usar la asignación "=", porque se opera el mismo objeto. El siguiente procedimiento:
}
}
Producción:
Soy testA, no he cambiado:testA
Soy arrayA, no he cambiado: arrayB ha cambiado
[Copia de matriz]
Cómo copiar una matriz en JAVA:
1. Utilice el bucle FOR para copiar todos los elementos o los elementos especificados, lo cual es menos eficiente.
2. Utilice el método de clonación para obtener el valor de la matriz en lugar de una referencia. Sin embargo, la clonación no puede copiar elementos específicos y tiene poca flexibilidad.
3. Utilice el método System.arraycopy(src, srcPos, dest, destPos, length). La biblioteca de clases estándar de Java proporciona el método estático System.arraycopy(). Usarlo para copiar una matriz es mucho más rápido que un bucle for. .arraycopy() es para Todos los tipos están sobrecargados. Tanto las matrices de tipos básicos como las matrices de objetos se pueden copiar usando System.arraycopy(), pero las matrices de objetos solo copian referencias y no habrá dos copias de los objetos. Esto se llama copia superficial.
src: matriz fuente;
srcPos: la posición inicial de la matriz fuente que se va a copiar;
destino: matriz de destino;
destPos: la posición inicial donde se coloca la matriz de destino;
longitud: La longitud de la copia.
Nota: System.arraycopy() no realiza el empaquetado ni el desempaquetado automáticos, por lo que las dos matrices deben ser del mismo tipo o pueden convertirse en matrices del mismo tipo. Al mismo tiempo, este método también se puede utilizar para copiar la propia matriz.
int[] prueba ={0,1,2,3,4,5,6};
System.arraycopy(prueba,0,prueba,3,3);
El resultado es: {0,1,2,0,1,2,6};
El procedimiento de prueba es el siguiente:
//método de clonación
int[] matrizB = nuevo int[9];
matrizB = matriz.clon();
//prueba
matrizB[1] = 19;
for(int i = 0; i < matrizB.length; i++){
System.out.print(matrizB[i] + ",");
}
System.out.println("");
for(int i = 0; i < matriz.longitud; i++){
System.out.print(matriz[i] + ",");
}
System.out.println("");
//Método System.arrayCopy
int[] matrizC = nuevo int[9];
System.arraycopy(matriz, 0, matrizC, 0, matrizC.longitud);
//prueba
matrizC[1] = 19;
for(int i = 0; i < arrayC.length; i++){
System.out.print(matrizC[i] + ",");
}
System.out.println("");
for(int i = 0; i < matriz.longitud; i++){
System.out.print(matriz[i] + ",");
}
}
}
Cadena[][] matrizD = {{"a","b"},{"c","d"}};
Cadena[][] matrizE = {{"a","b"},{"c","d"}};
System.out.println(Arrays.deepEquals(arrayD, arrayE));
}
}
[matriz de retorno]
C y C++ no pueden devolver una matriz, solo un puntero a la matriz, porque devolver una matriz dificulta el control del ciclo de vida de la matriz y puede causar fácilmente pérdidas de memoria. Java permite devolver una matriz directamente y puede reciclarse mediante el mecanismo de recolección de basura.
[Conversión de matriz y contenedor] [No se puede convertir una matriz de tipo básico]
Convertir matriz a lista:
int[] matrizB = {1,2,3};
Lista listaB = java.util.Arrays.asList(arrayB);
System.out.println("listaB: " + listaB);
Entero[] matrizC = {1,2,3};
Lista listaC = java.util.Arrays.asList(arrayC);
System.out.println("listaC: " + listaC);
}
}
Producción:
listaA: [a, b, c]
listaB: [[I@de6ced]
listaC: [1, 2, 3]
Convertir lista en matriz
Cadena[] cadenas = nueva Cadena[lista.tamaño()];
matriz = lista.toArray(cadenas);
for(int i = 0, j = matriz.longitud; i < j; i++){
System.out.print(matriz[i] + ",");
}
}
}
La salida es:
lista: [pruebaA, pruebaB, pruebaC]
pruebaA, pruebaB, pruebaC
cadena estática pública [] matrizUnique (matriz de cadena []) {
Lista<Cadena> lista = nueva ArrayList<Cadena>();
for(int i = 0, j = matriz.longitud; i < j; i++){
if(!lista.contiene(matriz[i])){
lista.add(matriz[i]);
}
}
Cadena[] cadenas = nueva Cadena[lista.tamaño()];
String[] arrayUnique = list.toArray(strings);
devolver matrizUnique;
}
}
Doble[] matrizB = nuevo Doble[1000000];
for(int i = 0, j = arrayB.length; i < j; i++){
matrizB[i] = Math.ceil(Math.random()*1000);
}
System.out.println("inicio");
tiempo de inicio largo = System.currentTimeMillis();
matrizÚnica(matriz);
tiempo final largo = System.currentTimeMillis();
System.out.println("tiempo de ejecución único de la matriz: " +(endTime - startTime) +"ms");
long startTimeB = System.currentTimeMillis();
matrizUnique(matrizB);
long endTimeB = System.currentTimeMillis();
System.out.println("tiempo de ejecución único de matrizB: " +(endTimeB - startTimeB) +"ms");
}
matriz doble [] pública estática única (matriz doble []) {
Lista<Doble> lista = nueva ArrayList<Doble>();
for(int i = 0, j = matriz.longitud; i < j; i++){
if(!lista.contiene(matriz[i])){
lista.add(matriz[i]);
}
}
Doble[] dobles = nuevo Doble[list.size()];
Doble[] arrayUnique = list.toArray(dobles);
devolver matrizUnique;
}
}
Producción:
comenzar
tiempo de ejecución único de la matriz: 577 ms
tiempo de ejecución único de arrayB: 5663 ms