Chapitre sur l'amélioration de Java (18) -----Array One : Comprendre les tableaux JAVA

Oh, ça comprend, la rivière n'est ni aussi peu profonde que le disait Oncle Vache, ni aussi profonde que le disait le petit écureuil. Vous ne pouvez le savoir que si vous l'essayez vous-même ! Les ouï-dire ne peuvent toujours que montrer le phénomène. Ce n'est qu'en l'essayant vous-même que vous pourrez en connaître la profondeur ! ! ! ! !

1. Qu'est-ce qu'un tableau

Tableau ? Qu'est-ce qu'un tableau ? Dans mon esprit, les tableaux devraient ressembler à ceci : créez-les et assemblez-les via le nouveau mot-clé, accédez à ses éléments en utilisant des valeurs d'index entières, et sa taille est immuable !

Mais ce n'est que la surface du tableau ! Plus profond? C'est tout : un tableau est un type de données composite simple. C'est une collection de données ordonnées. Chaque donnée qu'il contient a le même type de données. Nous utilisons de manière unique le nom du tableau plus une valeur d'indice qui ne sortira pas des limites. éléments du tableau.

 Il y a quelque chose de plus profond, c'est-à-dire que le tableau est un objet spécial ! ! (Je ne comprends pas très bien ce LZ et je n'ai pas lu JVM, donc mes idées sont limitées). Les références suivantes : http://www.php.cn/, http://www.php.cn/

                                                             Quoi, en Java, c'est un objet . Un objet assez particulier.

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

Comme le montre l'exemple ci-dessus, array est une sous-classe directe d'Object. Il appartient au « premier type d'objet », mais il est très différent des objets Java ordinaires. Cela se voit à son nom de classe : [I, qu'est-ce que c'est ? ? Je n'ai pas trouvé cette classe dans le JDK. On dit que ce "[I" n'est pas un identifiant légal. Comment la définir comme catégorie ? Je pense donc que les génies de SUM ont dû effectuer un traitement spécial sur la couche inférieure du tableau.

Regardons l'exemple suivant :

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

 Grâce à cet exemple nous savons : [ représente la dimension du tableau, un [ représente une dimension, et deux [ représente deux dimensions. On peut simplement dire que le nom de classe d'un tableau se compose de plusieurs '[' et du nom interne du type d'élément du tableau. Si ce n'est pas clair, regardons-le à nouveau :

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

                              les vraies couleurs". Dans le même temps, on peut également voir que les tableaux sont différents des classes Java ordinaires.Les classes Java ordinaires utilisent des noms de chemin complets comme seuls identifiants, tandis que les tableaux utilisent plusieurs chemins complets de classe d'éléments de tableau. Les classes sont les plus identifiées de manière unique. . Cette différence peut expliquer dans une certaine mesure qu'il existe une grande différence dans l'implémentation des tableaux et des classes Java ordinaires. Peut-être que cette différence peut être utilisée pour permettre à la JVM de faire la distinction lors du traitement des tableaux et des classes Java ordinaires.

Laissons de côté ce que c'est [je, qui l'a déclaré, et comment cela a été déclaré (je ne les connais pas maintenant ! Mais il y a une chose Peut confirmer : cela est déterminé au moment de l'exécution). Jetons un coup d'œil à ce qui suit :

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

Il n'y a pas de variable membre, de méthode membre, de constructeur, d'annotation ou même la variable membre length. C'est une classe complètement vide. La longueur n'est pas déclarée, alors pourquoi le compilateur ne signale-t-il pas d'erreur lorsque nous utilisons array.length ? En effet, la longueur d’un tableau est une variable membre très particulière. Nous savons que le tableau est la classe directe de Object, mais Object n'a pas la variable membre length, donc length devrait être la variable membre du tableau, mais à partir de l'exemple ci-dessus, nous constatons que le tableau n'a aucune variable membre. N'est-ce pas du tout contradictoire ?

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

 

Ouvrez le fichier de classe et récupérez le bytecode de la méthode principale :

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）！