Für diejenigen, die gerade mit dem Programmieren einschließlich der Java-Sprache begonnen haben, und für diejenigen, die es bereits gelernt haben, zur Überprüfung Dieses Mal schreibe ich, um mehr über ** Arrays ** zu erfahren.
Eine Variable ist ein Container, der Wertwerte für eine Variable enthält (Klicken Sie hier, um Variablen anzuzeigen).
Mithilfe eines Arrays können Sie mehrere Daten desselben Datentyps in einem Array verwalten. ``
Wenn es 500 Werte gibt, müssen Sie bei Variablen 500 Werte vorbereiten. Im Fall eines Arrays bedeutet dies, dass ein Array vorbereitet und 500 Daten darin gespeichert werden können.
Außerdem können Sie die Daten im Array einfach sortieren und den größten Wert erhalten.
Beim Erstellen eines Arrays muss zunächst der Datentyp festgelegt werden, welcher Wert wie eine Variable behandelt werden soll, ihm ein Name gegeben und deklariert werden.
Deklarieren Sie Datentyp [] Array Name.
Main.java
class Main {
public static void main(String[] args) {
int[] numbers; //Deklaration eines Arrays, das Werte vom Typ int verarbeiten kann
// []Kann nach dem Sequenznamen stehen.
String names[]; //Deklaration eines Arrays, das Werte vom Typ String verarbeiten kann
}
}
Es ist erforderlich, einen Bereich zu sichern, in dem das deklarierte Array mit Werten gefüllt werden soll. Bestimmen Sie die Größe des zu sichernden Bereichs durch "new [Anzahl der Elemente]".
Main.java
class Main {
public static void main(String[] args) {
int[] numbers; //Deklaration eines Arrays, das Werte vom Typ int verarbeiten kann
String names[]; //Deklaration eines Arrays, das Werte vom Typ String verarbeiten kann
numbers = new int[50]; //Reservieren Sie einen Bereich zum Speichern von 50 Werten im Zahlenarray
names = new String[3]; //Reservieren Sie einen Bereich zum Speichern von 3 Werten im Namensarray
}
}
** Es ist auch möglich, gleichzeitig ein Array zu deklarieren und einen Bereich zu sichern. ** ** **
Main.java
class Main {
public static void main(String[] args) {
int[] numbers = new int[50];//Deklarieren Sie ein Array, das Werte vom Typ int verarbeiten und 50 Bereiche sichern kann
String names[] = new String[3]; //Deklaration eines Arrays, das Werte vom Typ String und einen sicheren Bereich für 3 verarbeiten kann
}
}
** Bitte beachten Sie, dass ein Kompilierungsfehler auftritt, wenn Sie die Anzahl der Elemente nicht angeben. ** ** **
Main.java
class Main {
public static void main(String[] args) {
int[] numbers = new int[];//Kompilierungsfehler, da die Anzahl der Elemente nicht angegeben ist
String names[] = new String[]; //Kompilierungsfehler, da die Anzahl der Elemente nicht angegeben ist
}
}
Die Anzahl der Elemente im Array kann später nicht mehr geändert werden. Beachten Sie, dass, wenn Sie zuerst die Anzahl der Elemente im Array als 5 angeben, die Anzahl der Elemente danach immer auf 5 festgelegt wird.
Beachten Sie außerdem, dass die Anzahl der Elemente nicht ganzzahlig sein darf.
Das Array wird deklariert und instanziiert und ist bereit, die Werte zu speichern. Verwenden Sie "tiefgestellt (Index)", um einem Array einen Wert zuzuweisen. Indizes (Indizes) sind Seriennummern, die jedem Element des Arrays zugewiesen werden und bei 0 beginnen.
Main.java
class Main {
public static void main(String[] args) {
int[] numbers = new int[5]; //Definieren Sie ein Zahlenarray, in dem 5 Elemente vom Typ int gespeichert werden können
numbers[0] = 100; //Erstens 100
numbers[1] = 200; //Zweitens 200
numbers[2] = 300; //Drittens 300
numbers[3] = 400; //Viertens 400
numbers[4] = 500; //Fünftens 500
}
}
Indizes (Indizes) werden auch verwendet, um auf jedes Element des Arrays zuzugreifen.
Main.java
class Main {
public static void main(String[] args) {
int[] numbers = new int[5]; //Definieren Sie ein Zahlenarray, in dem 5 Elemente vom Typ int gespeichert werden können
numbers[0] = 100; //Erstens 100
numbers[1] = 200; //Zweitens 200
numbers[2] = 300; //Drittens 300
numbers[3] = 400; //Viertens 400
numbers[4] = 500; //Fünftens 500
System.out.println(numbers[0]); //100 wird ausgegeben
System.out.println(numbers[3]); //400 wird ausgegeben
}
}
Bis dahin wurden die Deklaration des Arrays, die Zuordnung des Bereichs und die Zuweisung des Wertes (Anfangswert) Schritt für Schritt durchgeführt.
Sie können gleichzeitig ein Array deklarieren, einen Bereich sichern und einen Wert (Anfangswert) zuweisen. (Initialisierung des Arrays)
Fügen Sie den Wert in {} ein und beschreiben Sie jedes durch Kommas getrennte Element.
Datentyp [] Array-Name = {Anfangswert 1, Anfangswert 2, Anfangswert 3, Anfangswert 4, Anfangswert 5};
Verwenden Sie außerdem length, um herauszufinden, wie viele Elemente Sie erstellt haben.
Sie können die Anzahl der Elemente mit array name.length; abrufen.
Main.java
class Main {
public static void main(String[] args) {
int[] numbers = {100, 200, 300, 400, 500}; //Array-Initialisierung
int size = numbers.length; //Abrufen der Anzahl der Elemente im Zahlenarray In diesem Fall wird 5 gespeichert
System.out.println(numbers[0]); //Ausgabe als 100
System.out.println(numbers[1]); //Ausgabe als 200
System.out.println(numbers[2]); //Ausgabe als 300
System.out.println(numbers[3]); //Ausgabe als 400
System.out.println(numbers[4]); //Ausgabe als 500
System.out.println(size); //Wird als 5 ausgegeben
//Die Array-Initialisierung mit dieser Beschreibungsmethode ist ebenfalls effektiv.
int[] id = new int[]{1, 2, 3};
System.out.println(id[0]); //Wird als 1 ausgegeben
System.out.println(id[1]); //2 wird ausgegeben
System.out.println(id[2]); //Wird als 3 ausgegeben
System.out.println(id.length); //Wird als 3 ausgegeben
}
}
Ich habe Indizes (Indizes) verwendet, um auf die Elemente des Arrays zuzugreifen. Beim Versuch, außerhalb der Elemente eines Arrays zuzugreifen, tritt kein Kompilierungsfehler auf, sondern ein Laufzeitfehler (Ausnahme). Weitere Informationen finden Sie unter Artikel zur Ausnahmebehandlung (https://qiita.com/morioheisei/items/d25d2b67e7530c1aab9d).
Lassen Sie uns auch hier einen kurzen Blick darauf werfen.
Main.java
class Main {
public static void main(String[] args) {
int[] id = {1, 2, 3, 4, 5}; //Die Anzahl der Elemente im Array beträgt 5
//Drehen Sie die Schleife 6 Mal mit der for-Anweisung=Überschüssige Elemente des ID-Arrays
for(int i = 0; i < 6; i++) {
//Ausgabe eins nach dem anderen
System.out.println(id[i]);
}
System.out.println("Ich habe die Ausgabe des gesamten Inhalts des ID-Arrays abgeschlossen.");
}
}
Das Ausgabeergebnis ist
Terminal
1
2
3
4
5
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
at Main.main(Main.java:195)
Es wurde wie oben ausgegeben. Eine ArrayIndexOutOfBoundsException-Ausnahme ist aufgetreten. Und ich habe die Ausgabe des gesamten Inhalts des ID-Arrays abgeschlossen. Wird nicht angezeigt. Wenn Sie versuchen, auf diese Weise auf das Array zuzugreifen, wenn Sie außerhalb des Elements zugreifen, Seien Sie vorsichtig, da eine Ausnahme auftritt und die Verarbeitung in der Mitte stoppt.
Es gibt auch zweidimensionale Arrays, die zwei Indizes (Indizes) verwalten, und mehrdimensionale Arrays. Dieses Mal werde ich das zweidimensionale Array erklären.
Verwenden Sie in einem zweidimensionalen Array zwei [] Deklarieren Sie den Array-Namen des Datentyps [] [].
Main.java
class Main {
public static void main(String[] args) {
int[][] numbers; //Deklaration eines zweidimensionalen Arrays, das Werte vom Typ int verarbeiten kann
// [][]Kann nach dem Sequenznamen stehen.
String strs[][]; //Deklaration eines zweidimensionalen Arrays, das Werte vom Typ String verarbeiten kann
}
}
Wie bei einem eindimensionalen Array muss ein Bereich gesichert werden, in dem das deklarierte Array mit Werten gefüllt werden soll.
Main.java
class Main {
public static void main(String[] args) {
int[][] numbers; //Deklaration eines zweidimensionalen Arrays, das Werte vom Typ int verarbeiten kann
String strs[][]; //Deklaration eines zweidimensionalen Arrays, das Werte vom Typ String verarbeiten kann
//Ein Array mit drei Elementen, Zahlen[0]Aus Zahlen[2]Sichern Sie einen Bereich mit 4 Elementen für jedes Element von
numbers = new int[3][4];
//Ein Array mit zwei Elementen, strs[0]Von strs[1]Sichern Sie einen Bereich mit zwei Elementen für jedes Element von
strs = new String[2][2];
}
}
Wie ein eindimensionales Array ** Es ist auch möglich, gleichzeitig ein Array zu deklarieren und einen Bereich zu sichern. ** ** **
Main.java
class Main {
public static void main(String[] args) {
//Weisen Sie eine zweidimensionale Array-Deklaration und einen Bereich zu, die Werte vom Typ int verarbeiten können
int[][] numbers = new int[3][4];
//Weisen Sie eine zweidimensionale Array-Deklaration und einen Bereich zu, die Zeichenfolgentypwerte verarbeiten können
String strs[][] = new String[2][2];
}
}
Es ist auch möglich, nur den Bereich des Arrays der ersten Dimension zu sichern. `` In diesem Fall können Sie später die Anzahl der Elemente in der zweiten Dimension festlegen.
Main.java
class Main {
public static void main(String[] args) {
int[][] array; //Deklaration eines zweidimensionalen Arrays, das Werte vom Typ int verarbeiten kann
array = new int[3][]; //Reservebereich für ein Array mit 3 Elementen
array[0] = new int[5]; //Das erste Array des Arrays kann 5 Elemente speichern
array[1] = new int[3]; //Das zweite Array des Arrays kann 3 Elemente speichern
array[2] = new int[4]; //Das dritte Array des Arrays kann 4 Elemente speichern
//Gleiches gilt, wenn gleichzeitig ein Array deklariert und ein Bereich gesichert wird.
String[][] strs = new String[2][]; //Deklaration des String-Typ-Arrays, Zuweisung des Bereichs
strs[0] = new String[6]; //Das erste Array von strs kann 6 Elemente speichern
strs[1] = new String[3]; //Das zweite Array von strs kann drei Elemente speichern
}
}
Selbst im Fall eines zweidimensionalen Arrays kann die Anzahl der Elemente später nicht geändert werden, und die Anzahl der Elemente muss eine Ganzzahl sein.
Werte werden mithilfe von Indizes (Indizes) wie eindimensionale Arrays gespeichert.
Main.java
class Main {
public static void main(String[] args) {
int[][] numbers = new int[2][2]; //Deklaration eines zweidimensionalen Arrays, das Werte vom Typ int verarbeiten kann
numbers[0][0] = 100;
numbers[0][1] = 200;
numbers[1][0] = 300;
numbers[1][1] = 400;
System.out.println(numbers[0][0]); //Ausgabe als 100
System.out.println(numbers[0][1]); //Ausgabe als 200
System.out.println(numbers[1][0]); //Ausgabe als 300
System.out.println(numbers[1][1]); //Ausgabe als 400
}
}
Auch in einem zweidimensionalen Array
Sie können gleichzeitig ein Array deklarieren, einen Bereich sichern und einen Wert (Anfangswert) zuweisen. (Initialisierung des Arrays)
Fügen Sie in ähnlicher Weise den Wert in {} ein und beschreiben Sie jedes durch Kommas getrennte Element.
Datentyp [] [] Array name = { {Anfangswert 1, Anfangswert 2, Anfangswert 3, Anfangswert 4, Anfangswert 5}, {Anfangswert 6, Anfangswert 7, Anfangswert 8, Anfangswert 9, Anfangswert 10} };
Verwenden Sie außerdem length, um herauszufinden, wie viele Elemente Sie erstellt haben.
Sie können die Anzahl der Elemente mit array name.length; abrufen.
Um die Länge des Arrays in diesem Array zu erhalten
Sie können die Anzahl der Elemente mit array name [subscript (index)] .length abrufen.
Main.java
class Main {
public static void main(String[] args) {
//Wie bei einem eindimensionalen Array ist es möglich, ein Array zu deklarieren, einen Bereich zu sichern und gleichzeitig einen Wert zuzuweisen.
int[][] numbers = {
{1, 2, 3, 4, 5},
{6, 7, 8, 9, 10},
{11, 12, 13},
{16, 17}
};
System.out.println("numbers[0][4]Der Wert des: " + numbers[0][4]); // numbers[0][4]Der Wert des:Wird als 5 ausgegeben
System.out.println("numbers[3][0]Der Wert des: " + numbers[3][0]); // numbers[3][0]Der Wert des:Wird als 16 ausgegeben
System.out.println("Nummernlänge: " + numbers.length); // Nummernlänge:Wird als 4 ausgegeben
System.out.println("numbers[0]Länge von: " + numbers[0].length); // numbers[0]Länge von:Wird als 5 ausgegeben
System.out.println("numbers[2]Länge von: " + numbers[2].length); // numbers[2]Länge von:Wird als 3 ausgegeben
System.out.println("numbers[3]Länge von: " + numbers[3].length); // numbers[3]Länge von:2 wird ausgegeben
}
}
Von hier aus werde ich eine einfache Verwendung von 1-dimensionalem Array und 2-dimensionalem Array vorstellen.
Denken Sie daran, zuerst zu importieren, da wir die Klasse java.util.Arrays verwenden werden. Klicken Sie hier für die Arrays-Klasse von Oracle
Main.java
import java.util.Arrays;
class Main {
public static void main(String[] args) {
//Initialisieren Sie das Zahlenarray (die Reihenfolge der darin enthaltenen Ganzzahlen ist zufällig).
int[] numbers = {10, 1, 5, 6, 9};
//Sortieren Sie in aufsteigender Reihenfolge mit der Sortiermethode der Arrays-Klasse
Arrays.sort(numbers);
//Ausgabennummern Array nacheinander
for(int number : numbers) {
System.out.print(number + " "); //Ausgabe als 1 5 6 9 10
}
}
}
Zahlen, die zufällige Ganzzahlen enthielten, können mithilfe der Sortiermethode in aufsteigender Reihenfolge sortiert werden.
Als nächstes sortieren wir die Zeichenketten.
Main.java
import java.util.Arrays;
class Main {
public static void main(String[] args) {
//Initialisieren Sie das Namensarray (die Reihenfolge der darin enthaltenen Namen ist zufällig).
String[] names = {"tanaka", "abe", "suzuki", "maeda"};
//Sortieren Sie alphabetisch nach der Sortiermethode der Arrays-Klasse
Arrays.sort(names);
//Ausgabennamen Array nacheinander
for(String name : names) {
System.out.print(name + " "); //Ausgabe als abe maeda suzuki tanaka
}
}
}
Namen, die zufällige Zeichenfolgen enthielten, können mithilfe der Sortiermethode alphabetisch sortiert werden.
Main.java
class Main {
public static void main(String[] args) {
//Initialisieren Sie die zweidimensionalen Array-Nummern (die Reihenfolge der darin enthaltenen Ganzzahlen ist zufällig).
int[][] numbers = {
{2, 5, 6, -10, 100, 3},
{-1000, 1, 20},
{999, 12, 300, 50}
};
//Definieren Sie die maximale Variable, um den Maximalwert festzulegen
int max = 0;
//Definieren Sie die Variable min, um den Mindestwert festzulegen
int min = 0;
//Schauen Sie sich die erste Dimension des Zahlenarrays nacheinander an
for(int i = 0; i < numbers.length; i++) {
// numbers[0]、numbers[1]、numbers[2]Schauen Sie sich den Inhalt von eins nach dem anderen an
for(int j = 0; j < numbers[i].length; j++) {
// numbers[0]、numbers[1]、numbers[2]Wenn es eine Zahl gibt, die größer als max in ist
if(max < numbers[i][j]) {
//Ersetzen Sie die maximale Variable durch diese Zahl
max = numbers[i][j];
}
// numbers[0]、numbers[1]、numbers[2]Wenn es eine Zahl gibt, die kleiner als min in ist
if(min > numbers[i][j]) {
//Ersetzen Sie die min-Variable durch diese Zahl
min = numbers[i][j];
}
}
}
System.out.println("Maximaler Wert im Zahlenarray: " + max); // Maximaler Wert im Zahlenarray:Ausgabe als 999
System.out.println("Minimaler Wert des Zahlenarrays: " + min); // Minimaler Wert des Zahlenarrays: -Ausgabe als 1000
}
}
Die Elemente des Arrays werden einzeln mit der for-Anweisung verglichen (ein separater Artikel wird für die iterative Verarbeitung beschrieben).
Wenn es eine große oder eine kleine Zahl gibt, wird der Wert jedes Mal der Maximalwert-Max-Variablen und der Minimalwert-Min-Variablen zugewiesen.
Es ist einfach, aber ich habe etwas über Arrays gelernt.
Die Anzahl der Elemente im Array wurde festgelegt, es gibt jedoch auch eine variable Liste. Ich möchte das in einem anderen Artikel behandeln.
Da mehrere Daten verwendet werden können, gibt es viele Möglichkeiten, sie zu verwenden. Ich möchte es festhalten.
Recommended Posts