Parlons de la définition et de l'utilisation des tableaux en Java

Cet article vous apporte des connaissances pertinentes sur java, qui organise principalement les problèmes liés à la définition et à l'utilisation des tableaux, y compris le tableau String dans la méthode principale, le stockage des types de données de référence dans les tableaux, l'expansion et la copie des tableaux. au contenu ci-dessous, j’espère qu’il sera utile à tout le monde.

Étude recommandée : "Tutoriel vidéo Java"

Tableau unidimensionnel

Le tableau en langage Java est un type de données de référence ; array C'est un objet. Un tableau est en fait un conteneur pouvant contenir plusieurs éléments en même temps. (Un tableau est une collection de données)
Tableau : signifie littéralement "un ensemble de données".

Les tableaux peuvent stocker des données de "types de données de base" et des données de "types de données de référence".
Étant donné que le tableau est un type référence, l'objet tableau est dans la mémoire tas. (Les tableaux sont stockés dans le tas)
Si "l'objet Java" est stocké dans le tableau, ce qui est réellement stocké est la "référence (adresse mémoire) " de l'objet Java ne peut pas être directement stocké dans le tableau. (enregistrer l'adresse).

Une fois un tableau créé, il est stipulé en java que la longueur est immuable. (La longueur du tableau est immuable)Classification des tableaux : tableau unidimensionnel, tableau bidimensionnel, tableau tridimensionnel, tableau multidimensionnel... (Le tableau unidimensionnel est plus courant, un tableau bidimensionnel est parfois utilisé !)

Tous les objets du tableau ont un attribut length (Java l'accompagne), utilisé pour obtenir le nombre d'éléments dans le tableau. Le
tableau en Java nécessite que les types d'éléments dans le tableau soient uniformes. Par exemple, un tableau de type int ne peut stocker que le type int, et un tableau de type Person ne peut stocker que le type Person. Par exemple : lorsque vous faites vos courses dans un supermarché, vous ne pouvez mettre que des pommes dans votre panier, pas des pommes et des oranges en même temps. (Les types d'éléments stockés dans le tableau sont uniformes) Lorsque le tableau est stocké en mémoire, les adresses mémoire des éléments du tableau (chaque élément stocké est régulièrement disposé les uns à côté des autres) sont continues. Les adresses mémoire sont consécutives. C'est la caractéristique (caractéristique) des tableaux stockant des éléments. Un tableau est en fait une simple structure de données.
Tous les tableaux utilisent "l'adresse mémoire de la première petite boîte" comme adresse mémoire de l'objet tableau entier. (L'adresse mémoire du premier élément du tableau est utilisée comme adresse mémoire de l'objet tableau entier.)
Chaque élément du tableau a un indice, et l'indice commence à 0 et augmente de 1. L'indice du dernier élément est : longueur - 1 ; l'indice est très important, car lorsque nous "accédons" aux éléments du tableau, nous devons utiliser l'indice.

ArrayQuels sont les avantages et inconvénients de cette structure de données ?
Avantages : Il est extrêmement efficace lors de l'interrogation/recherche/récupération d'éléments sur un certain indice. On peut dire qu'il s'agit de la structure de données ayant la plus grande efficacité de requête. Pourquoi l'efficacité de la récupération est-elle si élevée ? Premièrement :
L'adresse mémoire de chaque élément est continue en termes de stockage spatial. Deuxièmement :
Chaque élément est du même type, il occupe donc le même espace. Troisièmement :
Connaître l'adresse mémoire du premier élément, la taille de l'espace occupé par chaque élément et l'indice, afin que l'adresse mémoire de l'élément au-dessus d'un certain indice puisse être calculée via une expression mathématique. Localisez les éléments directement via les adresses mémoire, afin que l'efficacité de la récupération du tableau soit la plus élevée. Lorsque 100 éléments sont stockés dans un tableau ou 1 million d'éléments sont stockés, l'efficacité est la même en termes de requête/récupération d'éléments, car les éléments du tableau ne sont pas recherchés un par un, mais sont calculés à l'aide d'expressions mathématiques. (Calculez une adresse mémoire et localisez-la directement.)
                  Inconvénients  :                           1 : Afin de garantir que l'adresse mémoire de chaque élément du tableau est continue, ainsi lors de la suppression ou de l'ajout aléatoire d'éléments au tableau, l'efficacité est faible, car l'ajout et la suppression aléatoires d'éléments impliqueront le déplacement vers l'avant ou vers l'arrière des éléments suivants.
                  Deuxièmement : les tableaux ne peuvent pas stocker de grandes quantités de données, pourquoi ? Parce qu'il est difficile de trouver un espace mémoire continu particulièrement important dans l'espace mémoire. Il n'y a aucun impact sur l'efficacité de l'ajout ou de la suppression du dernier élément du tableau.

Comment déclarer/définir un tableau unidimensionnel ?

Format de grammaire :

int[] array1;
double[] array2;
boolean[] array3;
String[] array4;
Object[] array5;

Comment initialiser un tableau unidimensionnel ?
Il comprend deux méthodes : l'initialisation statique d'un tableau unidimensionnel et l'initialisation dynamique d'un tableau unidimensionnel.
          (1) Format de syntaxe d'initialisation statique :
              int[] array = {100, 2100, 300, 55};
                (2) Format de syntaxe d'initialisation dynamique :
    int[] array = new int[ 5];

Ici 5 représente le nombre d'éléments du tableau.
              Initialisez un tableau de type int de 5 longueurs, chaque élément a une valeur par défaut de 0
                       Un autre exemple : String[] noms = new String[6] ;

Quand utiliser l'initialisation de tableau statique ? Quand utiliser l’initialisation de tableau dynamique ?

(1) Lors de la création d'un tableau de clés, pour déterminer quels éléments spécifiques sont stockés dans le tableau, utilisez l'initialisation statique

(2) Lors de la création d'un tableau de clés, si vous n'êtes pas sûr des données qui seront stockées à l'avenir, vous pouvez utiliser l'initialisation dynamique. Pré-allouer de l'espace mémoire

package com.bjpowernode.javase.array;

public class ArrayTest01 {
    public static void main(String[] args) {
    //1.静态初始化
       int[] a1 = {1,3,5,7,9};
        //所有的数组对象都有length属性，而不是方法！
        System.out.println("数组元素的个数是："+a1.length);
        //取第一个元素
        System.out.println(a1[0]);
        //取最后一个元素
        System.out.println(a1[a1.length-1]);
        //改数据
        a1[a1.length-1] = 0;
        //遍历数据
        for(int i=0;i< a1.length;i++){
            System.out.println(a1[i]);
        }
        //数据下标越界异常，例如：访问下面为6的数据元素
        //System.out.println(a1[6]);// ArrayIndexOutOfBoundsException


    //2.动态初始化
        int[] a2 = new int[5]; //默认值是0
        for(int i=0;i< a2.length;i++){
            System.out.println(a2[i]);
        }
        //初始化一个Object类型的数组，
          //1.采用静态初始化方式
        Object o1 = new Object();
        Object o2 = new Object();
        Object o3 = new Object();
        Object[] object = {o1,o2,o3};
        //上面就等价于：Object[] object = {new Object(),new Object(),new Object()};
        for(int i=0;i<object.length;i++){
            System.out.println(object[i]);// 默认调用toString方法
        }
          //2.采用动态初始化的方式
        Object[] obj = new Object[3];
        for(int i=0;i<obj.length;i++){
            System.out.println(obj[i]);// null null null
        }

        //初始化一个String类型的数组
          //1.静态初始化
        String[] str1 = {"abc","bcd","cde"};
        for (int i = 0; i < str1.length; i++) {
            System.out.println(str1[i]);
        }
        //2.动态初始化
        String[] str2 = new String[3];
        for (int i = 0; i < str2.length; i++) {
            System.out.println(str2[i]);
        }

    }

}

Carte de mémoire de stockage dynamique

Le paramètre de la méthode est un tableau

Lorsqu'un tableau est transmis, la méthode le reçoit également. sous la forme d'un tableau ; ce tableau peut être static , il peut aussi être créé dynamiquement ; et nous écrivons la méthode

comme static, afin de pouvoir appeler

sans nouvel objet !

Exemple 1 :

package com.bjpowernode.javase.array;

public class ArrayTest02 {
    //也可以采用C++的风格,写成String args[]
    public static void main(String args[]) {
        System.out.println("HelloWorld");
        // 1.方法的参数传数组---静态初始化方式
        int[] a = {1,2,3,4,5};
        printArray(a);
        // 2.方法的参数传数组---动态初始化方式
        int[] arr = new int[5];
        printArray(arr);
        //   直接一步完成
        printArray(new int[3]);

    }
    //静态方法进行打印
    public static void printArray(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

}

Exemple 2 : (Maître)

(1) Un cas particulier de passage d'un tableau statique si vous passez directement un tableau statique, la syntaxe doit être écrite comme ceci !

(2) Regardons d'abord un exemple :

int[] arr = {1,2,3}

; Lorsque nous transmettons les paramètres du tableau, nous transmettons généralement le nom du tableau arr, par exemple :

printArray( arr); Mais une autre méthode consiste à le transmettre et à supprimer les composants restants du nom du tableau arr: int[]{1,2,3}, mais ajoutez le nouveau mot-clé, par exemple : printArray(new int[ ]{1, 2,3})

;

package com.bjpowernode.javase.array;

public class ArrayTest03 {
    public static void main(String[] args) {
     //----------1.动态初始化一位数组（两种传参方式）
        //第一种传参方式
        int[] a1 = new int[5];//默认是5个0
        printArray(a1);
        System.out.println("-------------");
        //第二种传参方式
        printArray(new int[3]);
        System.out.println("-------------");
     //----------2.静态初始化一位数组（两种传参方式）
        //第一种传参方式
        int[] a2 = {1,2,3};
        printArray(a2);
        System.out.println("-------------");
        //第二种传参方式----直接传递一个静态数组
        printArray(new int[]{4,5,6});

    }
    //调用的静态方法----静态方法比较方便，不需要new对象
    public static void printArray(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

Tableau de chaînes dans la méthode principale

(1) Pour main(String[] args analyser : qui est responsable de l'appel de la méthode principale (JVM); )

JVM appelle main Lors de l'appel de la méthode, un tableau String d'une longueur de 0 sera automatiquement transmis.

Exemple 1 :

package com.bjpowernode.javase.array;

public class ArrayTest04 {
    // 这个方法程序员负责写出来，JVM负责调用。JVM调用的时候一定会传一个String数组过来。
    public static void main(String[] args) {
        // JVM默认传递过来的这个数组对象的长度？默认是0
        // 通过测试得出：args不是null。
        System.out.println("JVM给传递过来的String数组参数，它这个数组的长度是？"
        + args.length); //0

        // 以下这一行代码表示的含义：数组对象创建了，但是数组中没有任何数据。就等价于：
        String[] strs = new String[0]; //动态的方式
        //String[] strs = {}; // 静态初始化数组，里面没东西。
        printLength(strs); //调用printLength静态方法

/*
     既然传过来的“String[] args”数组里什么都没有；那么这个数组什么时候里面会有值呢？
     其实这个数组是留给用户的，用户可以在控制台上输入参数，这个参数自动会被转换为“String[] args”
     例如这样运行程序：java ArrayTest04 abc def xyz；相当于在编译时进行传参
     那么这个时候JVM会自动将“abc def xyz”通过空格的方式进行分离，分离完成之后，自动放到“String[] args”数组当中。
     所以main方法上面的String[] args数组主要是用来接收用户输入参数的。
     把abc def xyz 转换成字符串数组：{"abc","def","xyz"}
*/
        // 遍历数组
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
        //既然是编译时进行传参，对于编译运行一体的IDEA怎么使用呢？
        //Run--->EditConfiguration--->Program Arguments里面进行传参，然后在从后重新运行

    }

    public static void printLength(String[] args){
        System.out.println(args.length); // 0
    }
}

Exemple 2 :

(1) À quoi sert "String[] args" au-dessus de la méthode principale ?

peut être utilisé pour simuler un système de connexion

 ! Veuillez regarder l'exemple intéressant suivant :

package com.bjpowernode.javase.array;
/*
   模拟一个系统，假设这个系统要使用，必须输入用户名和密码。
*/
public class ArrayTest05 {
    public static void main(String[] args) {
        //先判断长度，是不是两个字符串长度，不是2直接终止程序
        if(args.length != 2){
            System.out.println("请输入用户名和密码");
            return;
        }

        //取出用户名和密码
        String username = args[0];
        String password = args[1];
        // 假设用户名是admin，密码是123的时候表示登录成功。其它一律失败。
        // 判断两个字符串是否相等，需要使用equals方法。
        // if(username.equals("admin") && password.equals("123")){ //这样有可能空指针异常
        // 下面这种编写方式，也可以避免空该指针异常!
        if("admin".equals(username) && "123".equals(password)){ 
            System.out.println("恭喜你，登录成功");
            System.out.println("您可以继续使用该系统");
        }else{
            System.out.println("账户或密码错误，请重新输入");
        }
    }
}

Stockage des types de données de référence dans des tableaux (points clés)

(1) Profondeur des tableaux unidimensionnels : Les types stockés dans les tableaux sont :

Types de données de référence

 ; pour les tableaux En fait, seule "l'adresse mémoire" de l'objet Java peut être stockée.

Chaque élément stocké dans un tableau est une "référence" . L’exemple de question suivant se concentre sur la compréhension ! (2)Les tableaux nécessitent que les éléments du tableau soient du même type ; mais

peuvent également stocker ses sous-types

 !

package com.bjpowernode.javase.array;
public class ArrayTest06 {
    public static void main(String[] args) {
        //1.静态创建一个Animal类型的数组
        Animal a1 = new Animal();
        Animal a2 = new Animal();
        Animal[] animals = {a1,a2};

        //对Animal数组进行遍历
        for (int i = 0; i < animals.length; i++) {
            //方法1
            /*Animal a = animals[i];
            a.move();*/
            //方法2
            animals[i].move();
        }

        //2.动态初始化一个长度为2的animal类型的数组
        Animal[] ans = new Animal[2];
        ans[0] = new Animal();
        //ans[1] = new Product(); //err，Product和Animals没有任何关系
        //Animal数组中只能存放Animal类型，不能存放Product类型

        //3.Animal数组中可以存放Cat类型的数据，因为Cat是Animal一个子类
       ans[1] = new Cat();
        for (int j = 0; j < ans.length; j++) {
            ans[j].move();
        }

        //4.创建一个Animal类型的数据，数组当中存储Cat和Bird
          //4.1静态创建
        Cat cat = new Cat();
        Bird bird = new Bird();
        Animal[] anim = {cat,bird};
        for (int i = 0; i < anim.length; i++) {
            //直接调用子类和父类都有的move()方法
            //anim[i].move();
            
            //这里想要调用子类Bird里面特有的方法，需要向下转型
            if(anim[i] instanceof Bird){
                Bird b = (Bird)anim[i]; //向下转型
                b.move();
                b.sing(); //调用子类特有的方法
            }else{
                anim[i].move();
            }

        }


    }
}
//动物类
class Animal{
    public void move(){
        System.out.println("Animals move.....");
    }
}
//商品类
class Product{

}

//有一个猫类继承动物类
class Cat extends Animal{
    public void move(){
        System.out.println("Cat move.....");
    }
}

//有一个鸟类继承动物类
class Bird extends Animal{
    public void move(){
        System.out.println("Bird move.....");
    }

    //鸟特有的方法
    public void sing(){
        System.out.println("鸟儿在歌唱！");
    }
}

Extension et copie du tableau

Dans le développement Java, une fois que la longueur du tableau est déterminée comme étant immuable, que dois-je faire si le tableau est plein et doit être étendu ?

(1) L'expansion des

tableaux en Java est la suivante :

Créez d'abord un tableau de grande capacité, puis copiez les éléments du tableau de petite capacité un par un dans le grand tableau, et la petite capacité sera libérée.
(2) Conclusion : L'efficacité de l'expansion du tableau est faible. Parce que cela implique des problèmes de copie. Par conséquent, soyez attentif lors du développement futur : copiez le tableau le moins possible. Vous pouvez estimer la longueur appropriée ci-dessous lors de la création d'un objet tableau. Il est préférable d'estimer avec précision, ce qui peut réduire le nombre d'extensions de tableau. Améliorer l'efficacité.
(3)Utilisez System.arraycopy pour copier

, un total de 5 paramètres

System.arraycopy (tableau source, indice, tableau de destination, indice, numéro à copier)

package com.bjpowernode.javase.array;
public class ArrayTest07 {
    public static void main(String[] args) {
        //java中的数组是怎样拷贝的呢？System.arraycopy(5个参数)
        //System.arraycopy(源,下标,目的地,下标,个数)

        //拷贝源---把3、5、7拷贝过去
        int[] src = {1,3,5,7,9};
        //拷贝目的地---拷贝到下标为5的地方
        int[] dest = new int[20];
        //调用拷贝函数
        System.arraycopy(src,1,dest,5,3);
        //打印验证
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]+" ");
        }

        //拷贝引用数据类型
        String[] str = {"hello","world"};
        String[] strs = new String[10];
        System.arraycopy(str,0,strs,3,2);
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
        System.out.println("--------------");
        
        //采用动态开辟的时候拷贝的是地址
        Object[] objs = {new Object(),new Object(),new Object()};
        Object[] objects = new Object[5];
        System.arraycopy(objs,0,objects,0,3);
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);

        }

    }
}

内存图

推荐学习：《java视频教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!