Sem I (Program I) - N6 Flashcards
Platform-specific newline (Java printf)
%n
How big column shoud be (Java printf)
%10s = for string
%10d = for int
public class Solution {
public static void main(String[] args) {
System.out.printf("|%10s|%10s|%n", "Column1", "Column2");
System.out.printf("|%10d|%10d|", 123, 4567);
// Output:
// | Column1| Column2|
// | 123| 4567|
}
}
Formating after comma number (Java printf)
%.2
double pi = 3.14159;
System.out.printf("Value of pi: %.2f%n", pi);
// Output: Value of pi: 3.14
Left-justify (default is right-justify) (JAVA printf)
-
Include a plus sign for positive numbers (JAVA printf)
System.out.printf(“Number with sign: %+d%n”, num);
// Number with sign: +12345
Pad with zeros instead of spaces (JAVA printf)
System.out.printf("Number with padding: %010d%n", num);
// Number with padding: 0000012345Use locale-specific grouping separators (e.g., thousands separator) (JAVA printf)
System.out.printf("Number with grouping: %,d%n", num);
// Number with grouping: 12,345Wozu dienen Exceptions in Java? Wann sind sie brauchbar bzw. nicht (unbedingt) brauchbar?
Exceptions dienen dazu, Laufzeitfehler zu behandeln und den Programmablauf kontrolliert zu stoppen oder zu steuern. Sie sind brauchbar, um Fehlerbedingungen zu behandeln, ohne dass das Programm unerwartet abstürzt.
Wann (und wie) sollte eine Methode ihre Exceptions ankündigen?
Eine Methode sollte ihre Exceptions ankündigen, wenn sie potenziell eine überprüfte Ausnahme (checked exception) auslösen kann, die nicht innerhalb der Methode behandelt wird.
public void meineMethode() throws IOException {
// Methode
}
Was ist der Exception Handler?
Ein Exception Handler ist ein Codeblock, der eine Ausnahme fängt und behandelt. In Java wird dies durch den catch-Block realisiert, der zusammen mit dem try-Block verwendet wird.
Wo sollte eine Exception gefangen werden?
Eine Exception sollte dort gefangen werden, wo sie sinnvoll behandelt werden kann. Idealerweise so nahe wie möglich an der Quelle des Problems
Was ist der try-Block?
Ein try-Block enthält den Code, der potenziell eine Ausnahme auslösen könnte. Er wird verwendet, um Ausnahmen abzufangen und sicherzustellen, dass sie behandelt werden.
try {
// Risiko-Code
} catch (ExceptionType e) {
// Behandlungs-Code
}
Was ist eine catch-Klausel?
Eine catch-Klausel fängt eine spezifische Ausnahme ab, die im try-Block aufgetreten ist, und führt den Code zur Fehlerbehandlung aus
try {
// Risiko-Code
} catch (IOException e) {
// Fehlerbehandlung für IOException
}
Kann eine Methode mehrere Rückgabewerte haben?
Direkt kann eine Methode nur einen Rückgabewert haben. Man kann jedoch mehrere Werte in einem Objekt oder einem Array bündeln und dieses zurückgeben.
Kann eine Methode mehrere Rückgabewerte haben?
Nein
Was ist die Komplexität und wozu ist sie gut?
Komplexität bezieht sich auf die Analyse der Laufzeit oder des Speicherbedarfs eines Algorithmus.
Kann man nach einem Element schneller in einem sortierten oder unsortierten Array suchen?
In einem sortierten Array kann man mit der binären Suche (O(log n)) schneller suchen als mit der linearen Suche (O(n)) in einem unsortierten Array.
Was ist die Komplexitätsklasse für lineare Suche im sortierten und im unsortierten Feld?
Für beide ist die Komplexitätsklasse O(n), da jedes Element nacheinander durchsucht werden muss.
Kommt man ohne Suche aus, wenn in einem sortierten Feld ein Element eingefügt werden soll?
Nein, man muss die richtige Position finden
java.util.Scanner.hasNext()
This method checks if there is another token available in the input of the Scanner (for example space)
java.lang.Integer.parseInt(String)
method in Java is used to convert a String that represents an integer into the actual integer value.
public class ParseIntExample {
public static void main(String[] args) {
String numberString = "123";
int number = Integer.parseInt(numberString);
System.out.println("The integer value is: " + number); // Output: The integer value is: 123
}
}
java.lang.Integer.toString(int);
method in Java is used to convert an integer to its String representation.
import java.util.Scanner;
public class IntegerToStringExample {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter an integer: ");
int number = scanner.nextInt();
String numberString = Integer.toString(number);
System.out.println("The String representation of the integer is: " + numberString);
String concatenatedString = "The number is " + numberString;
System.out.println(concatenatedString);
scanner.close();
} }
Was ist der Unterschied zwischen der sequentiellen und der binären Suche in Bezug auf die Zeitkomplexität?
Die sequentielle Suche hat eine Zeitkomplexität von O(n), wobei n die Länge des Arrays ist.
Die binäre Suche O(log n).
Was ist der effizienteste Weg, ein Element in ein unsortiertes Array einzufügen?
Am Ende des Arrays anzuhängen. Dies hat eine Zeitkomplexität von O(1)
Wie unterscheidet sich das Einfügen eines Elements in ein sortiertes Array von dem Einfügen in ein unsortiertes Array?
Das Einfügen in ein unsortiertes Array hat eine Zeitkomplexität von O(1) (am Ende einfügen), während das Einfügen in ein sortiertes Array eine Zeitkomplexität von O(n) haben kann.
Was passiert, wenn man versucht, ein Element aus einem Array zu löschen?
Beim Löschen eines Elements aus einem Array wird zunächst das Element gesucht. Wenn es gefunden wird, wird ein neues Array erzeugt, das um 1 kürzer ist als das ursprüngliche. Alle Elemente außer dem zu löschenden werden in das neue Array kopiert.
Was ist ein offenes Array?
Ein offenes Array, auch als “varargs” (variadic arguments) bekannt, ist eine Funktionalität in Java, die es ermöglicht, eine Methode mit einer variablen Anzahl von Argumenten aufzurufen. (…)
public class VarargsExample {
public static void printNumbers(int... numbers) {
for (int number : numbers) {
System.out.println(number);
}
}
public static void main(String[] args) {
printNumbers(1, 2, 3);
printNumbers(4, 5);
printNumbers(6);
printNumbers(); // keine Argumente
}
}
equals() (Java)
Methode der Klasse Object, die in allen Java-Objekten verfügbar ist. Sie wird verwendet, um festzustellen, ob zwei Objekte gleich sind.
deepEquals() (JAVA)
Utility-Methode, die in der Klasse java.util.Objects enthalten ist. Sie wird verwendet, um zwei Objekte rekursiv auf Gleichheit zu überprüfen. Dies ist besonders nützlich für Arrays oder verschachtelte Strukturen, bei denen einfache Gleichheitsprüfungen nicht ausreichen.
Die Methode deepEquals() überprüft die Gleichheit von zwei Objekten auf einer tieferen Ebene als equals().
import java.util.Objects;
public class DeepEqualsExample {
public static void main(String[] args) {
// Primitive Arrays
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
System.out.println(Objects.deepEquals(arr1, arr2)); // true
// Zwei-dimensionale Arrays
int[][] arr3 = {{1, 2}, {3, 4}};
int[][] arr4 = {{1, 2}, {3, 4}};
System.out.println(Objects.deepEquals(arr3, arr4)); // true
// Arrays von Objekten
String[] arr5 = {"a", "b", "c"};
String[] arr6 = {"a", "b", "c"};
System.out.println(Objects.deepEquals(arr5, arr6)); // true
// Verschachtelte Strukturen
Object[] arr7 = {arr3, arr5};
Object[] arr8 = {arr4, arr6};
System.out.println(Objects.deepEquals(arr7, arr8)); // true
// Unterschiedliche Arrays
int[] arr9 = {1, 2, 3};
int[] arr10 = {1, 2, 4};
System.out.println(Objects.deepEquals(arr9, arr10)); // false
}
}
copyOfRange() (JAVA)
Klasse java.util.Arrays wird verwendet, um einen Teilbereich eines Arrays zu kopieren und in einem neuen Array zurückzugeben.
import java.util.Arrays;
public class CopyOfRangeExample {
public static void main(String[] args) {
// Beispiel mit einem int-Array
int[] originalIntArray = {1, 2, 3, 4, 5};
int[] copiedIntArray = Arrays.copyOfRange(originalIntArray, 1, 4);
System.out.println(Arrays.toString(copiedIntArray)); // Ausgabe: [2, 3, 4]
// Beispiel mit einem String-Array
String[] originalStringArray = {"A", "B", "C", "D", "E"};
String[] copiedStringArray = Arrays.copyOfRange(originalStringArray, 0, 3);
System.out.println(Arrays.toString(copiedStringArray)); // Ausgabe: [A, B, C]
// Beispiel mit einem Array von Objekten
Integer[] originalIntegerArray = {10, 20, 30, 40, 50};
Integer[] copiedIntegerArray = Arrays.copyOfRange(originalIntegerArray, 2, 5);
System.out.println(Arrays.toString(copiedIntegerArray)); // Ausgabe: [30, 40, 50]
// Beispiel mit einem char-Array
char[] originalCharArray = {'a', 'b', 'c', 'd', 'e'};
char[] copiedCharArray = Arrays.copyOfRange(originalCharArray, 1, 3);
System.out.println(Arrays.toString(copiedCharArray)); // Ausgabe: [b, c]
}
}
copyOf() (JAVA)
Klasse java.util.Arrays wird** verwendet, um ein Array zu kopieren und ein neues Array mit einer bestimmten Länge** zurückzugeben. Im Gegensatz zu copyOfRange(), das einen bestimmten Teilbereich eines Arrays kopiert, kopiert copyOf() das gesamte Array bis zu einer angegebenen Länge.
import java.util.Arrays;
public class CopyOfExample {
public static void main(String[] args) {
// Beispiel mit einem int-Array
int[] originalIntArray = {1, 2, 3, 4, 5};
int[] copiedIntArray = Arrays.copyOf(originalIntArray, 3);
System.out.println(Arrays.toString(copiedIntArray)); // Ausgabe: [1, 2, 3]
// Beispiel mit einem String-Array
String[] originalStringArray = {"A", "B", "C", "D", "E"};
String[] copiedStringArray = Arrays.copyOf(originalStringArray, 2);
System.out.println(Arrays.toString(copiedStringArray)); // Ausgabe: [A, B]
// Beispiel mit einem Array von Objekten
Integer[] originalIntegerArray = {10, 20, 30, 40, 50};
Integer[] copiedIntegerArray = Arrays.copyOf(originalIntegerArray, 4);
System.out.println(Arrays.toString(copiedIntegerArray)); // Ausgabe: [10, 20, 30, 40]
// Beispiel mit einem char-Array
char[] originalCharArray = {'a', 'b', 'c', 'd', 'e'};
char[] copiedCharArray = Arrays.copyOf(originalCharArray, 5);
System.out.println(Arrays.toString(copiedCharArray)); // Ausgabe: [a, b, c, d, e]
}
}
arraycopy() (JAVA)
Die Methode arraycopy() in Java wird verwendet, um Elemente zwischen Arrays oder innerhalb desselben Arrays zu kopieren. Im Gegensatz zu copyOf() und copyOfRange() aus der Klasse Arrays, bietet arraycopy() eine flexiblere Möglichkeit, die Kopieroperation durchzuführen, da sie direkten Zugriff auf den Systembereich für Array-Kopieroperationen bietet.
public class ArrayCopyExample {
public static void main(String[] args) {
// Quell-Array
int[] srcArray = {1, 2, 3, 4, 5};
// Ziel-Array
int[] destArray = new int[5];
// Kopieren von srcArray zu destArray
System.arraycopy(srcArray, 0, destArray, 0, srcArray.length);
// Ausgabe des Ziel-Arrays
System.out.println("Ziel-Array nach dem Kopieren:");
for (int num : destArray) {
System.out.print(num + " ");
}
System.out.println();
// Veränderung des Quell-Arrays
srcArray[0] = 10;
// Ausgabe des Ziel-Arrays nach der Veränderung des Quell-Arrays
System.out.println("Ziel-Array nach Änderung des Quell-Arrays:");
for (int num : destArray) {
System.out.print(num + " ");
}
System.out.println();
}
}
fill() (JAVA)
Klasse java.util.Arrays wird verwendet, um alle Elemente eines Arrays mit einem bestimmten Wert zu initialisieren.
sort() (JAVA)
Klasse java.util.Arrays wird verwendet, um die Elemente eines Arrays zu sortieren.
Quicksort-Algorithmus für primitive Datentypen
MergeSort-Algorithmus für Objekt-Arrays.
Zeitkomplexität Bubblesort ?
Zeitkomplexität: 𝑂(𝑛^2)
Wie kann der Selectionsort-Algorithmus optimiert werden?
Der Selectionsort-Algorithmus kann optimiert werden, indem gleichzeitig nach dem größten und dem kleinsten Element in einem Durchlauf gesuchtwird.
Welche Methode wird in Java verwendet, um mehrdimensionale Arrays zu vergleichen?
In Java wird die Methode deepEquals(datentyp[] a1, datentyp[] a2) verwendet, um mehrdimensionale Arrays zu vergleichen
Wie könnte man die Effizienz des Bubblesort-Algorithmus verbessern?
Die Effizienz des Bubblesort-Algorithmus kann verbessert werden, indem man nach jedem vollständigen Durchlauf prüft, ob keine Vertauschungen stattgefundenn haben. Wenn keine Vertauschungen stattgefunden haben, ist das Array bereits sortiert, und der Algorithmus kann vorzeitig beendet werden.
Welcher Sortieralgorithmus könnte effizienter als Bubblesort und Selectionsort sein, insbesondere für große Datenmengen?
Mergesort und Quicksort sind effizientere Sortieralgorithmen für große Datenmengen im Vergleich zu Bubblesort und Selectionsort.
Wie wird ein String in Java explizit erzeugt?
Explizit: String str = new String(“Hello”);
Vergleich von Strings
Mit == vergleicht Referenzen (ob sie auf dasselbe Objekt zeigen).
Mit equals() vergleicht den Inhalt der Strings.
Wie wird ein String in Java implizit erzeugt?
Implizit: String str2 = “Hello”; (Optimierung durch Compiler möglich)
Was passiert, wenn man zwei Strings mit == vergleicht?
Es wird überprüft, ob beide Referenzen auf dasselbe Objekt zeigen.
Wie vergleicht man den Inhalt zweier Strings korrekt?
Mit der Methode equals(), die true zurückgibt, wenn beide Strings denselben Inhalt haben.
Was ist die Ausgabe von char z = wort.charAt(2); wenn wort der String “Berlin” ist?
Die Ausgabe ist ‘r’, da das Zeichen an der Position 2 im String “Berlin” ‘r’ ist.
Was ist die Ausgabe von wort.substring(0, 1) wenn wort der String “Berlin” ist?
Die Ausgabe ist “B”, da der Teilstring von Index 0 bis 1 das Zeichen ‘B’ enthält.
Wie kann man aus einem String, z.B. “Hello World”, das Wort “World” extrahieren?
Mit der Methode substring(), z.B. String part = “Hello World”.substring(6, 11);.
Wie kann man Bubblesort optimieren?
1) Flagge zu verwenden, die anzeigt, ob während eines Durchlaufs des Arrays ein Austausch stattgefunden hat.
2) Cocktail Shaker Sort. Dieser Algorithmus durchläuft das Array in beide Richtungen abwechselnd.
Kann Selectionsort optimiert werden? Welche Beschleunigung kann dadurch erreicht werden?
1) kann kleinste am anfand und gleichzitig auch das größte Element gefunden und an das Ende gesetzt werden.
Arrays.copyOf()
used to create a new array by copying elements from an existing array.
int[] originalArray = {1, 2, 3, 4, 5};
// Copy entire array
int[] copiedArray = Arrays.copyOf(originalArray, originalArray.length);
// Copy with a larger size
int[] largerArray = Arrays.copyOf(originalArray, 8); // {1, 2, 3, 4, 5, 0, 0, 0}
// Copy with a smaller size
int[] smallerArray = Arrays.copyOf(originalArray, 3); // {1, 2, 3}
System.out.println(Arrays.toString(copiedArray)); // Output: [1, 2, 3, 4, 5]
System.out.println(Arrays.toString(largerArray)); // Output: [1, 2, 3, 4, 5, 0, 0, 0]
System.out.println(Arrays.toString(smallerArray)); // Output: [1, 2, 3]
