Introduction à l'utilisation des tableaux JAVA

Auteur：Eve Cole Date de mise à jour：2024-11-19 16:12:02

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 :

Copiez le code comme suit :

classe publique javaArrayInit{
public static void main(String args[]){
int[] arrayA; //non initialisé
int[] arrayB = new int[5]; //initialisation statique
//System.out.println(arrayA.length); //CompileException
System.out.println("arrayB length: " + arrayB.length); //Impossible d'obtenir le nombre réel d'éléments enregistrés

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

【longueur】
La longueur du membre en lecture seule fait partie de l'objet tableau (bien que cette variable ne soit pas réellement déclarée dans l'API et soit générée dynamiquement au moment de l'exécution). Il s'agit du seul champ ou méthode accessible. La syntaxe [] est le seul moyen d'accéder aux objets du tableau, et les conteneurs sont accessibles via la méthode get(). Vous pouvez utiliser Array.length pour obtenir la taille du tableau. Notez qu'elle est différente de String.length() de type String. Array utilise des variables membres, tandis que String utilise des méthodes membres. Dans le même temps, Array.length ne peut obtenir que la taille du tableau, mais pas le nombre d'éléments que contient réellement le tableau. La longueur d'un tableau multidimensionnel calcule uniquement la longueur de la première dimension.

Copiez le code comme suit :

classe publique javaArrayLength{
public static void main(String args[]){
int[] arrayA = nouveau int[15];
tableauA[1] = 1;
tableauA[2] = 2;
tableauA[3] = 3;
System.out.println("arrayA length: " + arrayA.length);

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

【Arrays.fill】
Arrays.fill est une méthode très limitée car elle ne peut remplir chaque position qu'avec la même valeur (ou, dans le cas d'un objet, copier la même référence à remplir). L'utilisation d'Arrays.fill peut remplir tout le tableau ou une certaine zone du tableau, mais comme Arrays.fill ne peut être appelé qu'avec une seule valeur, ce n'est pas très utile.

[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 :

Copiez le code comme suit :

classe publique javaArrayQuote{
public static void main(String args[]){
Chaîne testA = "testA" ;
Chaîne testB = "testB" ;
String[] arrayA = new String[]{"arrayA"};
String[] arrayB = new String[]{"arrayB"};
testB = testA ;
testB = "changement testB" ;
System.out.println("Je m'appelle testA, je n'ai pas changé : " + testA);
tableauB = tableauA;
arrayB[0] = "le tableauB a changé" ;
System.out.println("Je m'appelle arrayA, je n'ai pas changé : " + arrayA[0]);

}
}
Sortir:

Je m'appelle testA, je n'ai pas changé :testA
Je suis arrayA, je n'ai pas changé : arrayB a changé

On peut voir que lorsque nous modifions la valeur de arrayB[0], nous modifions le tableau référencé, nous obtenons donc arrayA[0], qui est en fait le même que arrayB[0].

[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 :

Copiez le code comme suit :

classe publique javaArrayCopy{
public static void main(String args[]){
tableau int[] = {1,2,3,4,5,6,7,8,9} ;
//méthode de boucle for
int[] arrayA = nouveau int[9];
pour(int i = 0; i < arrayA.length; i++){
tableauA[i] = tableau[i];
System.out.print(arrayA[i] + ",");
}
//test
System.out.println("");
tableauA[1] = 19 ;
pour(int i = 0; i < arrayA.length; i++){
System.out.print(arrayA[i] + ",");
}
System.out.println("");
pour(int i = 0; i < array.length; i++){
System.out.print(array[i] + ",");
}
System.out.println("");

// 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] + ",");
}
}
}

[Comparaison de tableaux]
Arrays fournit une méthode equals() surchargée, qui est surchargée pour tous les types et types d'objets afin de comparer l'ensemble du tableau. La condition pour l’égalité du tableau est que le nombre d’éléments doit être égal et que les éléments aux positions correspondantes doivent également être égaux. La méthode deepEquals() est utilisée pour comparer des tableaux multidimensionnels. Les deux tableaux comparés par la méthode Array.equals() doivent être des tableaux du même type.

Copiez le code comme suit :

importer java.util.Arrays ;
classe publique javaArrayEquals{
public static void main(String args[]){
int[] tableauA = {1,2,3};
int[] tableauB = {1,2,3,};
int[] arrayC = new int[4]; //si int[] arrayC = new int[3], renvoie vrai
tableauC[0] = 1;
tableauC[1] = 2;
tableauC[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));
}
}

[Tri et recherche de tableaux]
Les tableaux fournissent une méthode de tri intégrée sort(), qui peut trier n'importe quel tableau de type de base ou tableau d'objets (l'objet doit implémenter l'interface Comparable ou avoir un comparateur associé). JAVA propose différentes méthodes de tri pour différents types : un tri rapide conçu pour les types de base et un "tri par fusion stable" conçu pour les objets, il n'y a donc pas lieu de s'inquiéter de l'efficacité du tri des tableaux.
BinarySearch() est utilisé pour trouver rapidement des éléments dans un tableau trié. Si BinarySearch() est utilisé sur un tableau non trié, des résultats imprévisibles se produiront.

[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 :

Copiez le code comme suit :

importer java.util.* ;
tableau de classe publiqueToList{
public static void main(String args[]){
String[] arrayA = {"a","b","c"};
Liste listA = java.util.Arrays.asList(arrayA);
System.out.println("listA: " + listA);

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]

Pourquoi les sorties int et Integer sont-elles différentes ?

Convertir une liste en tableau

Copiez le code comme suit :

importer java.util.* ;
liste de classe publiqueToArray{
public static void main(String args[]){
List<String> list = new ArrayList<String>();
Tableau String[] ;
list.add("testA");
list.add("testB");
list.add("testC");
System.out.println("liste : " + liste);

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

【Supprimer les données en double】
La conversion de tableaux et de conteneurs peut facilement supprimer les données en double d'un tableau, mais si le tableau est trop grand, l'efficacité pose un problème.

Copiez le code comme suit :

importer java.util.* ;
classe publique javaArrayUnique{
public static void main(String args[]){
Tableau String[] = {"a","b","a","a","c","b"};
arrayUnique(tableau);
//test
for(int i = 0, j = arrayUnique(array).length; i < j; i++){
System.out.print(arrayUnique(array)[i] + ",");
}
}

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 ;
}
}

Concernant le problème d'efficacité, j'ai fait une comparaison. L'exécution d'un tableau de 100 000 données sur mon ordinateur prend environ 577 ms, tandis que l'exécution d'un tableau d'un million de données prend environ 5 663 ms. Ceci est également lié aux capacités de fonctionnement de l'ordinateur, mais cela augmente évidemment avec la taille de la baie.

Copiez le code comme suit :

importer java.util.* ;
classe publique javaArrayUnique{
public static void main(String args[]){
Tableau Double[] = nouveau Double[100000] ;
pour (int i = 0, j = array.length; i < j; i++){
array[i] = Math.ceil(Math.random()*1000);
}

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