OOP 2 Quizes 2019

Welche Aussage ist richtig, wenn sie nun dieser Liste mit add(E e) ein weiteres
Element hinzufügen?

Wir betrachten das UML Diagramm der Interfaces und Klassen, welche das
Collections API bilden. Welche Aussage trifft zu?

Betrachten wir die Interfaces Queue und Deque. Welche Aussage ist korrekt?

Collection<String> coll = ....;
Iterator<String> iter = coll.iterator();
while(iter.hasNext()) {
  String e = iter.next();
  if(e fulfills the condition) {
    iter.remove();
    }
 }

Welche Aussage zum Thema Set ist korrekt?

Map<String, Integer> m = new HashMap<>();
int result = m.get("some-key");

Map<String, Integer> counts = new HashMap<>();
counts.merge("Hans", 1, Integer::sum);

Map<String, Integer> map = new HashMap<>();
map.put("1", 1);
map.put("2", 2);
Set set = map.keySet();
set.remove("1");
Welche Aussage ist nach dem Ausführen des Codes korrekt?

public class Person {
private List<Person> friends;
...
public List<Person> getFriends() {
return Collections.unmodifiableList(friends);
}
}
Welche Aussage ist korrekt?

import java.util.*;
public class MoreNames {
private Map<String, String> m = new HashMap<>();
public void MoreNames() {
m.put("Mickey", "Mouse");
m.put("Mickey", "Mantle");
}
public int size() {
return m.size();
}
public static void main(String[] args) {
MoreNames moreNames = new MoreNames();
System.out.println(moreNames.size());
}
}

Sei

public class Entry<K, V> { ... }

eine generische Klasse.

Wir wollen mit

Entry<String, int> entry = new Entry<>();

eine Instanz dieser Klassen erzeugen.
Welche Aussage ist korrekt?

Unser Typ T soll das Interface Runnable implementieren.
Wir schreiben: T extends Runnable
Welche Aussage ist richtig?

T extends Runnable & AutoClosable

class A {}
class B extends A {}
Nun erzeugen wir Arrays aus diesen Typen:
A[] arr = new A[1];
B[] brr = new B[1];
Dann weisen wir wie folgt zu:
arr = brr;
Schliesslich fügen wir eine neue Instanz vom Typ A hinzu:
arr[0] = new A();

public static void printNamesAndAddMax(List<? extends Employee> staff) {
for(int i = 0; i < staff.size(); i++) {
Employee employee = staff.get(i);
System.out.println(employee.getName());
}
staff.add(new Employee("Max"));
}
Welche Aussage ist richtig?

public static boolean hasNulls(List<?> elements) {
for (Object element : elements) {
if(element == null) {
return true;
}
}
return false;
}
Welche Aussage ist richtig?

ArrayList<String> strings = new ArrayList<>();
System.out.println(strings.getClass());
Welche Aussage ist richtig?

Sei T eine Typ Variable. Betrachten wir den folgenden Code:
T[] result = new T[42];
Welche Aussage ist richtig?

pubic class TheClass<T> {
public boolean equals(T t) {
return true;
}
}

import java.util.*;
public class Name {
private final String first, last;
public Name(String first, String last) {
this.first = first;
this.last = last;
}
public boolean equals(Name n) {
return n.first.equals(first) && n.last.equals(last);
}
public int hashCode() {
return 31 * first.hashCode() + last.hashCode();
}
public static void main(String[] args) {
Set<Name> s = new HashSet<>();
s.add(new Name("Donald", "Duck"));
System.out.println(s.contains(new Name("Donald", "Duck")));
}
}

Die Klasse java.util.String implementiert das Comparable Interface.
Instanzen der String Klasse können so in einer Collection alphabetisch sortiert
werden.
Wir möchten nun die Strings nach ihrer Länge ordnen.
Welche Aussage ist korrekt?

Welche Aussage ist korrekt

Betrachten wir folgende Lambda Expression:
(String first, String second) -> first.length() - second.length();
Welche Aussage ist korrekt?

interface I<T> {
int compare(T f, T s);
boolean test(T t);
}
I<String> i = (first, second) -> first.length() - second.length();
Welche Aussage ist korrekt?

Object p = e -> e == null;
Welche Aussage ist korrekt?

public static void repeat(int n, IntConsumer action) {
for(int i = 0; i < n; i++) {
action.accept(i);
}
}

public class Application {
public void doWork() {
Runnable runner = () -> System.out.println(this.toString());
}
}

for(int i = 0; i < n; i++) {
new Thread(() -> System.out.println(i)).start();
}

public static Comparator<String> foo(Comparator<String> comp) {
return (x, y) -> comp.compare(y, x);
}

public class Indecision {
public static void main(String[] args) {
System.out.println(decision());
}
static boolean decision() {
try {
return true;
}
finally {
return false;
}
}
}

public final class SuperThread {
public static void main(String[] args) {
System.out.print("1 ");
new SuperThread().startMyThread();
System.out.print("3 ");
}
private void startMyThread() {
Runnable task = () -> sleep(1);
Thread thread = new Thread(task);
thread.start();
}
private void sleep(long seconds) {
try {
Thread.sleep(seconds * 1000L);
System.out.print("2 ");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

Runnable task = () -> { ... };
ExecutorService executor = ...;
executor.execute(task);

Thread, Runnable und ExecutorService

ExecutorService executor = Executors.newCachedThreadPool();
Welche Aussage ist korrekt?
Die Factory-Methode newCachedThreadPool erzeugt einen ExecutorService, der
optimiert ist für....

ExecutorService executor = Executors.newFixedThreadPool(10);
Callable<Integer> task = () -> 42;

static int count = 0;
Betrachten wir das Statement:
count++;
Dieses Statement wird hinter der Kulissen - auf CPU Ebene - so ausgeführt:
register = count + 1; // Zeile 1
count = register; // Zeile 2
Welche Aussage ist korrekt?

Locking ist ein Mechanismus, welcher zu einer gegebenen Zeit t ...

Im folgenden schauen wir Strategien für 'Safe Concurrency' an.
Welcher der folgenden Begriffe gehört nicht zu diesen Strategien?

Map<String, Integer> map = new HashMap<>();
map.compute(word, (k, v) -> v == null ? 1 : v + 1);

public class Confusing {
private Confusing(Object o) {
System.out.println("object");
}
private Confusing(double[] dArray) {
System.out.println("double array");
}
public static void main(String[] args) {
new Confusing(null);
}
}