Java-Verbesserung Kapitel (18)-----Array Eins: JAVA-Arrays verstehen

Oh, es versteht, der Fluss ist weder so flach, wie Onkel Kuh sagte, noch so tief, wie das kleine Eichhörnchen sagte. Das können Sie nur herausfinden, wenn Sie es selbst versuchen! Hörensagen kann das Phänomen immer nur aufzeigen. Nur wenn man es selbst ausprobiert, kann man die Tiefe des Phänomens erkennen! ! ! ! !

1. Was ist ein Array

Array? Was ist ein Array? Meiner Meinung nach sollten Arrays so aussehen: Sie werden mit dem neuen Schlüsselwort erstellt und zusammengesetzt, auf ihre Elemente kann über ganzzahlige Indexwerte zugegriffen werden, und ihre Größe ist unveränderlich!

Aber das ist nur die Oberfläche des Arrays! Tiefer? Das ist es: Ein Array ist ein einfacher zusammengesetzter Datentyp. Es handelt sich um eine Sammlung geordneter Daten. Wir verwenden eindeutig den Array-Namen und einen Indexwert, der nicht außerhalb der Grenzen liegt Elemente im Array.

 Es gibt etwas Tieferes, das heißt, das Array ist ein besonderes Objekt! ! (Ich verstehe diese LZ nicht sehr gut und habe JVM nicht gelesen, daher sind meine Erkenntnisse begrenzt.) Die folgenden Referenzen: http://www.php.cn/, http://www.php.cn/

                                              va es ist ein Objekt. Ein ganz besonderes Objekt.

public class Test {
    public static void main(String[] args) {
        int[] array = new int[10];
        System.out.println("array的父类是：" + array.getClass().getSuperclass());
        System.out.println("array的类名是：" + array.getClass().getName());
    }
}
-------Output:
array的父类是：class java.lang.Object
array的类名是：[I

Wie aus dem obigen Beispiel ersichtlich ist, ist Array eine direkte Unterklasse von Object. Es gehört zum „ersten Objekttyp“, unterscheidet sich jedoch stark von gewöhnlichen Java-Objekten. Dies ist an seinem Klassennamen zu erkennen: [Ich, was ist das? ? Ich habe diese Klasse im JDK nicht gefunden. Es heißt, dass dieses „[I““ kein gültiger Bezeichner ist. Wie definiere ich es als Kategorie? Ich denke also, dass die Genies bei SUM eine spezielle Verarbeitung auf der untersten Ebene des Arrays vorgenommen haben müssen.

Schauen wir uns das folgende Beispiel an:

public class Test {
    public static void main(String[] args) {
        int[] array_00 = new int[10];
        System.out.println("一维数组：" + array_00.getClass().getName());
        int[][] array_01 = new int[10][10];
        System.out.println("二维数组：" + array_01.getClass().getName());
        
        int[][][] array_02 = new int[10][10][10];
        System.out.println("三维数组：" + array_02.getClass().getName());
    }
}
-----------------Output:
一维数组：[I
二维数组：[[I
三维数组：[[[I

 Durch dieses Beispiel wissen wir: [ stellt die Dimension des Arrays dar, eins [ stellt eine Dimension dar und zwei [ stellt zwei Dimensionen dar. Man kann einfach sagen, dass der Klassenname eines Arrays aus mehreren '['s und dem internen Namen des Array-Elementtyps besteht. Wenn es nicht klar ist, schauen wir es uns noch einmal an:

public class Test {
    public static void main(String[] args) {
        System.out.println("Object[]:" + Object[].class);
        System.out.println("Object[][]:" + Object[][].class);
        System.err.println("Object[][][]:" + Object[][][].class);
        System.out.println("Object:" + Object.class);
    }
}
---------Output:
Object[]:class [Ljava.lang.Object;
Object[][]:class [[Ljava.lang.Object;
Object[][][]:class [[[Ljava.lang.Object;
Object:class java.lang.Object

                              True Colors". Gleichzeitig ist auch ersichtlich, dass sich Arrays von gewöhnlichen Java-Klassen unterscheiden, die vollständig qualifizierte Pfadnamen + Klassennamen als einzige Bezeichner verwenden, während Arrays mehrere vollständige Namen für Array-Elemente verwenden der Pfad + die Klasse, um es eindeutig zu identifizieren. Dieser Unterschied erklärt möglicherweise bis zu einem gewissen Grad, dass es einen großen Unterschied in der Implementierung von Arrays und gewöhnlichen Java-Klassen gibt. Möglicherweise kann dieser Unterschied genutzt werden, um die JVM bei der Verarbeitung von Arrays und gewöhnlichen Java-Klassen zu unterscheiden.

Lassen wir mal beiseite, was das ist [ich bin, wer es erklärt hat und wie es erklärt wurde (ich weiß das jetzt nicht! Aber es gibt eine Sache Kann bestätigen: Dies wird zur Laufzeit ermittelt. Schauen wir uns Folgendes an:

public class Test {
    public static void main(String[] args) {
        int[] array = new int[10];
        Class clazz = array.getClass();   
        System.out.println(clazz.getDeclaredFields().length);   
        System.out.println(clazz.getDeclaredMethods().length);   
        System.out.println(clazz.getDeclaredConstructors().length);   
        System.out.println(clazz.getDeclaredAnnotations().length);   
        System.out.println(clazz.getDeclaredClasses().length);   
    }
}
----------------Output：
0
0
0
0
0

Es gibt keine Mitgliedsvariable, Mitgliedsmethode, Konstruktor und Anmerkung oder sogar die Längenelementvariable. Es ist eine völlig leere Klasse. Die Länge ist nicht deklariert. Warum meldet der Compiler also keinen Fehler, wenn wir array.length verwenden? Tatsächlich ist die Länge eines Arrays eine ganz besondere Mitgliedsvariable. Wir wissen, dass das Array die direkte Klasse von Object ist, aber Object hat nicht die Mitgliedsvariable length, also sollte length die Mitgliedsvariable des Arrays sein, aber aus dem obigen Beispiel stellen wir fest, dass das Array keine Mitgliedsvariablen hat Sind sie überhaupt nicht widersprüchlich?

public class Main {
    public static void main(String[] args) {
        int a[] = new int[2];
        int i = a.length;
    }
}

 

Öffnen Sie die Klassendatei und rufen Sie den Bytecode der Hauptmethode ab:

0 iconst_2                   //将int型常量2压入操作数栈  
    1 newarray 10 (int)          //将2弹出操作数栈，作为长度，创建一个元素类型为int, 维度为1的数组，并将数组的引用压入操作数栈  
    3 astore_1                   //将数组的引用从操作数栈中弹出，保存在索引为1的局部变量(即a)中  
    4 aload_1                    //将索引为1的局部变量(即a)压入操作数栈  
    5 arraylength                //从操作数栈弹出数组引用(即a)，并获取其长度(JVM负责实现如何获取)，并将长度压入操作数栈  
    6 istore_2                   //将数组长度从操作数栈弹出，保存在索引为2的局部变量(即i)中  
    7 return                     //main方法返回

       在这个字节码中我们还是没有看到length这个成员变量，但是看到了这个:arraylength ,这条指令是用来获取数组的长度的，所以说JVM对数组的长度做了特殊的处理，它是通过arraylength这条指令来实现的。

       二、数组的使用方法

       通过上面算是对数组是什么有了一个初步的认识，下面将简单介绍数组的使用方法。

       数组的使用方法无非就是四个步骤：声明数组、分配空间、赋值、处理。

       声明数组：就是告诉计算机数组的类型是什么。有两种形式：int[] array、int array[]。

       分配空间：告诉计算机需要给该数组分配多少连续的空间，记住是连续的。array = new int[10];

       赋值：赋值就是在已经分配的空间里面放入数据。array[0] = 1 、array[1] = 2……其实分配空间和赋值是一起进行的，也就是完成数组的初始化。有如下三种形式：

int a[] = new int[2];    //默认为0,如果是引用数据类型就为null
        int b[] = new int[] {1,2,3,4,5};    
        int c[] = {1,2,3,4,5};

       处理：就是对数组元素进行操作。通过数组名+有效的下标来确认数据。

以上就是java提高篇(十八)-----数组之一：认识JAVA数组 的内容，更多相关内容请关注PHP中文网（www.php.cn）！