Einführung in die Verwendung von JAVA-Arrays

Der Herausgeber dieses Artikels wird Sie über die Verwendung von JAVA-Arrays informieren.

Es gibt drei Hauptunterschiede zwischen JAVA-Arrays und Containerklassen: Effizienz, Typ und die Möglichkeit, Grundtypen 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 des Aufkommens von Generika und automatischen Verpackungsmechanismen können Container jetzt mit Basistypen fast genauso einfach 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.

Daher sollten bei Verwendung aktueller JAVA-Versionen Container gegenüber Arrays bevorzugt werden. 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, die den Missbrauch von Arrays wirksam verhindern können. 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.
Array-Definitionen umfassen int[] array und int array[]. Im Allgemeinen wird der erste Stil verwendet, um den Typ vom Variablennamen zu trennen.
Es gibt zwei Möglichkeiten, Arrays 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 sie muss 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. Die spezifische Initialisierungsmethode finden Sie im Programm:

Der Code lautet wie folgt:

public class javaArrayInit{
    public static void main(String args[]){
        int[] arrayA; //未初始化
        int[] arrayB = new int[5]; //静态初始化
        //System.out.println(arrayA.length);  //CompileException
        System.out.println("arrayB length: " + arrayB.length); //无法得到实际保存的元素个数
        arrayA = new int[10]; //动态初始化
        System.out.println("arrayA length: " + arrayA.length);
        int[] arrayC = new int[]{1,2,3,4};
        System.out.println("arrayC length: " + arrayC.length);
        //int[] arrayD = new int[1]{1}; //错误的初始化，不能同时定义维和初始化值
        int[][] arrayE = new int[1][];
        System.out.println("arrayE length: " + arrayE.length);
        //int[][] arrayF = new int[][2]; //应先指定高维的长度
        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()}; //自定义数组类型
        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()); //2
    }
}
class dummyArray{
    private static int temp;
    private final int arrayValue = temp++;
    public int getValue(){
        return arrayValue;
    }
}

Ausgabe:

arrayB length: 5
arrayA length: 10
arrayC length: 4
arrayE length: 1
arrayG length: 3
arrayH length: 1
arrayI length: 2
arrayI[1]: 1
arrayK[0]: null
arrayK[0]: 2

[Länge]
Die schreibgeschützte Mitgliedslänge ist ein Array-Teil des Objekts (obwohl diese Variable nicht tatsächlich in der API deklariert ist, wird sie zur Laufzeit dynamisch generiert). 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.

Der Code lautet wie folgt:

public class 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},};//注意后面的逗号
        System.out.println("arrayC length: " + 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 length: " + arrayD.length);
    }
}

Ausgabe:

arrayA length: 15
arrayB length: 10
arrayC length: 3
arrayD length: 4

[Arrays.fill]
Arrays.fill ist Eine sehr nützliche eingeschränkte Methode, da sie nur verschiedene Stellen mit demselben Wert füllen kann (oder im Fall eines Objekts dieselbe Referenz zum Ausfü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.

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

Der Code lautet wie folgt:

public class 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 change";
        System.out.println("I'm testA,I have no changed: " + testA);
        arrayB = arrayA;
        arrayB[0] = "arrayB have changed";
        System.out.println("I'm arrayA, I have no changed: " + arrayA[0]);
    }
}

Ausgabe:

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

可以看出，我们改变arrayB[0]的值，改变的是引用的数组，因此我们输出arrayA[0]，其实和arrayB[0]一样。

【数组复制】
        JAVA中复制数组的方法：

        1.使用FOR循环复制全部或指定元素,效率较低
        2.使用clone方法,得到数组的值,而不是引用。然而clone不能复制指定元素,灵活性较低
        3.使用System.arraycopy(src, srcPos, dest, destPos, length)方法,java标准类库提供有static方法 System.arraycopy()，用它复制数组要比for循环快很多，System.arraycopy()针对所有类型做了重载，基本类型数组和对象数组都可以用System.arraycopy()复制，但是对象数组只是复制引用，不会出现两份对象的拷贝。这被称作浅复制(shallowcopy)。
               src:源数组;
                srcPos:源数组要复制的起始位置;
                dest:目的数组;
                destPos:目的数组放置的起始位置;
                length:复制的长度.
        注意：System.arraycopy()不会进行自动包装和自动拆包，因此两个数组必须是同类型或者可以转换为同类型的数组。同时，这个方法也可以用于复制数组本身。
        int[] test ={0,1,2,3,4,5,6};
        System.arraycopy(test,0,test,3,3);
        则结果为：{0,1,2,0,1,2,6};
        测试程序如下：

代码如下:

public class javaArrayCopy{
    public static void main(String args[]){
        int[] array = {1,2,3,4,5,6,7,8,9};
        //for循环方法
        int[] arrayA = new int[9];
        for(int i = 0; i < arrayA.length; i++){
            arrayA[i] = array[i];
            System.out.print(arrayA[i] + ",");
        }
        //测试
        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("");
        //clone方法
        int[] arrayB = new int[9];
        arrayB = array.clone();
        //测试
        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 方法
        int[] arrayC = new int[9];
        System.arraycopy(array, 0, arrayC, 0, arrayC.length);
        //测试
        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] + ",");
        }
    }
}

【数组比较】
Arrays提供了重载后的equals()方法，针对所有类型和Object类型都做了重载，用来比较整个数组。数组相等的条件是元素个数必须相等，并且对应位置的元素也相等。而多维数组的比较用deepEquals()方法。Array.equals()方法比较的两个数组必须是同类型的数组。

代码如下:

import java.util.Arrays;
public class 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));
    }
}

【数组排序与查找】
数组提供了内置的排序方法sort(),可以对任意基本类型数组或者对象数组进行排序（该对象必须实现Comparable接口或者具有相关联的Comparator）。JAVA对不同的类型提供了不同的排序方法----针对基本类型设计的快速排序，以及针对对象设计的“稳定归并排序”，所以无需担心数组排序的效率问题。
 binarySearch()用于在以排好序的数组中快速查找元素，如果对未排序的数组使用binarySearch()，那么将产生难以预料的结果。

【返回数组】
C和C++不能返回一个数组，只能返回指向数组的指针，因为返回数组使得控制数组的生命周期变得困难，并且容易造成内存泄漏。java允许直接返回一个数组，并且可以由垃圾回收机制回收。

【数组与容器转换】【无法转换基本类型数组】

数组转为List：

代码如下:

import java.util.*;
public class arrayToList{
    public static void main(String args[]){
        String[] arrayA = {"a","b","c"}; 
        List listA = java.util.Arrays.asList(arrayA);
        System.out.println("listA: " + listA);
        int[] arrayB = {1,2,3}; 
        List listB = java.util.Arrays.asList(arrayB);
        System.out.println("listB: " + listB);
        Integer[] arrayC = {1,2,3};
        List listC = java.util.Arrays.asList(arrayC);
        System.out.println("listC: " + listC);
    }
}

输出：

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

为什么int和Integer输出会不同呢？

List转为数组

代码如下:

import java.util.*;
public class 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] + ",");
        }
    }
}

输出为：

list: [testA, testB, testC]
testA,testB,testC

【去除重复数据】
利用数组和容器转换可以方便地去除数组重复数据，不过如果数组过大，效率是一个问题。

代码如下:

import java.util.*;
public class javaArrayUnique{
    public static void main(String args[]){
        String[] array = {"a","b","a","a","c","b"};
        arrayUnique(array);
        //test
        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;
    }
}

 关于效率问题，我做了一个对比，在我电脑上运行十万数据的数组大概是577ms，而运行一百万数据的数据大约要5663ms。这还跟计算机的运行能力有关，但是明显是随着数组大小递增的。

代码如下:

import java.util.*;
public class 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 unique run time: " +(endTimeB - startTimeB) +"ms");
    }
    public static 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;
    }
}

输出：

startarray unique run time: 577msarrayB unique run time: 5663ms

Das obige ist der detaillierte Inhalt vonEinführung in die Verwendung von JAVA-Arrays. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!