Irgendwann in unserer Entwicklung als Softwareentwickler werden wir in Situationen geraten, in denen wir viel komplexere Dinge in unseren Programmen tun müssen. In der Regel führt dies zu einer komplexeren Datenverwaltung und einer anderen Organisation von Programmen.

Datenstruktur

Hierfür verfügen wir über die Datenstrukturen , mit denen wir unsere Informationen innerhalb des Programms organisieren können, um auf diese geordnet und schematisiert zugreifen zu können. In Java können wir dank ihrer Standardklassen und -bibliotheken mit verschiedenen Arten von Strukturen umgehen. Wenn wir also lernen, was wir zur Verfügung haben, können wir den notwendigen Nutzen daraus ziehen und so unsere Ziele erreichen.

Strukturieren von Daten mit Arrays

Ein Array ist ein Strukturtyp, der eine lineare Konformation aufweist und eine Datenmenge desselben Typs speichern kann. Die Daten, die Sie speichern können, sind primitive Typen wie int, bool usw. Sie können aber auch Objekttypen speichern, obwohl dies in diesem Fall als Referenz auf das Objekt und nicht auf das Objekt als solches gespeichert wird. Es ist jedoch sehr nützlich, dies zu wissen.

Zugang

Da der Zugriff auf den Inhalt linear ist, muss er sequentiell erfolgen. Obwohl wir direkt auf einen Index verweisen und den Inhalt abrufen können, reagiert die Route, die wir für diese Struktur ausführen können, in den meisten Fällen auf eine Sequenz von Ihre Indizes

Wenn wir einen Index pro Element haben, ist dies ein eindimensionales Array oder ein eindimensionaler Vektor . Wenn wir jedoch mehr als einen Index pro Element haben, sprechen wir von mehrdimensionalen Arrays, dh innerhalb eines Indexes haben wir eine interne Struktur mit eigenen Indizes.

Deklarieren Sie ein Array

Deklarieren Sie ein Array als sehr einfach. Wir müssen nur den Datentyp definieren, der gespeichert werden soll, und die Dimensionen in Klammern angeben. Dann müssen wir den Namen des Arrays definieren und können mit seiner Verwendung beginnen.

Obwohl es mehrere Möglichkeiten gibt, ein Array zu deklarieren, ist die Kurzform die bevorzugte, wie wir unten sehen:

 Typ [] NameArrary = neuer Typ [Länge];

Im Fall eines mehrdimensionalen Arrays können wir dasselbe tun, aber die neuen Ebenen oder Dimensionen in derselben Anweisung hinzufügen, zum Beispiel:

Zweidimensionales Array:

 Typ [] [] NameArrary = neuer Typ [Länge] [Länge];

Dreidimensionales Array:

 Typ [] [] [] NameArrary = neuer Typ [Länge] [Länge] [Länge];

Das Einzige, was wir berücksichtigen müssen, ist, dass die Dinge nach drei Dimensionen viel komplexer werden, aber dies wird unsere Bedürfnisse zum Zeitpunkt der Entwicklung des Programms bestimmen.

Gehen Sie ein Array durch

Um ein Array zu durchlaufen, müssen wir einige der verfügbaren iterativen Zyklen verwenden, wobei es sich um den Zyklus für einen der bevorzugten handelt, da wir die Größe des Arrays angeben und jedes seiner Elemente durchgehen können.

Wir müssen berücksichtigen, dass die Indizes der Arrays bei Null beginnen. In einem Array mit drei Elementen wären die Indizes also [0], [1], [2]. Dies muss berücksichtigt werden, da dies nicht der Fall ist Ein traditioneller Bericht kann zu Verwirrung führen.

Ein allgemeines Beispiel für das Durchlaufen eines Arrays sieht folgendermaßen aus:

 für (int i = 0; i <LogitudeArray; i ++) { System.out.println (ourArray [i]); }

Genauso wie wir in diesem kleinen Beispiel den Inhalt des entsprechenden Index im Siebdruck gedruckt haben, können wir mit dem Array auch sequentielle Zuweisungen und andere Operationen durchführen. Im Fall eines mehrdimensionalen Arrays müssen wir für jede der Dimensionen einen Zyklus erstellen. Deshalb sprechen wir darüber, dass ein Array nach mehr als drei Dimensionen sehr komplex wird.

Ein Funktionsbeispiel

Wir werden einen kleinen Code erstellen, in dem wir ein Array definieren, dann werden wir eine Tour durch seine Elemente machen und sie auf dem Bildschirm anzeigen. Mal sehen, wie unser Code aussieht:

 public class ExampleArray1 { public static void main (String [] argv) { int [] ourArray = new int [12]; für (int i = 0; i <12; i ++) { ourArray [i] = i + 1; System.out.println ("Der Inhalt des Arrays in: [" + i + "] ist:" + ourArray [i]); } System.out.println ("Die Gesamtlänge des Arrays beträgt:" + ourArray.length); } }

In diesem Programm definieren wir nach der Definition unserer Klasse und der Hauptmethode zunächst ein Array vom Typ int mit dem Namen ourArray , dem wir eine Länge von 12 Elementen zuweisen. Anschließend weisen wir einen for-Zyklus von 0 bis 11 zu Wenn wir jedem der Indizes des Arrays einen Wert zuweisen, geben wir den Wert sofort aus und schließlich verwenden wir die Eigenschaft length des Arrays, mit der wir die Gesamtlänge ermitteln und gleich ausgeben können.

Wenn wir dies in unserer Konsole sehen, während wir das Programm ausführen, erhalten wir Folgendes:

Wie wir sehen, erhalten wir für jedes Element des Arrays eine Zeile und eine letzte Zeile, die die tatsächliche Größe des Arrays angibt. Wenn wir von 0 bis 11 zählen, haben wir 12 Elemente. Dies zeigt also, was wir über das Indexkonto erklären des Arrays.

Sammlungen

Die Verwendung von Arrays ist sehr populär und sehr nützlich, aber es gibt Zeiten, in denen sie ihre Grenzen erkennen, insbesondere wenn wir mit sehr dynamischen Strukturen arbeiten, bei denen wir nicht wissen, wie viele Elemente wir am Ende haben werden und wo wir außer ein wenig mehr Funktionalität benötigen Iterationen, um seine Elemente zu durchlaufen.

Wenn wir uns in der Notwendigkeit sehen, komplexer mit den Daten umzugehen, können wir zu den Sammlungen gehen , die nicht mehr als eine Menge von Klassen sind, die in der Java- Standardbibliothek java.util gruppiert sind und die es uns ermöglichen, andere Arten von Strukturen zu erstellen von Daten.

In diesem Fall werden wir die ArrayList- Klasse ein wenig untersuchen, wodurch wir Listen von Arrays erstellen können, wie es der Name angibt, aber um ihre Elemente zu manipulieren, müssen wir dies mit den verschiedenen Methoden tun.

In ArrayList verfügbare Methoden

Nachfolgend finden Sie eine kleine Liste der verfügbaren Methoden der wichtigsten ArrayList- Klasse, und möglicherweise müssen Sie unsere Programme erstellen. Wenn Sie zusätzliche Informationen benötigen, können Sie immer auf die offizielle Dokumentation der Sprache zurückgreifen.

add ()

Mit dieser Methode können wir der Liste entweder am Ende oder an einer bestimmten Position ein Element hinzufügen, dies wird bei der Übergabe der Parameter festgelegt.

klar ()

Bereinigt die Struktur, indem alle darin enthaltenen Elemente gelöscht oder geleert werden.

get ()

Es gibt den Wert des angegebenen Index der betreffenden Liste zurück.

entfernen ()

Mit dieser Methode können wir ein bestimmtes Element aus der Datenstruktur entfernen.

toArray ()

Mit dieser Methode können wir den Inhalt der Liste oder Datenstruktur in ein Array konvertieren.

Deklarieren Sie eine Liste

Um eine Liste mit ArrayList zu deklarieren, erstellen wir einfach eine Instanz dieser Klasse. Damit können wir mit der Zuordnung von Elementen und Inhalten beginnen. Dafür sehen wir die folgende Syntax:

 ArrayList <String> ourList = new ArrayList <> ();

Obwohl wir auch eine Anweisung und gleichzeitige Zuweisung von Elementen verwenden können, wie in der folgenden Codezeile dargestellt:

 List <String> ourList = Arrays.asList ("Pedro", "Juan", "Manuel");

Blättern Sie durch eine Liste

Die Route unserer Liste können wir mit einem iterativen Zyklus mit for () erreichen , den wir in den Arrays gesehen haben. Der Unterschied besteht darin, dass wir, da wir die Anzahl der Elemente in unseren Listen nicht genau kennen, die Grenze mit der Größenmethode definieren müssen ( ) desselben und um den Inhalt in einem gegebenen Index zu erhalten, verwenden wir die Methode get (). Ein Beispiel für die Syntax für diese Route könnte sein:

 für (int i = 0; i <ourList .size (); i ++) { System.out.println (ourList.get (i)); }

Praktisches Beispiel

Wir werden jetzt ein kleines Programm erstellen, in dem wir das, was wir über ArrayList gesehen haben, in die Praxis umsetzen und auf diese Weise ein Lernen über diese Datenstruktur spezifizieren:

 import java.util.ArrayList; public class ExampleList1 { public static void main (String [] argv) { ArrayList <String> ourList = new ArrayList <> (); ourList.add ("Peter"); ourList.add ("Juan"); ourList.add ("Francisco"); ourList.add ("Manolo"); ourLista.add ("Pablo"); für (int i = 0; i <ourList.size (); i ++) { System.out.println ("Der Inhalt unserer Liste in: [" + i + "] ist:" + ourList.get (i)); } System.out.println ("Die Gesamtlänge unserer Liste ist:" + ourList.size ()); } }

In diesem Code sehen wir, dass wir als erstes die ArrayList- Klasse aus dem java.util- Paket importieren. Andernfalls können wir sie nicht verwenden.

Dann haben wir eine neue Liste von Elementen vom Typ String definiert . Dann werden wir die Liste mit der Methode add () bekannt machen. Da wir keine Begrenzung für die Anzahl der Elemente festgelegt haben, wächst diese Liste dynamisch, wenn wir Elemente hinzufügen.

Schließlich gehen wir mit einem for () -Zyklus und der size () -Methode unseres Listenobjekts seine Elemente durch und ermitteln den Wert jeder Position mit der get () -Methode, mit der wir dann den Inhalt drucken können. Mal sehen, wie es aussieht, wenn wir es auf unserer Konsole ausführen:

Nachdem wir dieses Tutorial beendet haben, haben wir bereits gelernt, Datenstrukturen in Java zu erstellen und damit zu arbeiten. Auf diese Weise können wir komplexere Anwendungen und Programme erstellen, die unseren Anforderungen entsprechen.

Arbeiten mit Datenstrukturen in Java