A.double avg = numbers.stream().parallel().averagingDouble(a > a);

B.double avg = numbers.parallelStream().mapToInt (m > m).average().getAsDouble ();

C.double avg = numbers.stream().mapToInt (i > i).average().parallel();

D.double avg = numbers.stream().average().getAsDouble();

E.double avg = numbers.stream().collect(Collectors.averagingDouble(n > n));

A.Option D

B.Option A

C.Option B

D.Option C

A.public <T> Collection<T> foo(Stream<T> arg) { ... } overloads Foo.foo.

B.public <T> List<T> foo(Collection<T> arg) { ... } overrides Foo.foo.

C.public <T> Iterable<T> foo(Collection<T> arg) { ... } overrides Foo.foo.

D.public Collection<String> foo(Collection<String> arg) { ... } overrides Foo.foo.

E.public <T> Collection<T> foo(Collection<T> arg) { ... } overloads Foo.foo.

F.public <T> Collection<T> bar(Collection<T> arg) { ... } overloads Foo.foo.

A.An IllegalThreadStateException is thrown at run time.

B.Three threads are created.

C.The compilation fails.

D.Four threads are created.

A.public List<Integer> foo(Set<CharSequence> m) {...}

B.public ArrayList<Number> foo(Set<CharSequence> m) {...}

C.public ArrayList<Integer> foo(Set<String> m) {...}

D.public List<Integer> foo(TreeSet<String> m) {...}

E.public List<Object> foo(Set<CharSequence> m) {...}

F.public List<Number> foo(Set<String> m) {...}