Einführung in die Verwendung von JAVA-Arrays

Autor：Eve Cole Aktualisierungszeit：2024-11-19 16:12:02

Es gibt drei Hauptunterschiede zwischen JAVA-Arrays und Containerklassen: Effizienz, Typ und die Möglichkeit, Basistypen zu speichern . In JAVA sind Arrays die effizienteste Möglichkeit, eine Folge von Objektreferenzen zu speichern und wahlfrei darauf zuzugreifen. Ein Array ist eine einfache lineare Sequenz, die den Elementzugriff sehr schnell macht. Der dafür gezahlte Preis besteht jedoch darin, dass die Größe des Arrays fest ist und während seiner Lebensdauer nicht geändert werden kann.

Dank Generika und automatischen Verpackungsmechanismen können Container jetzt fast genauso einfach mit primitiven Typen verwendet werden wie Arrays. Sowohl Arrays als auch Container können Sie bis zu einem gewissen Grad daran hindern, sie zu missbrauchen. Wenn sie außerhalb der Grenzen liegen, erhalten Sie eine RuntimeException. Der einzige verbleibende Vorteil von Arrays ist die Effizienz. Wenn Sie jedoch allgemeinere Probleme lösen möchten, sind Arrays möglicherweise zu restriktiv, sodass sich die meisten Menschen in diesem Fall immer noch für Container entscheiden.

Wenn Sie aktuelle JAVA-Versionen verwenden, sollten Sie daher Container gegenüber Arrays bevorzugen. Programme sollten nur dann in Arrays umgestaltet werden, wenn sich herausgestellt hat, dass die Leistung ein Problem darstellt und der Wechsel zu Arrays die Leistung verbessert.

【Initialisierung】
JAVA hat sehr strenge Vorschriften für die Array-Initialisierung, wodurch der Missbrauch von Arrays wirksam verhindert werden kann. Wenn ein Initialisierungsfehler vorliegt, erhalten Sie direkt CompileException anstelle von RuntimeException. Mit dieser Array-Referenz kann nichts gemacht werden, bis das Array ordnungsgemäß initialisiert ist.
Zu den Array-Definitionen gehören int[] array und int array[]. Im Allgemeinen wird der erste Stil verwendet, um den Typ vom Variablennamen zu trennen.
Es gibt zwei Möglichkeiten, ein Array zu initialisieren: statische Initialisierung und dynamische Initialisierung. Die Länge muss bei der Initialisierung angegeben werden. Die Länge der ersten Dimension des mehrdimensionalen Arrays muss angegeben werden und von der hohen zur niedrigen Dimension definiert werden. Die Initialisierungsaktion kann an einer beliebigen Stelle im Code stehen, die Methode {} kann jedoch nur dort erscheinen, wo das Array erstellt wird. Spezifische Initialisierungsmethoden finden Sie im Programm:

Kopieren Sie den Codecode wie folgt:

öffentliche Klasse javaArrayInit{
public static void main(String args[]){
int[] arrayA; //nicht initialisiert
int[] arrayB = new int[5]; //statische Initialisierung
//System.out.println(arrayA.length); //CompileException
System.out.println("arrayB length: " + arrayB.length); //Die tatsächliche Anzahl der gespeicherten Elemente kann nicht ermittelt werden

arrayA = new int[10]; //Dynamische Initialisierung
System.out.println("arrayA length: " + arrayA.length);

int[] arrayC = new int[]{1,2,3,4};
System.out.println("arrayC-Länge: " + arrayC.length);

//int[] arrayD = new int[1]{1}; //Falsche Initialisierung, Dimensionen und Initialisierungswerte können nicht gleichzeitig definiert werden

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

//int[][] arrayF = new int[][2]; //Die Länge der hohen Dimension sollte zuerst angegeben werden

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

int[][][] arrayH = new 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()}; //Benutzerdefinierter Array-Typ
System.out.println("arrayI length: " + arrayI.length);
System.out.println("arrayI[1]: " + arrayI[1].getValue());

dummyArray[] arrayK = new dummyArray[5];
System.out.println("arrayK[0]: " + arrayK[0]); //null
for(int i = 0; i < arrayK.length; i++){
arrayK[i] = new dummyArray();
}
System.out.println("arrayK[0]: " + arrayK[0].getValue());
}
}
Klasse dummyArray{
private static int temp;
private final int arrayValue = temp++;
public int getValue(){
return arrayValue;
}
}

Ausgabe:

ArrayB-Länge: 5
ArrayA-Länge: 10
ArrayC-Länge: 4
ArrayE-Länge: 1
ArrayG-Länge: 3
ArrayH-Länge: 1
ArrayI-Länge: 2
arrayI[1]: 1
arrayK[0]: null
arrayK[0]: 2

【Länge】
Die schreibgeschützte Mitgliedslänge ist Teil des Array-Objekts (obwohl diese Variable nicht tatsächlich in der API deklariert ist und zur Laufzeit dynamisch generiert wird). Dies ist das einzige Feld oder die einzige Methode, auf die zugegriffen werden kann. Die []-Syntax ist die einzige Möglichkeit, auf Array-Objekte zuzugreifen, und auf Container wird über die Methode get() zugegriffen. Sie können Array.length verwenden, um die Größe des Arrays zu ermitteln. Beachten Sie, dass es sich von String.length() vom Typ String unterscheidet. Array verwendet Mitgliedsvariablen, während String Mitgliedsmethoden verwendet. Gleichzeitig kann Array.length nur die Größe des Arrays ermitteln, nicht jedoch, wie viele Elemente das Array tatsächlich enthält. Die Länge eines mehrdimensionalen Arrays berechnet nur die Länge der ersten Dimension.

Kopieren Sie den Codecode wie folgt:

öffentliche Klasse javaArrayLength{
public static void main(String args[]){
int[] arrayA = new int[15];
arrayA[1] = 1;
arrayA[2] = 2;
arrayA[3] = 3;
System.out.println("arrayA length: " + arrayA.length);

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

int[][] arrayC = new int[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7} ,};//Achten Sie auf das Komma danach
System.out.println("arrayC-Länge: " + arrayC.length);

int[][] arrayD = new int[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7} ,{}};
System.out.println("arrayD-Länge: " + arrayD.length);
}
}
Ausgabe:

ArrayA-Länge: 15
ArrayB-Länge: 10
ArrayC-Länge: 3
ArrayD-Länge: 4

【Arrays.fill】
Arrays.fill ist eine sehr eingeschränkte Methode, da sie jede Position nur mit demselben Wert füllen kann (oder im Fall eines Objekts dieselbe Referenz zum Füllen kopieren kann). Die Verwendung von Arrays.fill kann das gesamte Array oder einen bestimmten Bereich des Arrays füllen. Da Arrays.fill jedoch nur mit einem einzelnen Wert aufgerufen werden kann, ist dies nicht sehr nützlich.

[Aufgabe und Referenz]
Wenn ein JAVA-Array initialisiert wird, hat es nur einen Verweis auf das Array und dem Array wird kein Speicherplatz zugewiesen. Daher kann beim Kopieren zwischen Arrays nicht einfach die Zuweisung „=“ verwendet werden, da dasselbe Objekt bedient wird. Das folgende Verfahren:

Kopieren Sie den Codecode wie folgt:

öffentliche Klasse javaArrayQuote{
public static void main(String args[]){
String testA = "testA";
String testB = "testB";
String[] arrayA = new String[]{"arrayA"};
String[] arrayB = new String[]{"arrayB"};
testB = testA;
testB = „testB-Änderung“;
System.out.println("Ich bin testA, ich habe keine Änderungen: " + testA);
arrayB = arrayA;
arrayB[0] = „arrayB hat sich geändert“;
System.out.println("Ich bin arrayA, ich habe nichts geändert: " + arrayA[0]);

}
}
Ausgabe:

Ich bin testA, ich habe nichts geändert:testA
Ich bin ArrayA, ich habe keine Änderungen: ArrayB habe sich geändert

Es ist ersichtlich, dass wir, wenn wir den Wert von ArrayB [0] ändern, das referenzierte Array ändern, sodass wir ArrayA [0] ausgeben, was tatsächlich mit ArrayB [0] identisch ist.

[Array-Kopie]
So kopieren Sie ein Array in JAVA:

1. Verwenden Sie die FOR-Schleife, um alle oder bestimmte Elemente zu kopieren, was weniger effizient ist.
2. Verwenden Sie die Klonmethode, um den Wert des Arrays anstelle einer Referenz abzurufen. Allerdings kann der Klon bestimmte Elemente nicht kopieren und weist eine geringe Flexibilität auf.
3. Verwenden Sie die Methode System.arraycopy(src, srcPos, dest, destPos, length). Die Verwendung dieser Methode zum Kopieren eines Arrays ist viel schneller als eine for-Schleife .arraycopy() gilt für alle Typen, die überladen sind. Sowohl Basistyp-Arrays als auch Objekt-Arrays können mit System.arraycopy() kopiert werden, Objekt-Arrays kopieren jedoch nur Referenzen und es gibt keine zwei Kopien von Objekten. Dies wird als flache Kopie bezeichnet.
src: Quellarray;
srcPos: die Startposition des zu kopierenden Quellarrays;
dest: Zielarray;
destPos: die Startposition, an der das Zielarray platziert wird;
Länge: Die Länge der Kopie.
Hinweis: System.arraycopy() führt kein automatisches Packen und Entpacken durch, daher müssen die beiden Arrays vom gleichen Typ sein oder können in Arrays vom gleichen Typ konvertiert werden. Gleichzeitig kann diese Methode auch zum Kopieren des Arrays selbst verwendet werden.
int[] test ={0,1,2,3,4,5,6};
System.arraycopy(test,0,test,3,3);
Das Ergebnis ist: {0,1,2,0,1,2,6};
Der Testablauf ist wie folgt:

Kopieren Sie den Codecode wie folgt:

öffentliche Klasse javaArrayCopy{
public static void main(String args[]){
int[] array = {1,2,3,4,5,6,7,8,9};
//for-Schleifenmethode
int[] arrayA = new int[9];
for(int i = 0; i < arrayA.length; i++){
arrayA[i] = array[i];
System.out.print(arrayA[i] + ",");
}
//prüfen
System.out.println("");
arrayA[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("");

//Klonmethode
int[] arrayB = new int[9];
arrayB = array.clone();
//prüfen
arrayB[1] = 19;
for(int i = 0; i < arrayB.length; i++){
System.out.print(arrayB[i] + ",");
}
System.out.println("");
for(int i = 0; i < array.length; i++){
System.out.print(array[i] + ",");
}
System.out.println("");

//System.arrayCopy-Methode
int[] arrayC = new int[9];
System.arraycopy(array, 0, arrayC, 0, arrayC.length);
//prüfen
arrayC[1] = 19;
for(int i = 0; i < arrayC.length; i++){
System.out.print(arrayC[i] + ",");
}
System.out.println("");
for(int i = 0; i < array.length; i++){
System.out.print(array[i] + ",");
}
}
}

[Array-Vergleich]
Arrays bietet eine überladene Methode equal(), die für alle Typen und Objekttypen überladen ist, um das gesamte Array zu vergleichen. Voraussetzung für die Array-Gleichheit ist, dass die Anzahl der Elemente gleich sein muss und auch die Elemente an den entsprechenden Positionen müssen gleich sein. Die Methode deepEquals() wird zum Vergleich mehrdimensionaler Arrays verwendet. Die beiden von der Methode Array.equals() verglichenen Arrays müssen Arrays desselben Typs sein.

Kopieren Sie den Codecode wie folgt:

java.util.Arrays importieren;
öffentliche Klasse javaArrayEquals{
public static void main(String args[]){
int[] arrayA = {1,2,3};
int[] arrayB = {1,2,3,};
int[] arrayC = new int[4]; //if int[] arrayC = new int[3], return true
arrayC[0] = 1;
arrayC[1] = 2;
arrayC[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));
}
}

[Array-Sortierung und Suche]
Arrays bieten eine integrierte Sortiermethode sort(), mit der jedes Basistyp-Array oder Objektarray sortiert werden kann (das Objekt muss die Comparable-Schnittstelle implementieren oder über einen zugehörigen Comparator verfügen). JAVA bietet verschiedene Sortiermethoden für verschiedene Typen – schnelle Sortierung für Basistypen und „stabile Zusammenführungssortierung“ für Objekte, sodass Sie sich keine Sorgen um die Effizienz der Array-Sortierung machen müssen.
„binarySearch()“ wird verwendet, um Elemente in einem sortierten Array schnell zu finden. Wenn „binarySearch()“ für ein unsortiertes Array verwendet wird, treten unvorhersehbare Ergebnisse auf.

[Array zurückgeben]
C und C++ können kein Array zurückgeben, sondern nur einen Zeiger auf das Array, da die Rückgabe eines Arrays die Kontrolle des Lebenszyklus des Arrays erschwert und leicht zu Speicherverlusten führen kann. Java ermöglicht die direkte Rückgabe eines Arrays und kann vom Garbage-Collection-Mechanismus recycelt werden.

[Array- und Containerkonvertierung] [Basistyp-Array kann nicht konvertiert werden]

Array in Liste konvertieren:

Kopieren Sie den Codecode wie folgt:

import java.util.*;
öffentliche Klasse arrayToList{
public static void main(String args[]){
String[] arrayA = {"a",b","c"};
Liste listA = java.util.Arrays.asList(arrayA);
System.out.println("listA: " + listA);

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

Integer[] arrayC = {1,2,3};
Liste listC = java.util.Arrays.asList(arrayC);
System.out.println("listC: " + listC);
}
}
Ausgabe:

listA: [a, b, c]
listB: [[I@de6ced]
listC: [1, 2, 3]

Warum unterscheiden sich die Ausgabe von int und Integer?

Liste in Array konvertieren

Kopieren Sie den Codecode wie folgt:

import java.util.*;
öffentliche Klasse listToArray{
public static void main(String args[]){
List<String> list = new ArrayList<String>();
String[]-Array;
list.add("testA");
list.add("testB");
list.add("testC");
System.out.println("list: " + list);

String[] strings = new String[list.size()];
array = list.toArray(strings);
for(int i = 0, j = array.length; i < j; i++){
System.out.print(array[i] + ",");
}
}
}
Die Ausgabe ist:

Liste: [testA, testB, testC]
testA, testB, testC

【Doppelte Daten entfernen】
Durch die Array- und Containerkonvertierung können doppelte Daten leicht aus einem Array entfernt werden. Wenn das Array jedoch zu groß ist, stellt die Effizienz ein Problem dar.

Kopieren Sie den Codecode wie folgt:

import java.util.*;
öffentliche Klasse javaArrayUnique{
public static void main(String args[]){
String[] array = {"a", "b", "a", "a", "c", "b"};
arrayUnique(array);
//prüfen
for(int i = 0, j = arrayUnique(array).length; i < j; i++){
System.out.print(arrayUnique(array)[i] + ",");
}
}

public static String[] arrayUnique(String[] array){
List<String> list = new ArrayList<String>();
for(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;
}
}

Bezüglich der Effizienzfrage habe ich einen Vergleich angestellt. Das Ausführen eines Arrays mit 100.000 Daten auf meinem Computer dauert etwa 577 ms, während das Ausführen eines Arrays mit einer Million Daten etwa 5663 ms dauert. Dies hängt auch mit der Laufleistung des Computers zusammen, nimmt aber offensichtlich mit der Größe des Arrays zu.

Kopieren Sie den Codecode wie folgt:

import java.util.*;
öffentliche Klasse javaArrayUnique{
public static void main(String args[]){
Double[] array = new Double[100000];
for(int i = 0, j = array.length; i < j; i++){
array[i] = Math.ceil(Math.random()*1000);
}

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

System.out.println("start");
long startTime = System.currentTimeMillis();
arrayUnique(array);
long endTime = System.currentTimeMillis();
System.out.println("array unique run time: " +(endTime - startTime) +"ms");

long startTimeB = System.currentTimeMillis();
arrayUnique(arrayB);
long endTimeB = System.currentTimeMillis();
System.out.println("arrayB eindeutige Laufzeit: " +(endTimeB - startTimeB) +"ms");
}

öffentliches statisches Double[] arrayUnique(Double[] array){
List<Double> list = new ArrayList<Double>();
for(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;
}
}
Ausgabe:

Start
Array-Einzellaufzeit: 577 ms
ArrayB-Einzellaufzeit: 5663 ms