diff --git a/Programmierung2/src/Algorithmus/Allgemeine_Übungen.java b/Programmierung2/src/Algorithmus/Allgemeine_Übungen.java index 7752d6c..ac6ff49 100644 --- a/Programmierung2/src/Algorithmus/Allgemeine_Übungen.java +++ b/Programmierung2/src/Algorithmus/Allgemeine_Übungen.java @@ -3,7 +3,7 @@ package Algorithmus; import java.util.Arrays; import java.util.stream.Stream; -public class Allgemeine_Übungen { +public class Allgemeine_Übungen extends Thread { public static void main(String[] args) { // int [] nums = {3, 4, -7, 3, 1, 3, 1, -4, -2, -2}; diff --git a/Programmierung2/src/Algorithmus/ConcurrentModificationsException.java b/Programmierung2/src/Algorithmus/ConcurrentModificationsException.java new file mode 100644 index 0000000..3a4f65e --- /dev/null +++ b/Programmierung2/src/Algorithmus/ConcurrentModificationsException.java @@ -0,0 +1,24 @@ +package Algorithmus; + +import java.util.ArrayList; + +public class ConcurrentModificationsException { + + public static void main(String[] args) { + ArrayList al = new ArrayList<>(); + al.add("A"); + al.add("B"); + al.add("C"); + al.add("D"); + + for (int i = 0; i < al.size(); i++) { + + if (al.get(i).equals("A")) { + al.remove(i); + } + } + + } + +} + diff --git a/Programmierung2/src/Algorithmus/Person.java b/Programmierung2/src/Algorithmus/Person.java new file mode 100644 index 0000000..26d53ec --- /dev/null +++ b/Programmierung2/src/Algorithmus/Person.java @@ -0,0 +1,30 @@ +package Algorithmus; + +import java.util.*; + +public class Person { + String name; + int alter; + + Person(String name, int alter) { + this.name = name; + this.alter = alter; + } + + public static void main(String[] args) { + + Person[] arr = { new Person("Anna", 25),new Person("Ben", 30), new Person("Clara", 25),new Person("Daniel", 30)}; + + Map> merker = new HashMap<>(); + + for (int i = 0; i < arr.length; i++) { + int alter = arr[i].alter; + if (!merker.containsKey(alter)) + merker.put(alter, new ArrayList<>()); + + merker.get(alter).add(arr[i].name); + } + System.out.println(merker.toString()); + } + +} diff --git a/Programmierung2/src/Algorithmus/VariadischeFunktionen.java b/Programmierung2/src/Algorithmus/VariadischeFunktionen.java index a26ba6a..e239493 100644 --- a/Programmierung2/src/Algorithmus/VariadischeFunktionen.java +++ b/Programmierung2/src/Algorithmus/VariadischeFunktionen.java @@ -2,7 +2,7 @@ package Algorithmus; public class VariadischeFunktionen { - public static int sum(Integer... numbers) { + public static int sum(int... numbers) { int result = 0; for (int number : numbers) result += number; diff --git a/Programmierung2/src/Algorithmus/WordCount.java b/Programmierung2/src/Algorithmus/WordCount.java new file mode 100644 index 0000000..29b888d --- /dev/null +++ b/Programmierung2/src/Algorithmus/WordCount.java @@ -0,0 +1,45 @@ +package Algorithmus; + +import java.util.*; + +public class WordCount { + + public static void main(String[] args) { + +// String[] arr = { "hallo welt", "hallo omar", "hallo obai" }; +// Map speicher = new HashMap<>(); +// for (int i = 0; i < arr.length; i++) { +// String[] wörter = arr[i].split(" "); +// +// for (int j = 0 ; j < wörter.length; j++) { +// if (!speicher.containsKey(wörter[j])) { +// speicher.put(wörter[j], 1); +// } +// else +// speicher.put(wörter[j], speicher.get(wörter[j]) + 1); // Nur für dieses Wort erhöhen +// +// +// } +// +// } +// +// speicher.forEach((i,j) -> System.out.println(i + " " + j)); + + + int[] zahlen = {5, 10, 15, 20, 25, 30, 35, 4}; + Map> speicher = new HashMap<>(); + + speicher.put(true, new ArrayList<>()); + speicher.put(false, new ArrayList<>()); + + for (int i = 0; i < zahlen.length; i++) { + boolean merker = zahlen[i] % 2 == 0; + speicher.get(merker).add(zahlen[i]); + + } + + System.out.println(speicher.toString()); + } +} + + diff --git a/Programmierung2/src/BinaryTree/Baum.java b/Programmierung2/src/BinaryTree/Baum.java new file mode 100644 index 0000000..47f7001 --- /dev/null +++ b/Programmierung2/src/BinaryTree/Baum.java @@ -0,0 +1,85 @@ +package BinaryTree; + +public class Baum { + private Knoten wurzel; + + public Baum() { + wurzel = null; + + System.out.println("Leerer Baum angelegt."); + } + + public void insert(int neu) { + if (wurzel == null) { + wurzel = new Knoten(neu); + } else if (wurzel != null) { + wurzel.add(neu); + } + } + + public void inorderTraversierung() { + if (wurzel == null) + System.out.println("Baum ist leer."); + else if (wurzel != null) { + System.out.print("Inorder-Reihenfolge: "); + wurzel.inorder(); + } + } + + class Knoten { + private int wert; + private int htb; + private Knoten links, rechts; + + public Knoten(int wert) { + this.wert = wert; + this.links = null; + this.rechts = null; + + this.htb = 0; + + System.out.println(wert + " als Knoten angelegt."); + } + + public void add(int neu) { + if (neu == this.wert) + throw new IllegalArgumentException("Wert darf nicht doppelt gespeichert werden."); + + int htbL = 0; + int htbR = 0; + + if (neu < this.wert) { // nach links schauen + if (links == null) { + links = new Knoten(neu); + } else if (links != null) { + links.add(neu); + } + htbL = links.htb + 1; + this.htb = Math.max(htbL, this.htb); + } else if (neu > this.wert){ // nach rechts schauen + if (rechts == null) { + rechts = new Knoten(neu); + } else if (rechts != null) { + rechts.add(neu); + } + htbR = rechts.htb + 1; + this.htb = Math.max(this.htb, htbR); + } + + // this.htb = Math.max(htbL, htbR); -> Bug, da ein evtl. vorher vorhandener Wert ignoriert wird + System.out.println("Wert: " + this.wert + ", HTB: " + this.htb); + } // end add + + public void inorder() { + if (links != null) + links.inorder(); + + System.out.print(this.wert + " "); + + if (rechts != null) + rechts.inorder(); + } + + } // end Knoten + +} // end Baum \ No newline at end of file diff --git a/Programmierung2/src/Graphen/Graph.java b/Programmierung2/src/Graphen/Graph.java index 2e098a1..e464cdd 100644 --- a/Programmierung2/src/Graphen/Graph.java +++ b/Programmierung2/src/Graphen/Graph.java @@ -1,29 +1,129 @@ -package Graphen; - -import java.util.ArrayList; - -public class Graph { - // Graph hat Viele Knoten - ArrayList KnotenGraph = new ArrayList<>(); - - // füge Knote hinzu - public void addknoten(Knote k) { - - KnotenGraph.add(k); - } - - - - public Knote getKnote(String name) { - for (Knote kAusKnotenGraph: KnotenGraph) { - if (kAusKnotenGraph.getName().equalsIgnoreCase(name)) - return kAusKnotenGraph; - } - return null; - } - - public void printKnotenGraph() { - for (Knote a : KnotenGraph) - System.out.println(a.getName()); - } -} +package Graphen; + +import java.util.*; + +//Generische Graph-Klasse +class Graph { + + // Wir verwenden eine HashMap, um die Kanten im Graphen zu speichern + private Map> kanten = new HashMap<>(); + + // Diese Funktion fügt einen neuen Knoten (Vertex) zum Graphen hinzu + public void knotenHinzufügen(T k) { + kanten.put(k, new LinkedList()); + } + + // Diese Funktion fügt eine Kante zwischen Quelle und Ziel hinzu + public void kanteHinzufügen(T quelle, T ziel, boolean bidirektional) { + + if (!kanten.containsKey(quelle)) + knotenHinzufügen(quelle); + + if (!kanten.containsKey(ziel)) + knotenHinzufügen(ziel); + + kanten.get(quelle).add(ziel); + if (bidirektional) { + kanten.get(ziel).add(quelle); + } + } + + // Diese Funktion gibt die Anzahl der Knoten im Graphen zurück + public void anzahlKnoten() { + System.out.println("Der Graph hat " + kanten.keySet().size() + " Knoten."); + } + + // Diese Funktion gibt die Anzahl der Kanten im Graphen zurück + public void anzahlKanten(boolean bidirektional) { + int anzahl = 0; + for (T k : kanten.keySet()) { + anzahl += kanten.get(k).size(); + } + if (bidirektional) { + anzahl = anzahl / 2; + } + System.out.println("Der Graph hat " + anzahl + " Kanten."); + } + + // Diese Funktion prüft, ob ein bestimmter Knoten vorhanden ist + public void hatKnoten(T k) { + if (kanten.containsKey(k)) { + System.out.println("Der Graph enthält " + k + " als Knoten."); + } else { + System.out.println("Der Graph enthält " + k + " nicht als Knoten."); + } + } + + // Diese Funktion prüft, ob eine Kante zwischen zwei Knoten existiert + public void hatKante(T quelle, T ziel) { + if (kanten.get(quelle).contains(ziel)) { + System.out.println("Der Graph hat eine Kante zwischen " + quelle + " und " + ziel + "."); + } else { + System.out.println("Der Graph hat keine Kante zwischen " + quelle + " und " + ziel + "."); + } + } + + // Diese Funktion gibt die Nachbarn eines Knotens aus + public void nachbarn(T k) { + if (!kanten.containsKey(k)) + return; + System.out.println("Die Nachbarn von " + k + " sind:"); + for (T nachbar : kanten.get(k)) { + System.out.print(nachbar + ", "); + } + } + + // Gibt die Adjazenzliste jedes Knotens aus + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + + for (T k : kanten.keySet()) { + builder.append(k.toString() + ": "); + for (T nachbar : kanten.get(k)) { + builder.append(nachbar.toString() + " "); + } + builder.append("\n"); + } + + return (builder.toString()); + } +} + +//Hauptklasse +class Main { + + public static void main(String[] args) { + + // Objekt des Graphen wird erstellt + Graph graph = new Graph<>(); + + // Kanten werden hinzugefügt. + // Da der Graph bidirektional ist, wird true übergeben + graph.kanteHinzufügen(0, 1, true); + graph.kanteHinzufügen(0, 4, true); + graph.kanteHinzufügen(1, 2, true); + graph.kanteHinzufügen(1, 3, true); + graph.kanteHinzufügen(1, 4, true); + graph.kanteHinzufügen(2, 3, true); + graph.kanteHinzufügen(3, 4, true); + + // Graph ausgeben + System.out.println("Graph:\n" + graph.toString()); + + // Anzahl der Knoten im Graphen + graph.anzahlKnoten(); + + // Anzahl der Kanten im Graphen + graph.anzahlKanten(true); + + // Prüfen, ob eine bestimmte Kante existiert + graph.hatKante(3, 4); + + // Prüfen, ob ein bestimmter Knoten existiert + graph.hatKnoten(5); + + // Nachbarn eines Knotens ausgeben + graph.nachbarn(1); + } +} \ No newline at end of file diff --git a/Programmierung2/src/Graphen/Kanten.java b/Programmierung2/src/Graphen/Kanten.java index 6561065..71ac23b 100644 --- a/Programmierung2/src/Graphen/Kanten.java +++ b/Programmierung2/src/Graphen/Kanten.java @@ -1,61 +1,34 @@ -package Graphen; - -public class Kanten { - // jede Kante verbindet zwei Knoten - private Knote anfangsKnote; - private Knote endeKnote; - private boolean UndirectedGraph; - private int gewicht; - - // Kante verbindet zwei Knoten (Undirected Graph) - public Kanten(Knote anfangsKnote, Knote endeKnote, boolean UndirectedGraph) { - this.anfangsKnote = anfangsKnote; - this.endeKnote = endeKnote; - this.UndirectedGraph = UndirectedGraph; - anfangsKnote.addKante(this); //speichert dann zu ihrem ArrayList diese Kante - endeKnote.addKante(this);//speichert dann auch zu ihrem ArrayList diese gleiche Kante - } - - // Kante verbindet eine Knote (Directed Graph) - public Kanten(Knote anfangsKnote, Knote endeKnote) { - this.anfangsKnote = anfangsKnote; - this.endeKnote = endeKnote; - anfangsKnote.addKante(this); - } - - // Kante verbindet eine Knoten und mit Gewicht (Weighted Directed Graph) - public Kanten(Knote anfangsKnote, Knote endeKnote, int gewicht) { - this.anfangsKnote = anfangsKnote; - this.endeKnote = endeKnote; - //anfangsKnote.addkanteMitGewicht(this,gewicht); - } - - // Kante verbindet zwei Knoten und mit Gewicht (Weighted UnDirected Graph) - public Kanten(Knote anfangsKnote, Knote endeKnote, int gewicht, boolean UndirectedGraph) { - this.anfangsKnote = anfangsKnote; - this.endeKnote = endeKnote; -// anfangsKnote.addkanteMitGewicht(this, gewicht); -// endeKnote.addkanteMitGewicht(this, gewicht); - this.UndirectedGraph = UndirectedGraph; - } - - public Knote getPartner(Knote k) { - return (k == anfangsKnote) ? endeKnote : anfangsKnote; - } - - public int getGewicht() { - return gewicht; - } - - public Knote getAnfangsKnote() { - return anfangsKnote; - } - - public Knote getEndeKnote() { - return endeKnote; - } - - - - -} +package Graphen; + +public class Kanten { + // jede Kante verbindet zwei Knoten + private Knoten anfangsKnote; + private Knoten endeKnote; + private T gewicht; + + + public Kanten(Knoten anfangsKnote, Knoten endeKnote, T gewicht) { + this.anfangsKnote = anfangsKnote; + this.endeKnote = endeKnote; + this.anfangsKnote.addKante(this); + this.endeKnote.addKante(this); + this.gewicht = gewicht; + } + + + + public Knoten getPartner(Knoten k) { + if (k == anfangsKnote) + return endeKnote; + else + return anfangsKnote; + } + + public T getGewicht() { + return gewicht; + } + + + + +} diff --git a/Programmierung2/src/Graphen/Knote.java b/Programmierung2/src/Graphen/Knote.java deleted file mode 100644 index 1c99b2d..0000000 --- a/Programmierung2/src/Graphen/Knote.java +++ /dev/null @@ -1,44 +0,0 @@ -package Graphen; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Map; - -public class Knote { - private String name; - private ArrayList kantenList = new ArrayList<>(); - - - Knote(String name){ - this.name = name; - } - - //add kante zu this (knote) - public void addKante(Kanten k) { - kantenList.add(k); - } - - - public String getName() { - return name; - } - - - public ArrayList getKantenList() { - return kantenList; - } - - public void getPartner() { - ArrayList merker = getKantenList(); - if (merker == null) - return ; - - ArrayList verbindeteKnoten = new ArrayList<>(); - for (Kanten m : merker) - verbindeteKnoten.add(m.getPartner(this)); - - for (Knote k: verbindeteKnoten) - System.out.println(this.name + " verbindet mit " + k.getName()); - } - -} diff --git a/Programmierung2/src/Graphen/Knoten.java b/Programmierung2/src/Graphen/Knoten.java new file mode 100644 index 0000000..85e5acb --- /dev/null +++ b/Programmierung2/src/Graphen/Knoten.java @@ -0,0 +1,48 @@ +package Graphen; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + +public class Knoten { + private T id; + private ArrayList kantenList; + + Knoten(T id) { + this.id = id; + this.kantenList = new ArrayList<>(); + } + + // add kante zu this (knote) + public void addKante(Kanten k) { + kantenList.add(k); + } + + public T getId() { + return id; + } + + // Grad ist die Anzahl der Kanten an einem Knoten + public int getGrad() { + return kantenList.size(); + } + + public ArrayList getKantenList() { + return kantenList; + } + + public void getPartner() { + if (kantenList == null) + return; + + ArrayList> verbindeteKnoten = new ArrayList<>(); + for (Kanten m : kantenList) + verbindeteKnoten.add(m.getPartner(this)); + } + + @Override + public String toString() { + return this.id + " "; + } + +} diff --git a/Programmierung2/src/Graphen/Test.java b/Programmierung2/src/Graphen/Test.java index ffc6faa..00c0e0a 100644 --- a/Programmierung2/src/Graphen/Test.java +++ b/Programmierung2/src/Graphen/Test.java @@ -1,29 +1,9 @@ -package Graphen; - -public class Test { - - public static void main(String[] args) { - Graph graph = new Graph(); - - Knote mannheim = new Knote("Mannheim"); - Knote heidelberg = new Knote("Heidelberg"); - Knote frankfourt = new Knote("Frankfourt"); - Knote Maiz = new Knote("Maiz"); - graph.addknoten(mannheim); - graph.addknoten(heidelberg); - graph.addknoten(frankfourt); - graph.addknoten(Maiz); - - new Kanten(graph.getKnote("Mannheim"),graph.getKnote("Heidelberg")); - new Kanten(graph.getKnote("Mannheim"),graph.getKnote("Frankfourt")); - - - mannheim.getPartner(); - heidelberg.getPartner(); - frankfourt.getPartner(); - - Kanten k3 = new Kanten(graph.getKnote("Heidelberg"),graph.getKnote("Maiz"),25,true); - - } - -} +package Graphen; + +public class Test { + + public static void main(String[] args) { + + } + +} diff --git a/Programmierung2/src/Klausur/Firma.java b/Programmierung2/src/Klausur/Firma.java new file mode 100644 index 0000000..78958fc --- /dev/null +++ b/Programmierung2/src/Klausur/Firma.java @@ -0,0 +1,55 @@ +package Klausur; + +public class Firma { + + public static void main(String[] args) { + + Mitarbeiter mi2 = new Mitarbeiter("Mayer", "12.12.1999"); + ((Manager)mi2).getAbteilung(); + } +} + +class Mitarbeiter extends Object { + private String name; + private double gehalt; + private String geburtsdatum; + + public Mitarbeiter(String name, String geburtsdatum) { + this(name, 35000, geburtsdatum); + } + + public Mitarbeiter(String name, double gehalt, String geburtsdatum) { + this.name = name; + this.gehalt = gehalt; + this.geburtsdatum = geburtsdatum; + } + + public String getDetails() { + return name; + } + + public double getGehalt() { + return gehalt; + } + + public void setGehalt(double gehalt) { + this.gehalt = gehalt; + } +} + +class Manager extends Mitarbeiter { + private String abteilung; + + public Manager(String name, String geburtsdatum, String abteilung) { + super(name, 65000, geburtsdatum); // das MUSS zuerst gemacht werden! + this.abteilung = abteilung; + } + + public String getDetails() { + return super.getDetails() + " " + abteilung; + } + + public String getAbteilung() { + return abteilung; + } +} diff --git a/Programmierung2/src/Klausur/zoo/Animal.java b/Programmierung2/src/Klausur/zoo/Animal.java new file mode 100644 index 0000000..693dba5 --- /dev/null +++ b/Programmierung2/src/Klausur/zoo/Animal.java @@ -0,0 +1,22 @@ +package Klausur.zoo; + +public abstract class Animal { + private String name; + private int birthyear; + private String species; + + public Animal(String name, int birthyear) { + this.name = name; + this.birthyear = birthyear; + + species = this.getClass().getName(); + species = species.substring(species.lastIndexOf(".")+1); + } + + public abstract void speak(); + + public String getSpecies() { + return species; + } + +} diff --git a/Programmierung2/src/Klausur/zoo/Cat.java b/Programmierung2/src/Klausur/zoo/Cat.java new file mode 100644 index 0000000..a5cf480 --- /dev/null +++ b/Programmierung2/src/Klausur/zoo/Cat.java @@ -0,0 +1,15 @@ +package Klausur.zoo; + + +public class Cat extends Animal { + + public Cat(String name, int birthyear) { + super(name, birthyear); + } + + @Override + public void speak() { + System.out.println(super.getSpecies() + " macht: Meow"); + } + +} diff --git a/Programmierung2/src/Klausur/zoo/Dog.java b/Programmierung2/src/Klausur/zoo/Dog.java new file mode 100644 index 0000000..b70e438 --- /dev/null +++ b/Programmierung2/src/Klausur/zoo/Dog.java @@ -0,0 +1,14 @@ +package Klausur.zoo; + +public class Dog extends Animal { + + public Dog(String name, int birthyear) { + super(name, birthyear); + } + + @Override + public void speak() { + System.out.println(super.getSpecies() + " macht: Woof"); + } + +} diff --git a/Programmierung2/src/Klausur/zoo/ZooMain.java b/Programmierung2/src/Klausur/zoo/ZooMain.java new file mode 100644 index 0000000..21711cb --- /dev/null +++ b/Programmierung2/src/Klausur/zoo/ZooMain.java @@ -0,0 +1,24 @@ +package Klausur.zoo; + +import java.util.ArrayList; + +public class ZooMain { + + public static void main(String[] args) throws Exception { + ArrayList tiere = new ArrayList<>(); + + // Animal a = new Animal("Animal", "1934"); // abstrakt, daher keine Instanzen möglich! + + Animal c = new Cat("Sylvester", 1947); + c.speak(); + tiere.add(c); + + Animal d = new Dog("Spike", 1963); + d.speak(); + tiere.add(d); + + System.out.println("Anzahl der Tiere im Zoo: " + tiere.size()); + + } + +} diff --git a/Programmierung2/src/Lambda/Addiere.java b/Programmierung2/src/Lambda/Addiere.java new file mode 100644 index 0000000..da1de7e --- /dev/null +++ b/Programmierung2/src/Lambda/Addiere.java @@ -0,0 +1,25 @@ +package Lambda; + +public class Addiere { + + public static void main(String[] args) { + Add add = (a,b) -> a+b; +// int result = add.add(12, 12); +// System.out.println(result); + + + System.out.println(addieren(12,12,add)); + + } + + public static int addieren(int a,int b,Add add) { + + return add.add(a, b); + } + +} + +interface Add{ + + int add(int a, int b); +} \ No newline at end of file diff --git a/Programmierung2/src/Lambda/Übungtestate2.java b/Programmierung2/src/Lambda/Übungtestate2.java deleted file mode 100644 index 0f77030..0000000 --- a/Programmierung2/src/Lambda/Übungtestate2.java +++ /dev/null @@ -1,28 +0,0 @@ -package Lambda; - -public class Übungtestate2 { - - public static void main(String[] args) { - - Test23 t = new Test23() { - - @Override - public void print () { - System.out.println("Annynom Innere Klasse"); - } - - - }; - t.print(); - } - - - -} - -class Test23 { - - public void print () { - System.out.println("Test"); - } -} diff --git a/Programmierung2/src/Thread/SimpleHeapAndStack.java b/Programmierung2/src/Thread/SimpleHeapAndStack.java new file mode 100644 index 0000000..5eae700 --- /dev/null +++ b/Programmierung2/src/Thread/SimpleHeapAndStack.java @@ -0,0 +1,26 @@ +package Thread; + +import java.util.Random; + +class Runner4 implements Runnable { + private int zaehler = 0; + + public void run() { + int local = new Random().nextInt(); + System.out.println(local); + while (true) { + zaehler = local++; + } + } +} + +public class SimpleHeapAndStack { + public static void main(String[] args) { + Runner4 runner = new Runner4(); + Thread t1 = new Thread(runner, "Thread-1"); + Thread t2 = new Thread(runner, "Thread-2"); + + t1.start(); + t2.start(); + } +} diff --git a/Programmierung2/src/oop/Generics/Generic.odt b/Programmierung2/src/oop/Generics/Generic.odt index 9549e04..7c2547c 100644 Binary files a/Programmierung2/src/oop/Generics/Generic.odt and b/Programmierung2/src/oop/Generics/Generic.odt differ diff --git a/Programmierung2/src/oop/Generics/Parent.java b/Programmierung2/src/oop/Generics/Parent.java new file mode 100644 index 0000000..53e9302 --- /dev/null +++ b/Programmierung2/src/oop/Generics/Parent.java @@ -0,0 +1,34 @@ +package oop.Generics; + +public class Parent { + + private T name; + + public Parent(T name) { + this.name = name; + } + + public T getName() { + return name; + } + + public void setName(T name) { + this.name = name; + } + + @Override + public String toString() { + return "Parent [name=" + name + "]"; + } + +} + +class Sohn extends Parent{ + + public Sohn(T name) { + super(name); + } + + + +} diff --git a/Programmierung2/src/oop/Generics/RawType.java b/Programmierung2/src/oop/Generics/RawType.java index afb8857..360a5f8 100644 --- a/Programmierung2/src/oop/Generics/RawType.java +++ b/Programmierung2/src/oop/Generics/RawType.java @@ -8,12 +8,18 @@ public class RawType{ ArrayList t = new ArrayList<>(); t.add(22); t.add(12); + t.add(123); + + ArrayList t2 = new ArrayList<>(); + t2.add("dd"); + add(t2); } - public static void printList(ArrayList list) { - for (Object elem : list) - System.out.println(elem + " "); - } + public static void add(ArrayList list) { + for (Object o : list) + System.out.println(o.toString()); + + } } diff --git a/Programmierung2/src/oop/Generics/Wildcard-Zeichen.pdf b/Programmierung2/src/oop/Generics/Wildcard-Zeichen.pdf deleted file mode 100644 index 280d56e..0000000 Binary files a/Programmierung2/src/oop/Generics/Wildcard-Zeichen.pdf and /dev/null differ diff --git a/Programmierung2/src/streams/KlausurAufgabe.java b/Programmierung2/src/streams/KlausurAufgabe.java new file mode 100644 index 0000000..9f72552 --- /dev/null +++ b/Programmierung2/src/streams/KlausurAufgabe.java @@ -0,0 +1,25 @@ +package streams; + +import java.util.*; + +public class KlausurAufgabe { + + public static void main(String[] args) { + String[] arr = {"USW", "GGT", "UA", "ZB", "FKK", "MFG", "SOSE", "A", "H", "MM", "MBIT"}; + Map> speicher = new HashMap<>(); + + for (String s : arr) { + int length = s.length(); + + if (!speicher.containsKey(length)) + speicher.put(length, new ArrayList<>()); + + + + speicher.get(length).add(s); + } + + System.out.println(speicher); + } + +}