Übungen

Programmierung2/src/Lambda/JTest.java

@@ -0,0 +1,38 @@
+package Lambda;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class JTest {
+	JTestLambda calculator;
+	@BeforeEach
+	public void objekt() {
+		calculator = new JTestLambda(2);
+	}
+	
+	// Variant 1
+	@Test
+	public void testDivideByZero() {
+		
+
+		// Testet, ob eine ArithmeticException geworfen wird, wenn durch null geteilt wird
+					// Name der Klass Exception
+		assertThrows(ArithmeticException.class, () -> {
+			calculator.divide(10, 0);
+		});
+	}
+	
+	// Variant 2
+	@Test
+	public void testExceptionMessage() {
+	    Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+	        throw new IllegalArgumentException("Invalid argument");
+	    });
+	    
+	    // Überprüfen der Fehlermeldung
+	    assertEquals(10,calculator.divide(10, 1),exception.getMessage());
+	}
+
+}

Programmierung2/src/Lambda/JTestLambda.java

@@ -0,0 +1,23 @@
+package Lambda;
+
+import java.util.function.Supplier;
+
+public class JTestLambda {
+	
+	JTestLambda(int x){
+		
+	}
+	public int divide(int a, int b) {
+		if (b == 0) {
+			throw new ArithmeticException("Division durch Null");
+		}
+		return a / b;
+	}
+	
+	 public Supplier<String> erstelleLambda(String text) {
+		 
+	        // Lambda-Ausdruck, der auf die Variable 'text' zugreift
+	        return () -> "Der Text ist: " + text;
+	    }
+
+}

Programmierung2/src/Lambda/LambdaAlsRückgabewert.java

@@ -0,0 +1,21 @@
+package Lambda;
+
+import java.util.function.IntSupplier;
+
+public class LambdaAlsRückgabewert {
+
+	public static void main(String[] args) {
+		
+		IntSupplier würfel = würfel();
+		System.out.println(würfel.getAsInt());
+	}
+	
+
+	public static IntSupplier würfel() {
+		
+		// Das äußere return gibt den gesamten Lambda-Ausdruck als IntSupplier zurück.
+		// Das innere return innerhalb des Lambda-Körpers gibt den int-Wert für getAsInt()
+		return () -> {return (int) (Math.random() * 6+1);};
+	}
+	
+}

Programmierung2/src/Methoden_Referenzen/Konstruktor_Referenzen.java

@@ -0,0 +1,31 @@
+package Methoden_Referenzen;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Konstruktor_Referenzen {
+
+	public static void main(String[] args) {
+		List<String> namen = Arrays.asList("Alice", "Bob", "Charlie");
+
+		// Konstruktor-Referenz
+		List<Person> personen = namen.stream().map(Person::new) // Erzeugt für jeden Namen ein neues Person-Objekt
+				
+				.collect(Collectors.toList()); // Sammelt alle Objekte und speichert es in der List<Person>
+
+		personen.forEach(System.out::println); // Ausgabe: Alice, Bob, Charlie
+	}
+}
+
+class Person {
+	String name;
+
+	Person(String name) {
+		this.name = name;
+	}
+
+	@Override
+	public String toString() {
+		return name;
+	}
+}

Programmierung2/src/Methoden_Referenzen/LambdaVsMethoden_Refrenz.java

@@ -0,0 +1,19 @@
+package Methoden_Referenzen;
+import java.util.*;
+
+public class LambdaVsMethoden_Refrenz {
+
+	public static void main(String[] args) {
+	//	List<String> namen = Arrays.asList("Anna", "Ben", "Cara").forEach(System.out::println); Fehler weil forEach gibt nichts aus
+		
+		List<String> namen = Arrays.asList("Anna", "Ben", "Cara");
+		Arrays.asList("Anna", "Ben", "Cara").forEach(System.out::println);
+		// Mit Lambda-Ausdruck
+		namen.forEach(name -> System.out.println(name));
+
+		// Mit Methoden-Referenz
+		namen.forEach(System.out::println);
+
+	}
+
+}

Programmierung2/src/Methoden_Referenzen/Nicht_statische_Methoden_Referenzen.java

@@ -0,0 +1,22 @@
+package Methoden_Referenzen;
+
+import java.util.*;
+
+public class Nicht_statische_Methoden_Referenzen {
+	
+	public static void main(String[] args) {
+        List<String> worte = Arrays.asList("hallo", "welt", "java");
+        
+        // Nicht-statische Methoden-Referenz
+        worte.stream()
+             .map(String::toUpperCase) // "hallo"::toUpperCase, "welt"::toUpperCase, etc.
+             .forEach(System.out::println);
+        
+        Nicht_statische_Methoden_Referenzen t = new Nicht_statische_Methoden_Referenzen();
+        worte.forEach(t ::druckeWort );
+    }
+	
+	 public void druckeWort(String wort) {
+	        System.out.println("Wort: " + wort);
+	    }
+}

Programmierung2/src/Methoden_Referenzen/Statische_Methoden_Referenzen.java

@@ -0,0 +1,19 @@
+package Methoden_Referenzen;
+
+import java.util.*;
+
+
+public class Statische_Methoden_Referenzen {
+
+	public static void main(String[] args) {
+        List<String> zahlenStrings = Arrays.asList("1", "2", "3", "4");
+        
+        // Statische Methoden-Referenz zu Integer::parseInt
+        zahlenStrings.stream()
+                     .map(Integer::parseInt) // statische Integer.parseInt wird für jedes Element aufgerufen
+                     .forEach(System.out::println);
+    }
+	
+	
+
+}

Programmierung2/src/Methoden_Referenzen/WeitereBeispiele.java

@@ -0,0 +1,32 @@
+package Methoden_Referenzen;
+
+public class WeitereBeispiele {
+	public static void main(String[] args) {
+		System.out.println(Berechnung.berechne(5, 5, Funktionssammlung::add));
+		System.out.println(Berechnung.berechne(10, 8, Funktionssammlung::sub));
+		
+	}
+}
+
+//Interface Definition
+interface Funktion {
+	int apply(int a, int b);
+}
+
+//Klasse mit Methoden, die als Funktionen genutzt werden können
+class Funktionssammlung {
+	public static int add(int a, int b) {
+		return a + b;
+	}
+
+	public static int sub(int a, int b) {
+		return a - b;
+	}
+}
+
+//Klasse, die die Berechnungen durchführt
+class Berechnung {
+	public static int berechne(int a, int b, Funktion funktion) {
+		return funktion.apply(a, b);
+	}
+}

Programmierung2/src/oop/InnereKlassen/Main.java

@@ -0,0 +1,82 @@
+package oop.InnereKlassen;
+
+import java.util.ArrayList;
+import java.util.function.*;
+
+public class Main {
+
+	public static void main(String[] args) {
+		ArrayList<Integer> t = new ArrayList<>();
+		t.add(12);
+		t.add(123);
+		t.add(123);
+		
+		t.forEach(test());
+		System.out.println("Ber: " + berechnen().berechne(12, 12));
+		
+//		
+//		t.forEach(i -> System.out.println(i));
+//		System.out.println("Innere Klasse: ");
+//		t.forEach(new Consumer<Integer>() {
+//			
+//			public void accept(Integer i) {
+//				
+//				System.out.println(i);
+//			}
+//			
+//		});
+////		test(t, 123);
+//		
+//		t.removeIf(f -> f  == 123);
+//		
+//		t.removeIf(new Predicate<Integer>() {
+//
+//			@Override
+//			public boolean test(Integer value) {
+//				return value == 123;
+//			}
+//			
+//			
+//		});
+//		System.out.println(t);
+//		
+//		System.out.println(t);
+//		T tf = (a,b) -> a+b;
+//		
+//		System.out.println(tf.berechne(12, 12));
+//		
+
+	}
+	
+	public static Consumer<Integer> test() {
+		
+		class S implements Consumer<Integer>{
+
+			@Override
+			public void accept(Integer t) {
+				System.out.println(t);
+			}
+			
+		}
+		
+		return new S();
+	}
+	
+	public static T berechnen() {
+		
+		class X implements T{
+			
+			public int berechne(int i, int b) {
+				return i+b;
+			}
+		}
+		
+		return new X();
+	}
+	
+}
+
+interface T {
+
+	int berechne(int x, int y);
+}

Programmierung2/src/oop/IteratorKlasse.java

@@ -0,0 +1,21 @@
+package oop;
+
+import java.util.*;
+
+public class IteratorKlasse {
+
+	public static void main(String[] args) {
+		 ArrayList mylist = new ArrayList();
+	        mylist.add("Hello");
+	        mylist.add("Java");
+	        mylist.add("4");
+	        
+	        Iterator it = mylist.iterator();
+	        while(it.hasNext()){
+	            Object element = it.next();
+	            System.out.println((String)element);
+	        }
+
+	}
+
+}

Programmierung2/src/streams/ArraysAlsStream.java

@@ -0,0 +1,21 @@
+package streams;
+
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+public class ArraysAlsStream {
+
+	public static void main(String[] args) {
+		Stream<String> s = Stream.of("H","B","D");
+		s.forEach(System.out::println);
+		
+		int[] array = {1,2,3,4,5};
+		IntStream.of(array).filter(i -> (i == 2)).forEach(System.out::println);
+		
+		StringBuffer buffer = new StringBuffer();
+		IntStream.rangeClosed(1, 50)
+		         .forEach(buffer::append);
+		System.out.println(buffer.toString());
+	}
+
+}

Programmierung2/src/streams/Aufgaben.java

@@ -0,0 +1,71 @@
+package streams;
+
+import java.util.*;
+import java.util.stream.Stream;
+
+public class Aufgaben {
+	
+	public static void main(String[] args) {
+		
+//		List<Integer> numbers = Arrays.asList(1,2,3,4,5);
+//		
+//		List<Integer> result = numbers.stream()
+//				.map(i -> i * i)
+//				.collect(Collectors.toList());
+//		
+//		System.out.println(result);
+		
+//		 List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eva");
+//	        Integer result2 = names
+//	                .stream()
+//	                .map(e -> e.length())
+//	                .max((integer, newInteger) -> Integer.compare(integer, newInteger))
+//	                .get();
+//	        System.out.println(result2);
+//	        
+//	        List<Integer> numbers = Arrays.asList(1,2,3,4,5);
+//	        
+//	        Integer max = numbers.stream()
+//	        .max((a,b) -> a.compareTo(b))
+//	        .get();
+//	        
+//	        System.out.println(max);
+	        
+			String str = "Die Katze jagt die Maus";
+			Stream<String> wörterString = Arrays.stream(str.split(" "));
+			
+			
+			
+		
+	        List<String> saetze = Arrays.asList(
+	        	    "Die Katze jagt die Maus",
+	        	    "ist klein",
+	        	    "Der Hund ",
+	        	    "Die Katze schläft Bellt"
+	        	);
+	        
+	        //finde das kleinste Wort
+	        
+	        String maxWort = saetze.stream()
+	        	.flatMap(satz -> Arrays.stream(satz.split(" "))) // Teilt jeden Satz in Wörter
+	        	.max(String::compareTo) // finde das lexikografisch  größte Wort
+	        	.get();
+	        
+//	        System.out.println("maxWort " + maxWort);
+	        
+	        // speichere jede Wort der nur 5 Zeichen enthalten und alle Kleinbuchstaben
+	        List<String> mindestensfünfZeichen =  saetze.stream()
+	        		.flatMap(satz -> Arrays.stream(satz.split(" ")))
+	        		.filter(wort -> wort.length() == 5)
+	        		.map(wort -> wort.toLowerCase())
+	        		.toList();
+	        
+	        //System.out.println(mindestensfünfZeichen);
+	        
+	        
+	       saetze.stream()
+	        .flatMap(satz -> Arrays.stream(satz.split(" ")))
+	        .forEach(wort -> System.out.println("Wort: " + wort + " Wortlänge " + wort.length()));
+	        
+	}
+}

Programmierung2/src/streams/Beispiele.java

@@ -6,37 +6,40 @@ public class Beispiele {
 	
 	
 	public static void main(String[] args) {
-		Integer[] myArray = new Integer[]{10,20,22,30,50};
+		Integer[] myArray = new Integer[] { 10, 20, 22, 30, 50 };
-		Stream<Integer>  myStream = Arrays.stream(myArray);
+		Stream<Integer> myStream = Arrays.stream(myArray);
 		/*
-		 * Hier macht der Stream nichts, weil die Intermediate-Operation filter
+		 * Hier macht der Stream nichts, weil die Intermediate-Operation filter keine
-		 * keine Aktion auslöst, solange keine Terminal-Operation aufgerufen wird.
+		 * Aktion auslöst, solange keine Terminal-Operation aufgerufen wird.
-		*/
+		 */
-		myStream.filter(i -> (i % 2 == 0));//Keine Wirkung, da keine Terminal-Operation folgt
+//		myStream.filter(i -> (i % 2 == 0));//Keine Wirkung, da keine Terminal-Operation folgt
-		
 
 		/*
-		 * Hier wird eine Intermediate-Operation (filter) auf dem Stream aufgerufen,
+		 * Hier wird eine Intermediate-Operation (filter) auf dem Stream aufgerufen, die
-		 * die die geraden Zahlen aus dem Stream herausfiltert.
+		 * die geraden Zahlen aus dem Stream herausfiltert. Danach wird die
-		 * Danach wird die Terminal-Operation count() aufgerufen, die die Anzahl der 
+		 * Terminal-Operation count() aufgerufen, die die Anzahl der gefilterten
-		 * gefilterten Elemente zählt und als long zurückgibt.
+		 * Elemente zählt und als long zurückgibt.
 		 */
 		long x = myStream.filter(i -> (i % 2 == 0)).count(); // count gibt Long zurück
 		System.out.println(x);
 
-		// Wiederverwendung von myStream liefert einen Compiler-Fehler, da der Stream bereits abgeschlossen ist.
+		// Wiederverwendung von myStream liefert einen Compiler-Fehler, da der Stream
-		// Ein Stream kann nur einmal verwendet werden, und nach einer Terminal-Operation wie count() 
+		// bereits abgeschlossen ist.
+		// Ein Stream kann nur einmal verwendet werden, und nach einer
+		// Terminal-Operation wie count()
 		// ist der Stream geschlossen und nicht wiederverwendbar.
 		x = myStream.filter(i -> (i % 2 == 1)).count(); // Compiler-Fehler
 		System.out.println(x);
 
 		// Compiler-Fehler: Stream has already been operated upon or closed
-		// Dieser Fehler tritt auf, weil myStream nach der ersten count()-Operation nicht erneut verwendet werden kann.
+		// Dieser Fehler tritt auf, weil myStream nach der ersten count()-Operation
+		// nicht erneut verwendet werden kann.
 		long y = myStream.filter(i -> (i % 2 == 1)).count(); // Compiler-Fehler
 		System.out.println(y);
 
+		int[] array = { 1, 2, 3, 45, 6 };
+
 	}
 	
 	
-	
 }

Programmierung2/src/streams/Beispiele2.java

@@ -1,5 +1,6 @@
 package streams;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Stream;
@@ -17,7 +18,17 @@ public class Beispiele2 {
 		myStream.forEach(i -> System.out.println(i));
 		
 		
+		ArrayList<Integer> test = new ArrayList<>();
 		
+		test.stream();
 
+		Stream<String> stream3 = Stream.of("Hallo Welt", "Hello Detective", "Guten Tag", "Hallo hallo wie geht es Dir", "Endlich Feierabend");
+
+		int wordCount = stream3
+		    .flatMap(s -> Arrays.stream(s.split(" ")))  // Jedes Element (Satz) wird in Wörter gesplittet
+		    .map(word -> 1)                             // Jedes Wort wird in den Wert 1 gemappt
+		    .reduce(0, (sum, word) -> sum + word);      // Alle 1er-Werte werden addiert, um die Wortanzahl zu erhalten
+
+		System.out.println(wordCount);
 	}
 }

Programmierung2/src/streams/PeekMethode.java

@@ -0,0 +1,22 @@
+package streams;
+
+import java.util.stream.Stream;
+/* 
+ * - peek() ist ideal, um Daten im Stream zu beobachten und eignet sich gut für Debugging-Zwecke.
+ * - Es ist eine Zwischenoperation, die Daten nicht verändert, sondern sie unverändert weitergibt.
+ * - Nicht zum Modifizieren der Daten verwenden, da peek()-Operationen optimiert oder weggelassen werden könnten.
+ * 
+ */
+
+public class PeekMethode {
+
+	public static void main(String[] args) {
+		Stream.of("A", "B", "C", "D")
+	      .filter(s -> !s.equals("C"))
+	      .peek(System.out::println) // Ausgabe für Debugging
+	      .map(String::toLowerCase)
+	      .forEach(System.out::println);
+
+	}
+
+}

Programmierung2/src/streams/Reduce_Methode.java

@@ -0,0 +1,20 @@
+package streams;
+
+import java.util.*;
+
+public class Reduce_Methode {
+	static String str = "dds";
+	public static void main(String[] args) {
+		
+	
+		List<Integer> al = Arrays.asList(3,7,2,1,8,4,5);
+		al.forEach(i -> System.out.println(i + str));
+		
+	
+//		System.out.println(al.stream().reduce(0, (i,j) -> i+j));
+		
+		
+	}
+	
+	
+}