Lassen Sie uns über die Definition und Verwendung von Arrays in Java sprechen

Dieser Artikel vermittelt Ihnen relevantes Wissen über Java, in dem hauptsächlich Probleme im Zusammenhang mit der Definition und Verwendung von Arrays organisiert werden, einschließlich des String-Arrays in der Hauptmethode, der Speicherung von Referenzdatentypen in Arrays, der Array-Erweiterung und des Kopierens. Werfen wir einen Blick darauf Ich hoffe, dass der Inhalt unten für alle hilfreich sein wird.

Empfohlene Studie: „Java-Video-Tutorial“

Eindimensionales Array

Das Array in der Java-Sprache ist ein Referenzdatentyp; kein grundlegender Datentyp; die übergeordnete Klasse von Array Es ist ein Objekt. Ein Array ist eigentlich ein Container, der mehrere Elemente gleichzeitig enthalten kann. (Ein Array ist eine Sammlung von Daten)
Array: Bedeutet wörtlich „ein Datensatz“.

Arrays können Daten von „Basisdatentypen“ und Daten von „Referenzdatentypen“ speichern.
Da das Array ein Referenztyp ist, befindet sich das Array-Objekt im Heap-Speicher. (Arrays werden im Heap gespeichert)
Wenn das „Java-Objekt“ im Array gespeichert ist, wird tatsächlich die „Referenz (Speicheradresse) “ des Objekts gespeichert, das nicht direkt im Array gespeichert werden kann (Adresse speichern).

Sobald ein Array erstellt wird, wird in Java festgelegt, dass die Länge unveränderlich ist. (Array-Länge ist unveränderlich)Klassifizierung von Arrays: eindimensionales Array, zweidimensionales Array, dreidimensionales Array, mehrdimensionales Array ... (Eindimensionales Array ist häufiger, gelegentlich wird ein zweidimensionales Array verwendet !)

Alle Array-Objekte haben ein Längenattribut (Java ist im Lieferumfang enthalten), mit dem die Anzahl der Elemente im Array ermittelt wird. Das
Array in Java erfordert, dass die Elementtypen im Array einheitlich sein sollten. Beispielsweise kann ein Array vom Typ „int“ nur den Typ „int“ und ein Array vom Typ „Person“ nur den Typ „Person“ speichern. Zum Beispiel: Beim Einkaufen im Supermarkt darf man nur Äpfel in die Einkaufstüte packen, nicht Äpfel und Orangen gleichzeitig. (Die im Array gespeicherten Elementtypen sind einheitlich) Wenn das Array im Speicher gespeichert wird, sind die Speicheradressen der Elemente im Array (jedes gespeicherte Element ist regelmäßig nebeneinander angeordnet) fortlaufend. Speicheradressen sind fortlaufend. Dies ist das Merkmal (Merkmal) von Arrays, die Elemente speichern. Array ist eigentlich eine einfache Datenstruktur.
Alle Arrays verwenden die „Speicheradresse der ersten kleinen Box“ als Speicheradresse des gesamten Array-Objekts. (Die Speicheradresse des ersten Elements im Array wird als Speicheradresse des gesamten Array-Objekts verwendet.)
Jedes Element im Array hat einen Index, und der Index beginnt bei 0 und erhöht sich um 1. Der Index des letzten Elements ist: Länge - 1; der Index ist sehr wichtig, denn wenn wir auf die Elemente im Array „zugreifen“, müssen wir den Index verwenden.

ArrayWas sind die Vor- und Nachteile dieser Datenstruktur?
Vorteile: Es ist äußerst effizient beim Abfragen/Suchen/Abrufen von Elementen in einem bestimmten Index. Man kann sagen, dass es sich um die Datenstruktur mit der höchsten Abfrageeffizienz handelt. Warum ist die Abrufeffizienz so hoch? Erstens:
Die Speicheradresse jedes Elements ist hinsichtlich der räumlichen Speicherung kontinuierlich. Zweitens:
Jedes Element ist vom gleichen Typ, nimmt also den gleichen Platz ein. Drittens:
Kennen Sie die Speicheradresse des ersten Elements, die Größe des von jedem Element belegten Platzes und den Index, damit die Speicheradresse des Elements über einem bestimmten Index durch einen mathematischen Ausdruck berechnet werden kann. Lokalisieren Sie Elemente direkt über Speicheradressen, sodass die Effizienz beim Array-Abruf am höchsten ist. Wenn 100 Elemente in einem Array oder 1 Million Elemente gespeichert werden, ist die Effizienz hinsichtlich der Elementabfrage/-abfrage gleich, da die Elemente im Array nicht einzeln durchsucht, sondern mithilfe mathematischer Ausdrücke berechnet werden. (Berechnen Sie eine Speicheradresse und suchen Sie sie direkt.)
                  Nachteile :                           1: Um sicherzustellen, dass die Speicheradresse jedes Elements im Array kontinuierlich ist, ist die Effizienz beim zufälligen Löschen oder Hinzufügen von Elementen zum Array gleich niedrig, da das zufällige Hinzufügen und Löschen von Elementen die Vorwärts- oder Rückwärtsverschiebung nachfolgender Elemente mit sich bringt.
                  Zweitens: Arrays können keine großen Datenmengen speichern, warum? Denn es ist schwierig, im Speicherbereich einen besonders großen zusammenhängenden Speicherplatz zu finden. Das Hinzufügen oder Löschen des letzten Elements im Array hat keine Auswirkungen auf die Effizienz.

Wie deklariere/definiere ich ein eindimensionales Array?

Grammatikformat:

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

Wie initialisiere ich ein eindimensionales Array?
Es umfasst zwei Methoden: statische Initialisierung eines eindimensionalen Arrays und dynamische Initialisierung eines eindimensionalen Arrays.
          (1) Statisches Initialisierungssyntaxformat:
              int[] array = {100, 2100, 300, 55};
                (2) Dynamische Initialisierung. Syntax Format:
    int[] array = new int[ 5];

                                                                                                                                                                     vertreten durch
              Initialisieren Sie ein Array vom Typ „int“ mit 5 Längen. Jedes Element hat den Standardwert 0.
                        Ein weiteres Beispiel: String[] name = new String[6]; null.

Wann sollte die statische Array-Initialisierung verwendet werden? Wann sollte die dynamische Array-Initialisierung verwendet werden?

(1) Verwenden Sie beim Erstellen eines Schlüsselarrays die statische Initialisierung, wenn Sie bestimmen, welche spezifischen Elemente im Array gespeichert werden.

(2) Wenn Sie beim Erstellen eines Schlüsselarrays nicht sicher sind, welche Daten in Zukunft gespeichert werden, Sie können die dynamische Initialisierung verwenden. Speicherplatz vorab zuweisen

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]);
        }

    }

}

Dynamische Speicherzuordnung

Der Parameter der Methode ist ein Array

Wenn ein Array übergeben wird, empfängt die Methode es auch in Form eines Arrays; dieses Array kann statisch sein, es kann auch dynamisch erstellt werden und wir schreiben die

-Methode als statisch, sodass wir

ohne ein neues Objekt aufrufen können!

Beispiel 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]);
        }
    }

}

Beispiel 2: (Master)

(1) Ein Sonderfall der Übergabe eines statischen Arrays; wenn Sie ein statisches Array direkt übergeben, muss die Syntax so geschrieben werden!

(2) Schauen wir uns zunächst ein Beispiel an:

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

; Wenn wir die Parameter des Arrays übergeben, übergeben wir normalerweise den Array-Namen arr, zum Beispiel:

printArray( arr); Aber eine andere Methode besteht darin, es zu übergeben und die verbleibenden Komponenten des Array-Namens arr: int[]{1,2,3} zu entfernen, aber das neue Schlüsselwort hinzuzufügen, zum Beispiel: 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]);
        }
    }
}

String-Array in der Hauptmethode

(1) Für main(String[] args); analysieren: Wer ist für den Aufruf der Hauptmethode verantwortlich (JVM). )

JVM-Aufrufe main Beim Aufruf der Methode wird automatisch ein String-Array mit der Länge 0 übergeben.

Beispiel 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
    }
}

Beispiel 2:

(1) Wozu dient „String[] args“ über der Hauptmethode?

kann zur Simulation eines Login-Systems verwendet werden

! Schauen Sie sich bitte das folgende interessante Beispiel an:

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("账户或密码错误，请重新输入");
        }
    }
}

Speichern von Referenzdatentypen in Arrays (Schlüsselpunkte)

(1) Tiefe eindimensionaler Arrays: Die in Arrays gespeicherten Typen sind:

Referenzdatentypen

; für Arrays Tatsächlich kann nur die „Speicheradresse“ des Java-Objekts gespeichert werden.

Jedes in einem Array gespeicherte Element ist eine „Referenz“ . Die folgende Beispielfrage konzentriert sich auf das Verstehen! (2)Arrays erfordern, dass die Elemente im Array vom gleichen Typ sind;

können aber auch ihre Untertypen speichern

!

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("鸟儿在歌唱！");
    }
}

Array-Erweiterung und -Kopierung

Was soll ich tun, wenn in der Java-Entwicklung festgestellt wurde, dass die Array-Länge unveränderlich ist, wenn das Array voll ist und erweitert werden muss?

(1) Die Erweiterung von

Arrays in Java ist:

Erstellen Sie zuerst ein Array mit großer Kapazität und kopieren Sie dann die Elemente im Array mit kleiner Kapazität nacheinander in das große Array, und die kleine Kapazität wird freigegeben.
(2) Fazit: Die Effizienz der Array-Erweiterung ist gering. Weil es Kopierprobleme mit sich bringt. Achten Sie daher bitte bei der zukünftigen Entwicklung darauf, das Array so wenig wie möglich zu kopieren. Beim Erstellen eines Array-Objekts können Sie die folgende geeignete Länge schätzen. Es ist am besten, sie genau abzuschätzen, wodurch die Anzahl der Array-Erweiterungen reduziert werden kann. Verbessern Sie die Effizienz.
(3)Verwenden Sie System.arraycopy zum Kopieren

, insgesamt 5 Parameter;

System.arraycopy (Quellarray, Index, Zielarray, Index, zu kopierende Nummer)

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视频教程》

Das obige ist der detaillierte Inhalt vonLassen Sie uns über die Definition und Verwendung von Arrays in Java sprechen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!