Einführung

Hallo. Ich bin Wataku, ein serverseitiger Programmierer, der an einer bestimmten Schule Programmieren studiert. : entspannt:

Dieses Mal habe ich das Sammlungsframework in Java zusammengefasst. Da es für mich persönlich ein kompliziertes Feld war, fasse ich es auch für das Studium zusammen. Wenn Sie also Vorschläge wie Fehler haben, kommentieren Sie diese bitte.

Lass uns gehen.

Was ist eine Sammlung?

Erstens können Sie sich eine Sammlung als ein Array vorstellen, das eine große Anzahl von Werten gleichzeitig bearbeiten kann, obwohl die Größe nicht festgelegt ist.

Da die Größe nicht festgelegt ist, können Sie so viele Daten speichern, wie Sie benötigen.

Was ist ein Sammlungsrahmen?

Abhängig von der Anwendung gibt es drei Haupttypen in der Sammlung, wie unten gezeigt.

** Liste ** In der richtigen Reihenfolge gespeichert
** Set ** Nicht unbedingt in der richtigen Reihenfolge gespeichert
** Karte ** paarweise gespeichert

Das ** Collection Framework ** ist so konzipiert, dass es mit solchen Typen flexibel gehandhabt werden kann.

Was ist eine Sammlungsklasse?

"List", "Set" und "Map" werden als Schnittstellen bereitgestellt. * * Verwenden Sie bei der tatsächlichen Verwendung eine Klasse, die diese Schnittstellen implementiert. Eine Klasse, die die Schnittstelle des Auflistungsframeworks implementiert, wird als ** Auflistungsklasse ** bezeichnet. List --Listen haben sehr ähnliche Funktionen wie Arrays.

Eine geordnete Sammlung, die doppelte Elemente enthalten kann.
Mit dem Index können Sie die Position, an der Elemente eingefügt werden oder auf die zugegriffen wird, frei ändern.

Was ist ArrayList?

ArrayList ist eine Auflistungsklasse, die die List-Schnittstelle implementiert. * *

Wie der Name "Array" andeutet, kann es wie ein Array behandelt werden.

Übrigens gibt es andere Klassen wie ** LinkedList ** und ** Stack **, die List implementieren, aber ich werde sie hier nicht vorstellen. Ich würde gerne schreiben, wenn es eine andere Gelegenheit gibt.

Deklaration / Initialisierung

ArrayList<Schimmel>Variablennamen= new ArrayList<Schimmel>();

Am Ende der Klasse befindet sich ein Teil, der den Typ angibt, der von ** "<" ** und ** ">" ** umgeben ist. Obwohl es sich um eine ungewohnte Schreibweise handelt, wird sie als ** Generics-Funktion ** bezeichnet, die neu aus J2SE 5.0 eingeführt wurde, und gibt an, welcher Werttyp in dieser ArrayList gespeichert ist. Generics Geben Sie den Klassennamen für diesen Typ an. Und der Wert, der als Element gespeichert werden kann, ist das Objekt der hier angegebenen Klasse. Bitte beachten Sie, dass String in Ordnung ist, int und float jedoch nicht angegeben werden können. Dies liegt daran, dass String eine String-Klasse ist, int und float jedoch keine Klassen, sondern Basistypen sind.

Wenn Sie also Basistypen wie int type und float type verarbeiten möchten, wird die Klasse ** (Wrapper-Klasse) ** für jeden Basistyp vorbereitet. Verwenden Sie sie daher.

Entsprechende Klasse	Grundtyp
Boolean	boolean
Character	char
Byte	byte
Short	short
Integer	int
Long	long
Float	float
Doubule	double

Um beispielsweise eine ArrayList zu erstellen, in der Ganzzahlen gespeichert sind, und eine ArrayList, in der Zeichenfolgen gespeichert sind, sieht dies wie folgt aus.

ArrayList<Integer> array = new ArrayList<Integer>();
ArrayList<String> array = new ArrayList<String>();

Methode

Daten einfügen

add(Wert)

** add (Index, Wert) ** ermöglicht es Ihnen, einen Wert in den angegebenen Index einzufügen. --Datenabruf

get(Index)

Abrufen der Anzahl der Elemente (Länge)

size()

Ob es leer ist

isEmpty()

Ob der Wert enthalten ist

contains(Wert)

In welchem Index sich der Wert befindet

indexOf(Wert)

Den angegebenen Index löschen

remove(Index)

Set

Verwalten von Daten mit Duplikaten entfernt.
Sie können ** nicht bekommen () **, weil der Index den Wert nicht verwaltet → Schleife, um die Daten anzuzeigen
Die Schnittstelle ** SortedSet ** sortiert den Inhalt des Sets. Die Implementierungsklasse ist ** TreeSet **

Liste, Set-Schleife

Verwenden Sie die ** Italator ** -Schnittstelle.

<Hauptmethode>
· Nächster():Holen Sie sich den folgenden Wert
・ HasNext():Gibt es den folgenden Wert?

for(Iterator ite = stock.itarator; ite.hasNext;) {
     //ite.Spiel mit dem nächsten
}

Beispielcode

①List



import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class UseList {

	public static void main(String[] args) {
		//TODO automatisch generierter Methodenstub
		List<Integer> store = new ArrayList<>();

		System.out.println("Vor der Registrierung: Die Gesamtzahl der Elemente" + store.size() + "Das ist es.");
		System.out.println("Ist die Liste derzeit leer?" + store.isEmpty());

		store.add(54);
		store.add(24);
		store.add(47);
		store.add(0);
		store.add(6);
		store.add(24);
		store.add(85);
		store.add(1);
		store.add(5);
		store.add(6);
		store.add(98);
		store.add(47);
		store.add(54);
		store.add(96);
		store.add(9);

		System.out.println("Vor der Registrierung: Die Gesamtzahl der Elemente" + store.size() + "Das ist es.");
		System.out.println("Ist die Liste derzeit leer?" + store.isEmpty());

		System.out.println("Der Wert von Index 8 ist" + store.get(8) + "ist.");
		System.out.println("Ist der Wert 1 enthalten?" + store.contains(1));
		System.out.println("Was ist der Index von Wert 1?" + store.indexOf(1));

		System.out.println("-------------Werfen wir einen Blick auf den Inhalt--------------");
		for(Iterator<Integer> ite = store.iterator(); ite.hasNext();) {
			Integer element = ite.next();
			System.out.println(element);
		}
		System.out.println("Beachten Sie, dass einige Werte dupliziert werden");

		store.remove(8);

		System.out.println("Nach dem Löschen: Alle Elemente" + store.size() + "Das ist es.");
		System.out.println("-------------Schauen wir uns den Inhalt noch einmal an--------------");
		for(Integer element : store) {
			System.out.println(element);
		}

		store.add(12, 346);
		System.out.println("Nach der Registrierung: Alle Elemente" + store.size() + "Das ist es.");
		System.out.println("-------------Schauen wir uns den Inhalt noch einmal an--------------");
		for(Integer element : store) {
			System.out.println(element);
		}
	}

}

Ergebnis

Vor der Registrierung: Die Gesamtzahl der Elemente beträgt 0.
Ist die Liste derzeit leer? wahr
Vor der Registrierung: Die Gesamtzahl der Elemente beträgt 15.
Ist die Liste derzeit leer? falsch falsch
Der Wert von Index 8 ist 5.
Ist der Wert 1 enthalten? wahr
Was ist der Index von Wert 1? 7
-------------Werfen wir einen Blick auf den Inhalt--------------
54
24
47
0
6
24
85
1
5
6
98
47
54
96
9
Beachten Sie, dass einige Werte dupliziert werden
Nach dem Löschen: Insgesamt gibt es 14 Elemente.
-------------Schauen wir uns den Inhalt noch einmal an--------------
54
24
47
0
6
24
85
1
6
98
47
54
96
9
Nach der Registrierung: Insgesamt gibt es 15 Elemente.
-------------Schauen wir uns den Inhalt noch einmal an--------------
54
24
47
0
6
24
85
1
6
98
47
54
346
96
9

②Set


import java.util.HashSet;
import java.util.Set;
public class UseSet {

	public static void main(String[] args) {
		//TODO automatisch generierter Methodenstub
		Set<Integer> store = new HashSet<>();
		
		store.add(54);
		store.add(24);
		store.add(47);
		store.add(0);
		store.add(6);
		store.add(24);
		store.add(85);
		store.add(1);
		store.add(5);
		store.add(6);
		store.add(98);
		store.add(47);
		store.add(54);
		store.add(96);
		store.add(9);
		
		System.out.println("Die Anzahl der Elemente beträgt" + store.size() + "Das ist es.");
		System.out.println("-------------Werfen wir einen Blick auf den Inhalt--------------");
		for(Integer element : store) {
			System.out.println(element);
		}
	}

}

Ergebnis

Die Anzahl der Elemente beträgt 11.
-------------Werfen wir einen Blick auf den Inhalt--------------
0
96
1
98
85
5
54
6
24
9
47

Map

Assoziatives Array
Geben Sie sowohl Schlüssel als auch Wert als Typ an, wenn er neu ist (Generika).


Map<string, Integer> maps new HashMap<>();

Kartenspezifische Methode

Datenregistrierung

put(Schlüssel,Wert)

Ist es im Schlüssel enthalten?

containsKey(Schlüssel)

Ist es im Wert enthalten?

containsValue(Wert)

Den angegebenen Schlüssel löschen

remove(Schlüssel)

Kartenschleife

(Hinweis) Die Karte kann nicht so wie sie ist geloopt werden. Schleifen Sie daher das mit "entitySet" ausgeschnittene Set-Objekt.

Set entity = maps.entitySet();
for(Iterator ite = entity.itarator; ite.hasNext;) {
     //ite.Spiel mit dem nächsten
}

Unterschiedliche Verwendung von 3 Kartentypen

** HashMap **: Wenn Sie Werte vorerst mit Map verwalten möchten
** TreeMap **: Wenn Sie nach Schlüssel sortieren möchten
** LinkedHashMap **: Wenn Sie die Put-Reihenfolge beibehalten möchten

Map + Entity Erstellen Sie auch in Java eine Entitätsklasse und verwenden Sie den Map-Schlüssel als DB-Primärschlüssel. * O-R-Zuordnung * kann durch Speichern der "neuen" Entität im Wert erfolgen.

Beispielcode

①



import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class UseMap {
	public static void main(String[] args) {

		HashMap<Integer, String> map = new HashMap<>();

		System.out.println("Die aktuelle Anzahl der Elemente ist" + map.size() + "Das ist");
		System.out.println("Ist die Karte leer?" + map.isEmpty());

		map.put(1, "Tanibe");
		map.put(3, "Kuroi");
		map.put(5, "Kaneko");
		map.put(7, "Inoue");
		map.put(11, "Yamamoto");
		map.put(13, "Nakamura");
		map.put(15, "Mit Morgen");
		map.put(17, "Nakajima");
		map.put(19, "Takeda");
		map.put(21, "Kimoto");
		map.put(25, "Saito");
		map.put(27, "Asuka");
		map.put(29, "Hoshino");

		System.out.println("Die aktuelle Anzahl der Elemente ist" + map.size() + "Das ist");
		System.out.println("Ist die Karte leer?" + map.isEmpty());
		System.out.println("--------------------Werfen wir einen Blick auf den Inhalt(Iterator-Version)------------------------");
		Set<Map.Entry<Integer, String>> entries = map.entrySet();
		for(Iterator<Map.Entry<Integer, String>> ite = entries.iterator(); ite.hasNext();) {
			Map.Entry<Integer, String> element = ite.next();
			Integer key = element.getKey();
			String value = element.getValue();
			System.out.println("key=" +key + ":value=" + value);
		}

		System.out.println("--------------------Werfen wir einen Blick auf den Inhalt(Praktische Version)------------------------");
		for(Map.Entry<Integer, String> element : map.entrySet()) {
			Integer key = element.getKey();
			String value = element.getValue();
			System.out.println("key=" +key + ":value=" + value);
		}

		System.out.println("ich" + map.get(25) + "ist");
		System.out.println("Hast du No22?" + map.containsKey(22));
		System.out.println("Haben Sie Herrn Tanaka? ::" + map.containsValue("Tanaka"));

		String name = map.put(9, "Nakayama");
		System.out.println(name + "Überschrieben");
		for(Map.Entry<Integer, String> element : map.entrySet()) {
			System.out.println(element);
		}

		name = map.remove(25);
		System.out.println(name + "Wurde getötet");
		for(Map.Entry<Integer, String> element : map.entrySet()) {
			System.out.println(element);
		}

		Set<Integer> keySet = map.keySet();
		for(Integer integer : keySet) {
			System.out.println(integer);
		}

		Collection<String> values = map.values();
		for(String eachName : values) {
			System.out.println(eachName);
		}
	}
}

Ergebnis

Die aktuelle Anzahl der Elemente ist 0
Ist die Karte leer? wahr
Die aktuelle Anzahl der Elemente beträgt 13
Ist die Karte leer? falsch falsch
--------------------Werfen wir einen Blick auf den Inhalt(Iterator-Version)------------------------
key=1:value=Tanibe
key=3:value=Kuroi
key=5:value=Kaneko
key=7:value=Inoue
key=11:value=Yamamoto
key=13:value=Nakamura
key=15:value=Mit Morgen
key=17:value=Nakajima
key=19:value=Takeda
key=21:value=Kimoto
key=25:value=Saito
key=27:value=Asuka
key=29:value=Hoshino
--------------------Werfen wir einen Blick auf den Inhalt(Praktische Version)------------------------
key=1:value=Tanibe
key=3:value=Kuroi
key=5:value=Kaneko
key=7:value=Inoue
key=11:value=Yamamoto
key=13:value=Nakamura
key=15:value=Mit Morgen
key=17:value=Nakajima
key=19:value=Takeda
key=21:value=Kimoto
key=25:value=Saito
key=27:value=Asuka
key=29:value=Hoshino
Ich bin Saito
Hast du No22? falsch falsch
Haben Sie Herrn Tanaka? : Falsch
Null überschrieben
1=Tanibe
3=Kuroi
5=Kaneko
7=Inoue
9=Nakayama
11=Yamamoto
13=Nakamura
15=Mit Morgen
17=Nakajima
19=Takeda
21=Kimoto
25=Saito
27=Asuka
29=Hoshino
Ich habe Mr. Saito getötet
1=Tanibe
3=Kuroi
5=Kaneko
7=Inoue
9=Nakayama
11=Yamamoto
13=Nakamura
15=Mit Morgen
17=Nakajima
19=Takeda
21=Kimoto
27=Asuka
29=Hoshino
1
3
5
7
9
11
13
15
17
19
21
27
29
Tanibe
Kuroi
Kaneko
Inoue
Nakayama
Yamamoto
Nakamura
Mit Morgen
Nakajima
Takeda
Kimoto
Asuka
Hoshino

②


import java.util.HashMap;
import java.util.Map;
public class UseMapAndEntity {

	public static void main(String[] args) {
		//TODO automatisch generierter Methodenstub
		Map<Integer, PersonalData> stock = new HashMap<>();

		PersonalData taro = new PersonalData(46887, "Taro", 72.8, 167.3, 23, 1);
		PersonalData jiro = new PersonalData(12547, "Jiro", 57.7, 170.4, 28, 1);
		PersonalData hanako = new PersonalData(63544, "Hanako", 53.1, 155.4, 19, 0);
		PersonalData keisuke = new PersonalData(34544, "Keisukr", 98.4, 192.4, 35, 1);

		stock.put(46887, taro);
		stock.put(12457, jiro);
		stock.put(63544,hanako);
		stock.put(34544, keisuke);

		System.out.println("Das Element ist" + stock.size() + "Das ist");

		System.out.println("--------------Werfen wir einen Blick auf den Inhalt---------");
		for(Map.Entry<Integer, PersonalData> element :stock.entrySet()) {
			Integer key = element.getKey();
			PersonalData person = element.getValue();

			StringBuffer  sbCurry = new StringBuffer();
			sbCurry.append("Mitgliedsnummer");
			sbCurry.append(key);
			sbCurry.append("Person von:");
			sbCurry.append("Name =");
			sbCurry.append(person.getName());
			sbCurry.append(";");
			sbCurry.append("Höhe =");
			sbCurry.append(person.getHeight());
			sbCurry.append("cm;");
			sbCurry.append("Gewicht =");
			sbCurry.append(person.getWeight());
			sbCurry.append("kg");
			System.out.println(sbCurry.toString());

		}
	}

}


public class PersonalData {
	private Integer _id;
	private String _name;
	private Double _weight;
	private Double _height;
	private Integer _age;
	private Integer _sex;

	//Konstrukteur
	public PersonalData (Integer id, String name, Double weight, Double height, Integer age, Integer sex) {
		_id = id;
		_name = name;
		_weight = weight;
		_height = height;
		_age = age;
		_sex = sex;
	}

	//Accessor-Methode
	public Integer getId() {
		return _id;
	}
	public void setId(Integer id) {
		_id = id;
	}

	public String getName() {
		return _name;
	}
	public void setName(String name) {
		_name = name;
	}

	public Double getWeight() {
		return _weight;
	}
	public void setWeight(Double weight) {
		_weight = weight;
	}

	public Double getHeight() {
		return _height;
	}
	public void setHeight(Double height) {
		_height = height;
	}

	public Integer getAge() {
		return _age;
	}
	public void setAge(Integer age) {
		_age = age;
	}

	public Integer getSex() {
		return _sex;
	}
	public void setSex(Integer sex) {
		_sex = sex;
	}
}

Ergebnis

Es gibt 4 Elemente
--------------Werfen wir einen Blick auf den Inhalt---------
Person mit Mitgliedsnummer 34544:Name = Keisukr;Höhe = 192.4cm;Gewicht = 98.4kg
Person mit Mitgliedsnummer 46887:Name = Taro;Höhe = 167.3cm;Gewicht = 72.8kg
Person mit Mitgliedsnummer 63544:Name = Hanako;Höhe = 155.4cm;Gewicht = 53.1kg
Person mit Mitgliedsnummer 12457:Name = Jiro;Höhe = 170.4cm;Gewicht = 57.7kg

das ist alles. Wenn Sie Vorschläge wie etwas falsches haben, kontaktieren Sie uns bitte. Vielen Dank für das Lesen bis zum Ende.

[JAVA] Ich habe den Sammlungsrahmen zusammengefasst.

Einführung

Was ist eine Sammlung?

Was ist ein Sammlungsrahmen?

Was ist eine Sammlungsklasse?

Was ist ArrayList?

Deklaration / Initialisierung

Methode

Liste, Set-Schleife

Beispielcode

Kartenspezifische Methode

Kartenschleife

Unterschiedliche Verwendung von 3 Kartentypen

Beispielcode