Java Grundlagen – Block3 (Java advanced) – Tag 2 – Arrays und Lists

Ich nehme derzeit an einer Akademie zum Java Fullstack Software Engineer teil. In den kommenden Wochen möchte ich hier meine Mitschrift, so gut es geht, aufzeichnen und mitteilen. Hier ist das, was ich vom zweiten Tag in Block 3 gelernt und behalten habe:

Ein Array[] hat einen vordefinierten Arbeitsspeicher.

Eine Liste<> kann wachsen und ist daher dynamisch

Wir bauen eine neue Zulassungsstelle:

//Stereotyp: Singletone
public class Zulassungsstelle {
// Eigenschaft
private static Zulassungsstelle instance; // static sorgt für eine Klasseneigenschaft -> Einmaligkeit innerhalb der JVM

//Der Konstruktor ist private
private Zulassungsstelle(){
}

//Businesslogik
public synchronized static Zulassungsstelle getInstance() { // static erlaubt, dass wir die Klassenmethode auch ohne new erstellen können
    if (instance == null) {
        instance = new Zulassungsstelle();
    }
    return instance;
}

}

Diese Singleton- Klasse erzeugt ein Objekt, das eine Methode beinhaltet, die das Objekt selber aufruft, und zwar nur dann, wenn sie noch nicht existiert. Dadurch wird es maximal ein einziges Objekt dieser Klasse geben.

Wir fügen nun eine Liste hinzu. Diese kennzeichnet sich mit einem <> aus. Steht zwischen < und > nichts drin, könnte man alle möglichen Daten in die Liste einfügen. Damit wären alle als Objekte hinterlegt:

Java.util.List importiert alles als Objekt.

Da wir diese Ariel-Lego-Tonne (Sammlung von Objekten) nicht wollen, geben den Typ vor. Hier z.B. vom Typ "Auto". Alle anderen Typen  werden rot im Code. Damit garantieren wir, dass nur ein Typ akzeptiert wird.

Arrays, Listen, Hashtables

Siehe auch: https://docs.oracle.com/javase/8/docs/api/index.html?overview-summary.html

https://www.torsten-horn.de/techdocs/java-collections.htm    Torsten Horn

Interfaces legen sich auf Funktionalitäten aber nicht auf Implementierungen fest.

In einen Eierkarton kann man Eier, aber auch "Pelzeier" (Kiwis) oder Tischtennisbälle rein tun.

Im folgenden Beispiel ist "private Map register;" der Eierkarton (also die Funktionalität) und "this.register = new Hashtable();" die Eier (also die Implementierung).

Zulassungsstelle.java sieht jetzt so aus:

package de.firma.aemter;
import de.firma.fahrzeuge.Auto;
import java.util.Hashtable;

import java.util.Map;
//Stereotyp: Singletone

public class Zulassungsstelle {
// Eigenschaft
private static Zulassungsstelle instance; // static sorgt für eine Klasseneigenschaft -> Einmaligkeit innerhalb der JVM
// (payload - Nutzlast)
private Map<Kennzeichen, Auto> register; //Wir deklarieren die Key-Value-Map

//Der Konstruktor ist private
private Zulassungsstelle() {
    this.register = new Hashtable();
}

//Businesslogik
public synchronized static Zulassungsstelle getInstance() { // static erlaubt, dass wir die Klassenmethode auch ohne new erstellen können
    if (instance == null) {
        instance = new Zulassungsstelle();
    }
    return instance;
}

public void anmelden(Auto a) throws AutoBereitsAngemeldetException, BuchstabenException {
    Kennzeichen k;
    if (register.containsValue(a)) {
        throw new AutoBereitsAngemeldetException("Auto existiert schon im Referenzzeiger");
    }
    if (a.getKennzeichen() != null) {
        // Pruefung ob Auto bereits angemaldet (Besserer-Ansastz)
        if (register.containsKey(a.getKennzeichen())) {
            throw new AutoBereitsAngemeldetException("Auto bereits angemeldet");
        }
    }

    do {
        k = new Kennzeichen("WL", "A", ((int) (Math.random() * 9999) + 1), null);
    } while (this.register.containsKey(k)); //Wir prüfen, ob das Kennzeichen schon existiert

    this.register.put(k,a);
    a.setKennzeichen(k);
}

public void abmelden(Auto a) throws KennzeichenNotExists {
    if (register.containsKey(a.getKennzeichen())){
        register.remove(a.getKennzeichen());
    } else {
        throw new KennzeichenNotExists("Kennzeichen existiert nicht");
    }
}

public void registerzeigen(){
    System.out.println("Anzahl der angemeldeten Autos : "+this.register.size());
    for (Auto a: this.register.values()){
        System.out.printf("%10s %s \n" , a.getName(),a.getKennzeichen());
        System.out.printf("%10s %s \n" , a.getName(),a.getKennzeichen().getNummernschild());
    }
}

}

Beispiel mit Hashset und LinkedHashSet

package de.firma;
import java.util.HashSet;

import java.util.LinkedHashSet;

import java.util.Set;
/**

Hello universe!

*/

public class App {

public static void main(String[] args) {

System.out.println("Planeten");
 /* SET -> Menge
 Name:        Merkur   Venus    Erde     Mars     Jupiter  Saturn    Uranus    Neptun     Pluto


*/

Set <String> myset;  //Deklaration einer zugesagten Funktionalität (Eierkarton)

myset = new HashSet<String>();  //Definition Implementierung der Funktionalität (Pelzeier)

myset.add("Merkur");

myset.add("Venus");

myset.add("Erde");

myset.add("Mars");
    for (String name : myset){
        System.out.println("Planet :"+name);
    }
    System.out.println("---------------------");
    System.out.println("myset: "+myset);  //Der Hashset verspricht keine garantierte Sortierung

    myset = new LinkedHashSet&lt;String>();
    myset.add("Merkur");
    myset.add("Venus");
    myset.add("Erde");
    myset.add("Mars");
    for (String name : myset){
        System.out.println("Planet :"+name);
    }
    System.out.println("---------------------");
    System.out.println("myset: "+myset);

}

}

Ergebnis:

Beispiel mit ArrayList

package de.firma;
import de.firma.model.Planet;
import java.util.ArrayList;

import java.util.LinkedList;

import java.util.List;
public class ListApp {

public static void main(String[] args) {

// List -> Menge

List<String> myList; //Deklaration einer zugeagten Funktionalität

myList = new ArrayList<String>(); //Definition Implementierung der Funktionalität

myList.add("Merkur");

myList.add("Venus");

myList.add("Erde");

myList.add("Mars");

myList.add("Merkur"); // Im Gegensatz zur Hashlist, wird hier ein doppeltes Element hinzugefügt.
    for (String name : myList){
        System.out.println("Planet :"+name);
    }

    System.out.println("------------------------");
    System.out.println("myList: "+myList);
    System.out.println("========================================");

    List&lt;Planet> myplanetList;  // Deklaration einer zugesgten Funktionalität
    myplanetList = new LinkedList&lt;Planet>();
    Planet p1 = new Planet ("Merkur", 58,87.969);
    Planet p2 = new Planet ("Venus", 108, 224.701);
    myplanetList.add(p1);
    myplanetList.add(p2);

    for (Planet planet : myplanetList){
        System.out.println("Name: "+planet.getName());
    }
    System.out.println("myplanetlist: "+myplanetList);
    System.out.println("2ter Planet: " + myplanetList.get(1));
}

}

Das Programm liefert folgendes Ergebnis:

Beispiel Hastable (Keylist)

package de.firma;
import de.firma.model.Planet;
import java.util.Collection;

import java.util.Hashtable;

import java.util.Map;

import java.util.Set;
public class MapApp {

public static void main(String[] args) {

// Map -> Tabelle mit zwei Spalten(Key, Value)

Map<String, Planet> mymap; //Deklaration

mymap = new Hashtable<String, Planet>(); //Definiton
    Planet p1 = new Planet ("Merkur", 58,87.969);

    mymap.put("Merkur",p1);
    mymap.put("Venus", new Planet ("Venus",108,224.701));
    mymap.put("Erde", new Planet ("Erde",150,365.256));
    mymap.put("Mars", new Planet ("Mars",228,686.980));

    // Key Liste ausgeben

    Set &lt;String> planetkeys = mymap.keySet();  //Die Daten sind nicht sortiert
    for (String name : planetkeys){
        System.out.println("Name: "+name);
    }
    System.out.println("-----------------------");
    // Key-Liste ausgeben
    Collection &lt;Planet> planetvalue = mymap.values();
    for (Planet planet : planetvalue) {
        System.out.println("Planet: " + planet);
    }
}

}

——————

Disclaimer

Alles was ich mitschrieb und verstanden habe ist ohne Gewähr.

Besten Dank an unseren

Trainer: Hans-Joachim Blanke blanke@4point.de

Mehr dazu im nächsten Blog von mir.

Gruß, Achim Mertens