Hallo habrozhiteli! Dieses Buch ist für Anfänger gedacht.
Seit vielen Jahren ist die Java-Sprache eine der beliebtesten und gefragtesten. Es ist schön, effektiv und vor allem sehr produktiv. Aber leider nicht die einfachste. Deshalb ist die Nachfrage nach Java-Programmierern konstant hoch. Die Java-Sprache ist ein Diamant, der das Wissensgepäck eines jeden Programmierers schmückt. Und Java zu lernen, wie ich hoffe, müssen die Leser dieses Buches sicherstellen, dass es nicht nur nützlich, sondern auch interessant ist. Grundlage des Buches sind Vorlesungen zu unterschiedlichen Zeiten, die ich für die nach ihr benannten Meister der Fakultät für Physik der Nationalen Universität Kiew gelesen habe Tarasa Shevchenko, Bachelor der Medizintechnischen Fakultät der Nationalen Technischen Universität der Ukraine „Kiewer Polytechnisches Institut“ und Studenten verschiedener Programmierkurse. Das Material des Buches und die Art der Präsentation sind für alle geeignet, die Java nicht nur in Bildungseinrichtungen, sondern auch unabhängig lernen möchten. Daher kann das Buch als Tutorial verwendet werden.
Arrays
Ein Array bedeutet eine Menge derselben Art von Werten (Variablen), auf die unter einem gemeinsamen Namen zugegriffen werden kann. Dieses Kapitel ist Arrays gewidmet.
Zu einem Array gehörende Variablen werden als Elemente dieses Arrays bezeichnet. Um ein Element eines Arrays eindeutig zu identifizieren, müssen Sie den Namen des Arrays und die Position (Platzierung) des Elements im Array kennen. Die Position der Elemente im Array wird mithilfe von Ganzzahlindizes bestimmt. Die Anzahl der Indizes, die zum Identifizieren eines Elements eines Arrays benötigt werden, wird als Dimension des Arrays bezeichnet. Ein eindimensionales Array ist ein Array, in dem Elemente anhand eines einzelnen Index identifiziert werden.
Eindimensionale Arrays
Es ist zweckmäßig, sich ein eindimensionales Array in Form einer geordneten Kette oder Folge von Variablen (desselben Typs) vorzustellen. Um ein eindimensionales Array zu deklarieren, müssen Sie den Typ angeben, zu dem die Elemente des Arrays gehören, den Namen des Arrays sowie die Anzahl der im Array enthaltenen Elemente. Die Syntax zum Deklarieren eines eindimensionalen Arrays lautet:
[] =new [];
Zuerst wird der Typ der Elemente des Arrays angegeben, und nach dem Typbezeichner folgen leere eckige Klammern. Als nächstes der Name des Arrays, der Zuweisungsoperator, der Befehl (Operator) neu, wieder der Typ der Elemente des Arrays und in eckigen Klammern die Größe des Arrays (die Anzahl der Elemente im Array). Beispielsweise deklariert der Befehl int nums = new int [20] ein ganzzahliges nums-Array mit 20 Elementen.
Genau genommen ist der hier vorgestellte Befehl zur Array-Deklaration eine Symbiose aus zwei Befehlen: den int [] -Befehlsnummern, die eine Variablennummer vom Typ "Integer-Array" (Array-Variable) deklarieren, und dem neuen Befehl int [20], der tatsächlich das Array erstellt. Dieser Anweisung wird der Wert der Variablen nums zugewiesen, und als Ergebnis der Arrayreferenz wird er in die Variable nums geschrieben. Mit anderen Worten kann der Prozess zum Erstellen eines Arrays mit zwei Befehlen ausgeführt werden:
int[] nums; nums=new int[20];
Darüber hinaus können diese Befehle im Programmcode veröffentlicht werden - das heißt, wir können eine Array-Variable deklarieren und erst dann an einer anderen Stelle im Code ein Array erstellen (und einen Link zu diesem Array in die Array-Variable schreiben).
DETAILS Bisher haben wir uns hauptsächlich mit grundlegenden oder primitiven Typen (wie int, char oder double) befasst. Eine Variable vom Basistyp speichert den Wert. Technisch sieht es so aus: Für eine Variable im Speicher wird ein Leerzeichen zugewiesen, und der Wert der Variablen wird an diese Stelle geschrieben. Es gibt jedoch eine andere Möglichkeit, mit Daten zu arbeiten, bei denen sich eine Variable auf Daten bezieht. Dies passiert mit Objekten, und so werden Arrays implementiert. Es gibt tatsächlich ein Array, aber wir erhalten keinen direkten Zugriff darauf, sondern mithilfe eines Vermittlers, der eine Array-Variable ist. Der Wert der Array-Variablen ist nicht das Array, sondern die Adresse des Arrays. Das Erstellen einer Array-Variablen bedeutet daher nicht das Erstellen eines Arrays. Ein Array wird separat erstellt. Wir werden diese Situation als eine beschreiben, in der sich eine Array-Variable auf ein Array bezieht. Jedes Mal, wenn wir auf das Array zugreifen müssen, greifen wir auf die Array-Variable zu, die sich auf das angegebene Array bezieht.
Obwohl ein solches Schema auf den ersten Blick überflüssig erscheint, hat es dennoch seine Vorteile. Und wir werden das sehen.
In Fällen, in denen kein Missverständnis vorliegt, identifizieren wir die Array-Variable mit dem Array.
Beim Deklarieren einer Array-Variablen dürfen eckige Klammern entweder nach der Typkennung oder nach dem Array-Namen angegeben werden. Beispielsweise können Sie anstelle des Befehls int [] nums den Befehl int nums [] verwenden.
Auf ein Element eines eindimensionalen Arrays wird über den Namen des Arrays zugegriffen, wobei der Index des Elements in eckigen Klammern angegeben ist. Die Indizierung von Array-Elementen beginnt bei Null. Daher sieht der Verweis auf das erste Element des nums-Arrays wie nums [0] aus. Wenn das Array 20 Elemente enthält, hat das letzte Element des Arrays einen Index von 19, dh die Anweisung zum Zugriff auf das Element sieht aus wie nums [19].
Die Länge des Arrays kann mithilfe der Eigenschaft length ermittelt werden: Der Name des Arrays wird angegeben und durch den Punkt die Eigenschaft length. Um beispielsweise die Länge des nums-Arrays herauszufinden, können Sie die Anweisung nums.length verwenden. Dann kann der Verweis auf das letzte Element des Arrays als nums [nums.length-1] geschrieben werden.
HINWEIS Java verwendet eine automatische Überprüfung, um festzustellen, ob das Array verlassen wird. Wenn der Code auf ein nicht vorhandenes Array-Element verweist, tritt daher ein Fehler auf.
Beim Deklarieren eines Arrays wird Speicher dafür zugewiesen. In Java werden Array-Elemente automatisch mit Nullwerten initialisiert. Die ausgewählten Zellen werden auf Null gesetzt, und die Werte dieser auf Null gesetzten Zellen werden je nach Array-Typ interpretiert. Sie sollten sich jedoch nicht auf eine solche automatische Initialisierung verlassen. Es ist ratsam, die Elemente des Arrays explizit zu initialisieren. Verwenden Sie dazu den Schleifenoperator oder geben Sie beim Deklarieren eines Arrays eine Liste von Elementwerten an.
Um das Array beim Deklarieren einer Array-Variablen mit einer Liste von Werten zu initialisieren, wird nach Angabe (über den Zuweisungsoperator) eine Liste von Werten in geschweiften Klammern angezeigt. Zum Beispiel:
int[] data={3,8,1,7};
Hier werden die Variablendaten für ein ganzzahliges Array deklariert, ein Array erstellt und ein Link dazu in diese Variable geschrieben. Die Größe des Arrays und die Werte der Elemente werden automatisch anhand der Anzahl der Elemente in der Werteliste bestimmt. In diesem Fall wird ein ganzzahliges Array von vier Elementen mit den Werten der Elemente 3, 8, 1 und 7 erstellt. Das gleiche Ergebnis kann beispielsweise mit den folgenden Befehlen erzielt werden:
int[] data; data=new int[]{3,8,1,7};
Der erste Datenbefehl int [] deklariert eine Arrayvariable. Der Befehl new int [] {3,8,1,7} erstellt ein Array mit vier Ganzzahlen, und den variablen Daten wird ein Verweis auf dieses Array zugewiesen (dh der Befehl data = new int [] {3,8,1,7}). .
Ein Beispiel für das Deklarieren, Initialisieren und Verwenden von Arrays finden Sie in Listing 3.1.
Listing 3.1. Einführung eindimensionaler Arrays
class Demo{ public static void main(String[] args){
Das Programm deklariert und initialisiert ein Datenarray aus vier Elementen. Die Länge des Arrays wird durch die Anweisung data.length berechnet. Dieser Wert wird in die Ganzzahlvariable n geschrieben (Befehl n = data.length). Als nächstes deklariert der Befehl int [] nums = new int [n] ein anderes Array mit ganzzahligen Zahlen. Die Anzahl der Elemente in diesem Array wird durch den Wert der Variablen n bestimmt und fällt daher mit der Größe des Datenarrays zusammen. Das Füllen des nums-Arrays erfolgt mit einer Schleifenanweisung. Die Werte der Elemente des nums-Arrays werden basierend auf den Werten der Elemente des Datenarrays berechnet (Befehl nums [i] = 2 * data [i] -3). Verwenden Sie den Befehl System.out.println ("nums [" + i + "] =" + nums [i]), um die Werte von Elementen des nums-Arrays anzuzeigen.
Das Folgende zeigt, wie das Ergebnis der Programmausführung aussieht:
Das Ergebnis des Programms (aus Listing 3.1)
nums[0]=3 nums[1]=13 nums[2]=-1 nums[3]=11
Wir stellen erneut fest, dass die Indizierung von Array-Elementen bei Null beginnt. Daher wird im Schleifenoperator die Indexvariable i mit dem anfänglichen Nullwert initialisiert, und der Operator für strikte Ungleichung wird in der Testbedingung i <nums.length verwendet.
Es ist auch wichtig, dass beim Erstellen des nums-Arrays seine Größe mithilfe der Variablen n bestimmt wird, deren Wert während der Ausführung des Programms berechnet wird.
Zweidimensionale und mehrdimensionale Arrays
Die Dimension des Arrays kann größer als eins sein. In der Praxis werden jedoch selten Arrays mit einer höheren Dimension als der zweiten verwendet. Als Nächstes werden Möglichkeiten zum Deklarieren, Initialisieren und Verwenden zweidimensionaler Arrays untersucht, bei denen der Zugriff auf ein Element eines Arrays mithilfe von zwei Indizes erfolgt. Wenn Sie ein zweidimensionales Array als Tabelle darstellen, bestimmt der erste Index des Elements die Zeile, in der sich das Element befindet, und der zweite Index bestimmt die Spalte, in der sich das Element befindet.
DETAILS Obwohl ein zweidimensionales Array bequem als Tabelle dargestellt wird, wird es auf eine völlig andere Weise implementiert. Tatsächlich ist ein zweidimensionales Array in Java ein eindimensionales Array, dessen Elemente Arrayvariablen sind. Jede solche Variable bezieht sich auf ein eindimensionales Array. Bei Verwendung dieser Konstruktion entsteht die Illusion, dass es sich um einen Tisch handelt.
Das Erstellen zweidimensionaler Arrays ist so einfach wie das Erstellen eindimensionaler Arrays. Wenn Sie jedoch eine Variable für ein zweidimensionales Array deklarieren, werden nach der Typkennung zwei Paare leerer eckiger Klammern angegeben, und die Anweisung zum Erstellen eines zweidimensionalen Arrays - in separaten eckigen Klammern - gibt die Größe für jeden der Indizes an (die Anzahl der Zeilen und Spalten im Array). Die Syntax zum Deklarieren eines zweidimensionalen Arrays lautet wie folgt:
[][] =new [][];
Wie bei einem eindimensionalen Array kann dieser Befehl in zwei Teile unterteilt werden:
[][] ; =new [][];
Der erste Befehl deklariert eine Variable für ein zweidimensionales Array. Der zweite Befehl erstellt ein tatsächliches zweidimensionales Array mit den angegebenen Größen, und ein Verweis auf dieses Array wird als Wert der Arrayvariablen zugewiesen. Mit dem Befehl double [] [] data = new double [3] [4] wird beispielsweise ein zweidimensionales Array mit Elementen vom Typ double erstellt. Das Array hat 3 Zeilen und 4 Spalten, und der Link zum Array wird in die Datenvariable geschrieben. Dieselben Befehle führen zu demselben Ergebnis:
double[][] data; data=new double[3][4];
Der Zugriff auf Elemente eines zweidimensionalen Arrays erfolgt im folgenden Format: Der Name des Arrays wird angegeben, in eckigen Klammern steht der erste Index des Elements, in anderen eckigen Klammern der zweite Index des Elements des Arrays. Die Indizierung über alle Dimensionen beginnt bei Null. Beispielsweise ist die Verknüpfung data [0] [3] ein Aufruf eines Elements des Datenarrays mit den Indizes 0 und 3 und ein Element in der ersten Zeile und vierten Spalte.
Um ein zweidimensionales Array zu initialisieren, werden verschachtelte Schleifenoperatoren oder eine Liste mit Wertelisten verwendet. Jede solche interne Liste definiert die Werte der Array-Elemente in einer Zeichenfolge. Im Folgenden finden Sie Beispiele für die Initialisierung eines zweidimensionalen Arrays mithilfe einer Liste:
double[][] data={{0.1,0.2,0.3},{0.4,0.5,0.6}}; int nums[][]={{1,2,3},{4,5}};
Der erste Befehl erstellt und initialisiert ein zweidimensionales 2 x 3-Datenarray (zwei Zeilen und drei Spalten). Die Anzahl der Zeilen wird durch die Anzahl der Elemente in der externen Liste bestimmt. Es gibt zwei solche Elemente - dies sind die Listen {0.1,0.2,0,3} und {0,4,0,5,0,6}. Jede dieser Listen enthält drei Elemente. Dies ergibt ein Array mit den Größen 2 mal 3. Die Liste {0.10.0.2.0.3} definiert die Werte der Elemente in der ersten Zeile, die Liste {0.4.0.5.0.6} bestimmt die Werte der Elemente in der zweiten Zeile. Beispielsweise erhält das Element data [0] [0] den Wert 0,1, das Element data [0] [2] den Wert 0,3, das Element data [1] [0] den Wert 0,4 und das Element data [1] [2] den Wert 0,6 .
Der zweite Befehl erstellt ein Integer-Nums-Array, das aus zwei Zeilen besteht (da die zugewiesene Liste zwei Elemente enthält - Listen {1,2,3} und {4,5}). Die erste Zeile des erstellten Arrays enthält jedoch drei Elemente (da die Liste drei Werte enthält {1,2,3}), und die zweite Zeile des Arrays enthält zwei Elemente (da die Liste zwei Werte enthält {4,5}). In dem erstellten Array hat das Element nums [0] [0] den Wert 1, das Element nums [0] [1] den Wert 2, das Element nums [0] [2] den Wert 3 und das Element nums [1] [0] den Wert 4 und das Element nums [1] [1] ist der Wert 5.
DETAILS Das Problem ist, dass das nums-Array in verschiedenen Zeilen eine unterschiedliche Anzahl von Elementen enthält, Nr. Technisch ist alles mehr als nur implementiert. Die Variable der zweidimensionalen Array-Nummern bezieht sich tatsächlich auf ein eindimensionales Array aus zwei Elementen (die Anzahl der Zeilen in dem zweidimensionalen Array). Die Elemente dieses Arrays sind jedoch keine Ganzzahlen, sondern Variablen, die sich auf eindimensionale Ganzzahlarrays beziehen können (relativ gesehen sind die Elemente vom Typ int []). Die erste Variable bezieht sich auf eine eindimensionale Anordnung von drei Elementen (1, 2 und 3), und die zweite Variable bezieht sich auf eine eindimensionale Anordnung von drei Elementen (4 und 5). Wenn wir die Variable nums indizieren (mit einem Index!), Erhalten wir Zugriff auf das Element des eindimensionalen Arrays, auf das diese Variable verweist. Zum Beispiel ist nums [0] das erste Element und nums [1] das zweite Element des erwähnten Arrays aus Arrayvariablen. Und diese Elemente sind Verweise auf Arrays. Sie können indiziert werden. Nehmen wir daher an, nums [0] [1] ist das zweite Element im Array, auf das sich das erste nums [0] -Element in dem Array bezieht, auf das sich die nums-Variable bezieht. Also passiert wirklich alles. Und wir interpretieren den Befehl nums [0] [1] als Appell an ein Element in der ersten Zeile und in der zweiten Spalte eines zweidimensionalen Arrays.
Listing 3.2 zeigt ein Beispiel für ein Programm, das ein zweidimensionales Array erstellt, das mit verschachtelten Schleifenanweisungen gefüllt wird.
Listing 3.2. Erstellen Sie ein zweidimensionales Array
class Demo{ public static void main(String[] args){ int i,j,n=3,val=1;
Der Befehl int [] [] nums = new int [n-1] [n] erstellt ein ganzzahliges nums-Array mit n-1 Zeilen und n Spalten. Der Variablen n wird der Wert 3 vorab zugewiesen. Das Array wird mit verschachtelten Schleifenoperatoren gefüllt. Der Wert für das Array-Element (für die angegebenen Indizes i und j) wird durch den Befehl nums [i] [j] = val ++ zugewiesen. Hier wird dem Element nums [i] [j] der aktuelle Wert der Variablen val zugewiesen, und unmittelbar danach wird der Wert der Variablen val um eins erhöht.
HINWEIS Durch Ausführen der Anweisung val ++ wird der Wert der Variablen val um eins erhöht. Da jedoch die Postfix-Form des Inkrementoperators verwendet wird, ist der Wert des Ausdrucks val ++ der alte Wert (vor dem Erhöhen um eins) der Variablen val.
Nach der Berechnung des Werts des Elements wird es im Ausgabebereich angezeigt. Als Ergebnis des Programms erhalten wir:
Das Ergebnis des Programms (aus Listing 3.2)
1 2 3 4 5 6
Listing 3.3 zeigt den Code für ein Programm, das ein zweidimensionales Array mit Zeichenfolgen unterschiedlicher Länge erstellt.
Listing 3.3. Array mit Strings unterschiedlicher Länge
class Demo{ public static void main(String[] args){ int i,j,val=1;
Der Befehl int [] [] nums = new int [4] [] erstellt ein zweidimensionales ganzzahliges nums-Array. Dieses Array besteht aus vier Zeilen. Die Größe der Zeilen ist jedoch nicht angegeben - das zweite Paar eckiger Klammern am Ende des Befehls ist leer. Genauer gesagt gibt es noch keine Zeilen. Sie müssen erstellt werden. Linien werden in der Schleifenanweisung erstellt. In dieser Schleifenanweisung durchläuft die Indexvariable i Werte von 0 bis einschließlich nums.length-1. Der Befehl nums [i] = new int [i + 1] erstellt eine Zeile eines zweidimensionalen Arrays mit dem Index i. Eine solche Zeichenfolge enthält ein i + 1-Element.
DETAILS Technisch gesehen geschieht alles so: Der neue Befehl int [i + 1] erstellt ein eindimensionales Array (eine Zeichenfolge für ein zweidimensionales Array), und ein Verweis auf dieses Array wird in die Variable nums [i] geschrieben. In diesem Fall können nums [i] als Verknüpfung zu einer Zeile mit dem Index i interpretiert werden. Die Bedeutung der Anweisung nums.length wird deutlich, wenn Sie sich daran erinnern, dass ein zweidimensionales Array tatsächlich ein eindimensionales Array ist, dessen Elemente sich auf eindimensionale Arrays beziehen. In diesem Fall gibt nums.length einen Wert für die Anzahl der Elemente in dem Array an, auf die durch die Variable nums verwiesen wird. Dies ist die Anzahl der Zeilen im zweidimensionalen Array.
Als Ergebnis erhalten wir ein zweidimensionales Array eines dreieckigen Typs: In der ersten Zeile des Arrays befindet sich ein Element, in der zweiten zwei Elemente usw. bis zur vierten Zeile des Arrays.
Das erstellte Array wird mit verschachtelten Schleifenoperatoren gefüllt. Die Indexvariable i im externen Schleifenoperator nimmt Werte von 0 bis nums.length-1 an und definiert eine Zeile im zweidimensionalen nums-Array. Für die Indexvariable j wird die Obergrenze des Variationsbereichs durch den Befehl nums [i] .length bestimmt, der die Anzahl der Elemente in der Zeile mit dem Index i zurückgibt (die Variable j ändert sich von 0 zu nums [i] .length-1 einschließlich).
DETAILS Es ist zu beachten, dass nums [i] tatsächlich eine Variable ist, die sich auf ein eindimensionales Array bezieht, das eine Zeichenfolge mit dem Index i bildet. Die Anzahl der Elemente in diesem Array (String) wird durch den Ausdruck nums [i] .length bestimmt.
Der Wert der Array-Elemente wird durch den Befehl nums [i] [j] = val ++ zugewiesen. Das Folgende zeigt, wie das Ergebnis der Programmausführung aussieht:
Das Ergebnis des Programms (aus Listing 3.3)
1 2 3 4 5 6 7 8 9 10
Wie erwartet haben wir ein Array mit einer unterschiedlichen Anzahl von Elementen in verschiedenen Zeilen.
HINWEIS Arrays, deren Dimension mehr als zwei beträgt, werden auf dieselbe Weise erstellt. Wenn Sie eine Variable für ein mehrdimensionales Array deklarieren, werden nach der Typkennung Paare leerer Klammern angezeigt. Die Anzahl solcher Paare wird durch die Dimension des Arrays bestimmt. Im Befehl zum Erstellen eines Arrays wird die Größe jedes Index in separaten eckigen Klammern angegeben.
»Weitere Informationen zum Buch finden Sie auf der Website des Herausgebers
» Inhalt
» Auszug
25% Rabatt auf Gutschein für Händler - Java
Nach Bezahlung der Papierversion des Buches wird ein elektronisches Buch per E-Mail verschickt.