Zusammenfassung:
Dieser Artikel erläutert hauptsächlich das Wissen über Array in Java Arrays werden unter fünf Aspekten ausführlich besprochen: Arrays und Container, Array-Erstellung und -Initialisierung, Arrays und Generika, Arrays und VariablenparameterListen sowie die praktischen Funktionen der Arrays-Werkzeugklassen Beschreibung und Zusammenfassung.
Arrays und Container
Erstellung und Erstellung Initialisierung von Arrays
Arrays und Generika
Arrays und Variablenparameterlisten
Arrays-Tool-Klasse Zusammenfassung praktischer Funktionen
2. Arrays und Container
In Java sind sowohl Arrays als auch Container Sie kann Objekte enthalten. Was ist also der Unterschied zwischen Arrays und Containern? Wenn wir Objekte speichern müssen, unter welchen Umständen sollten wir Arrays und unter welchen Umständen Containern Vorrang einräumen?
In der ersten Version von Java waren Arrays mit fester Größe unbedingt erforderlich, nicht nur, weil Java-Designer sich dafür entschieden, primitive Typen in Java einzubeziehen und einige leistungsbasierte Überlegungen anzustellen, sondern auch wegen der ersten Version bietet nur sehr wenig Unterstützung für Container. Daher ist es in frühen Versionen von Java immer sinnvoll, sich für die Einbeziehung von Arrays zu entscheiden, insbesondere im Hinblick auf die folgenden drei Aspekte:
-
Effizienz
In Java, Arrays sind die effizienteste Möglichkeit, ObjektsequenzenReferenzen zu speichern und wahlfrei darauf zuzugreifen. Ein Array ist eine einfache lineare Sequenz, die den Zugriff auf Elemente sehr schnell ermöglicht. Der Preis für diese Geschwindigkeit besteht jedoch darin, dass die Größe des Array-Objekts fest ist und während seiner Lebensdauer nicht geändert werden kann. Da ArrayList die automatische Zuweisung von Speicherplatz realisieren kann und flexibler ist, sollten wir normalerweise ArrayList dem Array vorziehen, aber diese Flexibilität bringt einen Mehraufwand mit sich. Daher ist ArrayList viel weniger effizient als Arrays.
-
Typ
Vor JDK 1.5 führte Java keine Generika ein. Daher behandeln Containerklassen vor Generika Objekte bei der Handhabung so, als hätten sie keinen bestimmten Typ, d. h. diese Objekte werden als Objekt behandelt. Der Grund, warum Arrays besser sind als Container vor Generika, liegt darin, dass Sie ein Array erstellen können, das einen bestimmten Typ enthält. Dies bedeutet, dass Sie durch die Typprüfung zur Kompilierungszeit verhindern können, dass falsche Typen eingefügt und ungeeignete Typen extrahiert werden. Natürlich verhindert Java, dass Sie sowohl zur Kompilierungszeit als auch zur Laufzeit unangemessene Nachrichten an Objekte senden. Daher ist es nicht so, dass diese Methode weniger sicher ist, aber sie ist eleganter, wenn beim Kompilieren auf Fehler hingewiesen werden kann.
-
Die Möglichkeit, Basistypen zu speichern
Arrays können Basistypen enthalten, Container vor Generika jedoch nicht.
Nach JDK 1.5 führte Java Generika und automatische Verpackungsmechanismen ein (Generika können die Produktion typsicherer Container sicherstellen, und automatische Verpackungsmechanismen ermöglichen es Containern, Basistypen aufzunehmen). was dazu führt, dass die heutigen Container Arrays in jeder Hinsicht außer der Leistung in den Schatten stellen. Darüber hinaus stellen Generika eine große Bedrohung für Arrays dar, und normalerweise lassen sich beide nicht gut kombinieren (Arrays mit parametrisierten Typen können nicht instanziiert werden).
Wenn wir daher mit neueren Java-Versionen programmieren, sollte Container gegenüber Arrays bevorzugen. Wir sollten unser Programm so umgestalten, dass es nur dann Arrays verwendet, wenn nachgewiesen wurde, dass die Leistung ein Problem darstellt und der Wechsel zu Arrays die Leistung verbessert.
3. Erstellung und Initialisierung von Arrays
1 Array-Grundlagen
Die Array-ID ist nur ein Referenz: Dieses Objekt wird zum Speichern von Referenzen auf andere Objekte oder Werte von Basistypen verwendet.
Objektarrays speichern Referenzen und Basistypen Arrays direkt Basistypwerte speichern;
„[ ]“-Syntax ist die einzige Möglichkeit, auf Array-Objekte zuzugreifen
2. Erstellen und Initialisieren
String[] strs = { ... };
// 创建方式 1 --- 花括号内对象的个数就是数组大小System.out.println(strs.length);
// 输出 0Nach dem Login kopieren
String[] strs = new String[5];
//创建方式 2String[] ss = new String[]{ ... };
//创建方式 3Nach dem Login kopieren
3. Mehrdimensionales Array
Das Wesentliche eines mehrdimensionalen Arrays: Die Elemente des Arrays sind immer noch Arrays
// 创建方式 1int[][] a = {
{ 1, 2, 3, },
{ 4, 5, 6, },
};
// 创建方式 2int[][][] a = new int[2][2][4];//粗糙数组：每个向量具有任意长度Random rand = new Random(47);
// 3-D array with varied-length vectors: int[][][] a = new int[rand.nextInt(7)][][];
for(int i = 0; i < a.length; i++) {
a[i] = new int[rand.nextInt(5)][];
for(int j = 0; j < a[i].length; j++)
a[i][j] = new int[rand.nextInt(5)];
}Nach dem Login kopieren
4. Arrays und Generics
T[] first = new T[3];
// ERROR A<String>[] arrays = new A<String>[4];
// ERROR: Cannot create a generic array of A<String>
Nach dem Login kopieren
kann eine generische Array-Referenz erstellen; -
A<String>[] arrays;
// OK
Nach dem Login kopieren
Arrays sind kovariant
Kurz gesagt:
Object[] objs = new String[3];
// OK
Nach dem Login kopieren
5. Arrays und variable ParametertypenDas Konzept der variablen Parametertypen
Java SE5 fügt variable Parametertypen hinzu (Variable Argument Type), in der Form „Type... args“,
kann nur als Methodenparameter
verwendet werden.
Die Liste der variablen Parameter eignet sich für Situationen, in denen die Anzahl der Parameter ungewiss ist, der Typ jedoch sicher ist (Java behandelt variable Parameter als Array). Besonderes Augenmerk sollte darauf gelegt werden, dass die Liste der variablen Parameter das letzte Element sein muss (d. h. es wird höchstens ein variabler Parameter unterstützt). Wenn mehr als eine Variablenparameterliste vorhanden ist, darf eine der Variablen nicht das letzte Element sein, sodass nur ein Variablenparameter unterstützt wird. Da die Anzahl der Parameter in der Liste der variablen Parameter ungewiss ist, kann Java nicht unterscheiden, ob der übergebene Parameter zum vorherigen variablen Parameter oder zum folgenden Parameter gehört, wenn dahinter Parameter desselben Typs stehen, und kann daher nur den variablen Parameter platzieren am Ende ein Punkt. Die variable Parameterliste hat die folgenden Eigenschaften:
// 代码示例public class TestVarArgus {
public static void dealArray(int... intArray){
for (int i : intArray)
System.out.print(i +" ");
System.out.println();
}
public static void main(String args[]){
dealArray();
dealArray(1);
dealArray(1, 2, 3);
}
}/* Output:
1
1 2 3
*///:~Nach dem Login kopieren
kann nur am Ende der Methodenparameterliste erscheinen ;
Der Compiler betrachtet den Array-Typ und den variablen Parametertyp als gleich, d >
Tatsächlich benötigen Sie zum Beispiel Code 2 nur eine Methode, die als DealArray(int, int, int) definiert ist, oder eine Methode, die als DealArray(int...) definiert ist. Daher ist es natürlich unmöglich, die Methode dealArray(int[]) mit Array-Typparametern abzugleichen.
public class TestVarArgus {
public static void dealArray(int... intArray){
for (int i : intArray)
System.out.print(i +" ");
System.out.println();
}
//ERROR : Duplicate method dealArray(int[]) in type TestVarArgus
public static void dealArray(int[] intArray){
for (int i : intArray)
System.out.print(i +" ");
System.out.println();
}
public static void main(String args[]){
dealArray();
dealArray(1);
dealArray(1, 2, 3);
}
}Nach dem Login kopieren
kann auch in einen variablen Parametertyp umgeschrieben werden: public static void main(String... args) .
// 代码示例 1 ： 给参数为可变参数类型的方法传递数组public class TestVarArgus {
public static void dealArray(int... intArray){
for (int i : intArray)
System.out.print(i +" ");
System.out.println();
}
public static void main(String args[]){
int[] intArray = {1, 2, 3};
dealArray(intArray); // OK
}
}Nach dem Login kopieren
// 代码示例 2 ： 给参数为数组类型的方法传递可变参数public class TestVarArgus {
public static void dealArray(int[] intArray){
for (int i : intArray)
System.out.print(i +" ");
System.out.println();
}
public static void main(String args[]){
dealArray(1, 2, 3); // ERROR
}
}Nach dem Login kopieren
Praktische Funktionen der Arrays-ToolklasseArray kopieren| Function | Introduction | Note |
|---|
| System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length) | 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束 | 若复制对象数组，那么只是复制了对象的引用，而不是对象本身的拷贝(浅复制)；该方法不会执行自动包装和自动拆包，所以两个数组必须具有相同的确切类型；须明确自行新建立一个数组对象，作为副本 |
| copyOf(T[] original, int newLength) | 复制指定的数组，截取或用 null 填充 | 底层调用的还是 System.arraycopy；返回一个新的数组对象，若新数组的长度超过原数组的长度，则保留数组默认值 |
注意：
对于以上两个方法：
2、数组的字符串方式表示
方法： Arrays.toString(Object[] a) / Arrays.deepToString(Object[] a)
作用： 返回指定数组内容的字符串表示形式：前者适用于一维数组，或者适用于多维数组
3、数组的比较
方法： Arrays.equals(Object[] a, Object[] a2) / deepEquals(Object[] a1, Object[] a2) (多维)
作用： 比较两个数组：元素类型相同，元素个数相等，对应位置的元素相同;
注意：
通过对每个元素使用 equals() 作比较来判断;
对于基本类型，使用的是基本类型的包装器类的 equals() 方法（对于 int 类型使用 Integer.equals() 作比较）;
使用 equals() 方法比较原则：是不是同一个对象，是不是同一个类型，是不是具有相同的内容。
int[] a1 = new int[10];
int[] a2 = new int[10];
Arrays.fill(a1, 47);
Arrays.fill(a2, 47);
print(Arrays.equals(a1, a2)); //true
Nach dem Login kopieren
4、数组的排序
使用内置的排序方法，就可以对任意的基本类型数组排序；也可以对任意的对象数组进行排序，只要该对象实现了 Comparable 接口或具有相关联的 Comparator (独立的实现该接口的类)。
方法： Arrays.sort(Object[] a) / Arrays.sort(Object[] a, int fromIndex, int toIndex)
Arrays.sort(T[] a, Comparatorsuper T> c) / Arrays.sort(T[] a, int fromIndex, int toIndex, Comparator c)
作用： 对数组内元素进行升序排序 (默认)
String[] sa = Generated.array(new String[20], new RandomGenerator.String(5));
// 利用 String 内置的比较器（已实现 Comparable 接口）：字典序（大写字母开头的词都放在前面输出，之后才是小写字母开头的词）Arrays.sort(sa);
// ... ,WHkjU, YNzbr, bkIna, cQrGs, ....
// 利用 Comparator 比较 ： Collections.reverseOrder() ： 现有顺序的逆序Arrays.sort(sa, Collections.reverseOrder());
// 利用 Comparator 比较 ： String.CASE_INSENSITIVE_ORDER : 忽略大小写将单词一起进行排序Arrays.sort(sa, String.CASE_INSENSITIVE_ORDER);
Nach dem Login kopieren
Java 标准类库中的排序算法针对正排序的特殊类型进行了优化 ———— 针对基本类型设计的“快排” 和 针对对象设计的“稳定归并排序”。所以，无需担心排序的性能，除非你可以证明排序部分的确是程序效率的瓶颈。
5、在已排序的数组中查找
若数组已经 排好序，就可以使用该方法执行快速查找；若对未排序的数组使用该方法，将产生不可预料的结果。
方法： binarySearch(Object[] a, Object key) / binarySearch(T[] a, T key, Comparator c)
作用： 使用 二分搜索法 来搜索指定数组，以获得指定对象。在进行此调用之前，必须根据元素的自然顺序对数组进行升序排序（通过 sort(Object[]) 方法）; 使用二分搜索法来搜索指定数组，以获得指定对象。在进行此调用之前，必须根据指定的比较器（通过 sort(T[], Comparator) 方法）对数组进行多态升序排序。
注意：
对 已经有序 的数组进行查找；
Wenn das Ziel gefunden wird, ist der von der Methode zurückgegebene Wert nicht kleiner als 0. Andernfalls gibt der von ihr generierte negative Rückgabewert die Position an, die unter dieser Sortierung eingefügt werden soll 🎜>
-
„sort(Object[])“ entspricht „binarySearch(Object[] a, Object key)“, „sort(T[], Comparator)“ entspricht BinarySearch(T[] a, T key, Comparator c) Entspricht.
Wenn das Array doppelte Elemente enthält, kann diese Methode nicht garantieren, welches Element gefunden wird. Wenn Sie ein Array ohne doppelte Elemente sortieren müssen, können Sie TreeSet verwenden (Sortierreihenfolge beibehalten) oder LinkedHashSet (Einfügungsreihenfolge beibehalten) für die Sortierung. Es besteht keine Notwendigkeit, Arrays selbst zu verwalten, es sei denn, sie stellen einen Engpass in Ihrem Programm dar.
6. Array füllen
Methode: fill(Object[] a, Object val)
Funktion: kann jede Position nur mit demselben Wert füllen, und bei Objekten wird die Referenz desselben Objekts kopiert, um
7. Konvertierung zwischen Arrays und Containern
Methode: asList(T… a) Funktion:
Gibt ein zurück Liste mit fester Größe, die vom angegebenen Array unterstützt wird Hinweis:
Die resultierende Liste hat eine feste Größe, weil -
Die zugrunde liegende Darstellung ist das Array und kann daher nicht in der Größe geändert werden. Daher löst der Aufruf der Methode „add/remove“ eine java.lang.UnsupportedOperationException (optionale Operation) aus.
Bei Arrays.asList() geht es also wirklich darum: das Ergebnis als Konstruktorargument an eine beliebige Sammlung zu übergeben (oder addAll Methode, Collections.addAll statische Methode), die einen dynamischen Container generieren kann.
Grundsätze:
- Verwenden Sie lieber Container anstelle von Arrays.
- Verwenden Sie bei der Erstellung Arrays und variable Parameter Methodenparameter: Durch die Priorisierung der Verwendung variabler Parameter wird das Programm stärker entkoppelt. Erhalten Sie das Doppelte des Ergebnisses bei halbem Programmieraufwand.
Das obige ist der detaillierte Inhalt vonZusammenfassung der Beispiele für Java-Array-Code. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
