Il existe trois différences principales entre les tableaux JAVA et les classes de conteneurs : l'efficacité, le type et la possibilité d'enregistrer les types de base . En JAVA, les tableaux constituent le moyen le plus efficace de stocker et d’accéder de manière aléatoire à une séquence de références d’objets. Un tableau est une séquence linéaire simple, qui rend l’accès aux éléments très rapide. Mais le prix à payer est que la taille de la baie est fixe et ne peut pas être modifiée au cours de sa durée de vie.
Grâce aux génériques et aux mécanismes de packaging automatiques, les conteneurs peuvent désormais être utilisés avec des types primitifs presque aussi facilement qu'avec des tableaux. Les tableaux et les conteneurs peuvent vous empêcher d'en abuser dans une certaine mesure. S'ils dépassent les limites, vous obtiendrez une RuntimeException. Le seul avantage restant des tableaux est l'efficacité. Cependant, si vous souhaitez résoudre des problèmes plus généraux, les tableaux peuvent être trop restrictifs, donc dans ce cas, la plupart des gens choisiront toujours des conteneurs.
Par conséquent, si vous utilisez des versions JAVA récentes, vous devez préférer les conteneurs aux tableaux. Les programmes ne doivent être refactorisés vers des tableaux que si les performances s'avèrent être un problème et que le passage aux tableaux améliore les performances.
【initialisation】
JAVA a des réglementations très strictes sur l'initialisation des tableaux, ce qui peut empêcher efficacement les abus des tableaux. S'il y a une erreur d'initialisation, vous obtiendrez directement CompileException au lieu de RuntimeException. Rien ne peut être fait avec cette référence de tableau tant que le tableau n'est pas correctement initialisé.
Les définitions de tableau incluent int[] array et int array[]. Généralement, le premier style est utilisé pour séparer le type du nom de la variable.
Il existe deux manières d'initialiser un tableau : l'initialisation statique et l'initialisation dynamique. La longueur doit être spécifiée lors de l'initialisation. La longueur de la première dimension du tableau multidimensionnel doit être indiquée, et elle doit être définie des dimensions élevées aux dimensions faibles. L'action d'initialisation peut se situer n'importe où dans le code, mais la méthode {} ne peut apparaître qu'à l'endroit où le tableau est créé. Voir le programme pour les méthodes d'initialisation spécifiques :
arrayA = new int[10]; //Initialisation dynamique
System.out.println("arrayA length: " + arrayA.length);
int[] arrayC = nouveau int[]{1,2,3,4};
System.out.println("arrayC length: " + arrayC.length);
//int[] arrayD = new int[1]{1}; //Une initialisation incorrecte, des dimensions et des valeurs d'initialisation ne peuvent pas être définies en même temps
int[][] arrayE = new int[1][];
System.out.println("arrayE length: " + arrayE.length);
//int[][] arrayF = new int[][2]; //La longueur de la dimension élevée doit être spécifiée en premier
int[][] arrayG = new int[][]{{1,2,3,4},{5,6,7},{7,24,23,24}};
System.out.println("arrayG length: " + arrayG.length);
int[][][] arrayH = nouveau int[][][]{{{1,2,3},{4,5,6},{7,8,9},{10,11,12} }} ;
System.out.println("arrayH length: " + arrayH.length);
dummyArray[] arrayI = {new dummyArray(),new dummyArray()} ; //Type de tableau personnalisé
System.out.println("arrayI length: " + arrayI.length);
System.out.println("arrayI[1]: " + arrayI[1].getValue());
dummyArray[] arrayK = nouveau dummyArray[5];
System.out.println("arrayK[0]: " + arrayK[0]);
pour(int i = 0; i < arrayK.length; i++){
arrayK[i] = new dummyArray();
}
System.out.println("arrayK[0]: " + arrayK[0].getValue());
}
}
classe dummyArray{
temp. int statique privée ;
private final int arrayValue = temp++;
public int getValue(){
retourner arrayValue ;
}
}
Sortir:
longueur du tableauB : 5
longueur du tableau A : 10
longueur du tableauC : 4
longueur du tableauE : 1
longueur du tableauG : 3
longueur du tableauH : 1
longueur du tableau I : 2
tableauI[1] : 1
tableauK[0] : nul
tableauK[0] : 2
int[][] arrayB = new int[10][];
System.out.println("longueur du tableauB : " + tableauB.longueur);
int[][] arrayC = nouveau int[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7} ,};//Faites attention à la virgule après
System.out.println("arrayC length: " + arrayC.length);
int[][] arrayD = nouveau int[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7} ,{}} ;
System.out.println("arrayD length: " + arrayD.length);
}
}
Sortir:
longueur du tableauA : 15
longueur du tableauB : 10
longueur du tableauC : 3
longueur du tableauD : 4
[Affectation et référence]
Lorsqu'un tableau JAVA est initialisé, il n'a qu'une référence au tableau et aucun espace de stockage n'est alloué au tableau. Par conséquent, la copie entre tableaux ne peut pas simplement utiliser l'affectation "=", car le même objet est exploité. La procédure suivante :
}
}
Sortir:
Je m'appelle testA, je n'ai pas changé :testA
Je suis arrayA, je n'ai pas changé : arrayB a changé
[Copie du tableau]
Comment copier un tableau en JAVA :
1. Utilisez la boucle FOR pour copier tous les éléments spécifiés, ce qui est moins efficace.
2. Utilisez la méthode clone pour obtenir la valeur du tableau au lieu d'une référence. Cependant, clone ne peut pas copier les éléments spécifiés et a une faible flexibilité.
3. Utilisez la méthode System.arraycopy(src, srcPos, dest, destPos, length). La bibliothèque de classes standard Java fournit la méthode statique System.arraycopy(). Son utilisation pour copier un tableau est beaucoup plus rapide qu'une boucle for. .arraycopy() est pour Tous les types sont surchargés. Les tableaux de types de base et les tableaux d'objets peuvent être copiés à l'aide de System.arraycopy(), mais les tableaux d'objets ne copient que les références et il n'y aura pas deux copies d'objets. C'est ce qu'on appelle une copie superficielle.
src : tableau source ;
srcPos : la position de départ du tableau source à copier ;
dest : tableau de destination ;
destPos : la position de départ où le tableau de destination est placé ;
length : La longueur de la copie.
Remarque : System.arraycopy() n'effectue pas de packaging ni de déballage automatiques, les deux tableaux doivent donc être du même type ou peuvent être convertis en tableaux du même type. En même temps, cette méthode peut également être utilisée pour copier le tableau lui-même.
int[] test ={0,1,2,3,4,5,6} ;
System.arraycopy(test,0,test,3,3);
Le résultat est : {0,1,2,0,1,2,6} ;
La procédure de test est la suivante :
// méthode de clonage
int[] arrayB = nouveau int[9];
arrayB = array.clone();
//test
tableauB[1] = 19 ;
pour(int i = 0; i < arrayB.length; i++){
System.out.print(arrayB[i] + ",");
}
System.out.println("");
pour(int i = 0; i < array.length; i++){
System.out.print(array[i] + ",");
}
System.out.println("");
//Méthode System.arrayCopy
int[] arrayC = nouveau int[9];
System.arraycopy(array, 0, arrayC, 0, arrayC.length);
//test
tableauC[1] = 19 ;
pour(int i = 0; i < arrayC.length; i++){
System.out.print(arrayC[i] + ",");
}
System.out.println("");
pour(int i = 0; i < array.length; i++){
System.out.print(array[i] + ",");
}
}
}
String[][] arrayD = {{"a","b"},{"c","d"}};
String[][] arrayE = {{"a","b"},{"c","d"}};
System.out.println(Arrays.deepEquals(arrayD, arrayE));
}
}
[tableau de retour]
C et C++ ne peuvent pas renvoyer un tableau, seulement un pointeur vers le tableau, car le retour d'un tableau rend difficile le contrôle du cycle de vie du tableau et peut facilement provoquer des fuites de mémoire. Java permet de renvoyer directement un tableau, et il peut être recyclé par le mécanisme de garbage collection.
[Conversion de tableau et de conteneur] [Impossible de convertir un tableau de type de base]
Convertir un tableau en liste :
int[] tableauB = {1,2,3};
Liste listB = java.util.Arrays.asList(arrayB);
System.out.println("listB: " + listeB);
Tableau entier[]C = {1,2,3} ;
Liste listC = java.util.Arrays.asList(arrayC);
System.out.println("listC: " + listC);
}
}
Sortir:
listeA : [a, b, c]
listeB : [[I@de6ced]
listeC : [1, 2, 3]
Convertir une liste en tableau
String[] strings = new String[list.size()];
array = list.toArray(strings);
pour (int i = 0, j = array.length; i < j; i++){
System.out.print(array[i] + ",");
}
}
}
Le résultat est :
liste : [testA, testB, testC]
testA, testB, testC
public static String[] arrayUnique(String[] tableau){
List<String> list = new ArrayList<String>();
pour (int i = 0, j = array.length; i < j; i++){
if(!list.contains(array[i])){
list.add(array[i]);
}
}
String[] strings = new String[list.size()];
String[] arrayUnique = list.toArray(strings);
return arrayUnique ;
}
}
Double[] tableauB = nouveau Double[1000000];
pour (int i = 0, j = arrayB.length; i < j; i++){
arrayB[i] = Math.ceil(Math.random()*1000);
}
System.out.println("démarrer");
long startTime = System.currentTimeMillis();
arrayUnique(tableau);
long endTime = System.currentTimeMillis();
System.out.println("Array unique run time: " +(endTime - startTime) +"ms");
long startTimeB = System.currentTimeMillis();
tableauUnique(tableauB);
long endTimeB = System.currentTimeMillis();
System.out.println("ArrayB unique run time: " +(endTimeB - startTimeB) +"ms");
}
public static Double[] arrayUnique(Tableau Double[]){
List<Double> list = new ArrayList<Double>();
pour (int i = 0, j = array.length; i < j; i++){
if(!list.contains(array[i])){
list.add(array[i]);
}
}
Double[] doubles = new Double[list.size()];
Double[] arrayUnique = list.toArray(doubles);
return arrayUnique ;
}
}
Sortir:
commencer
durée d'exécution unique du tableau : 577 ms
Durée d'exécution unique du arrayB : 5 663 ms