The more we work with Java 8, the more we go into the rabbit hole. Did they add all those streams, lambdas, monads, Optionals and CompletableFutures only to confuse us? It surely looks so! And Java 9 that heads our way brings even more of what we like the most, more puzzlers, of course! In this season we as usual have a great batch of the best Java WTF, great jokes to present them and great prizes for the winners!

1. This slide is intentionally left
blank

2. JAVA PUZZLERS NG
DOWN THE RABBIT HOLEhttp://www.davidfloresmedia.com/philly-rocky-statue/

3. @gAmUssA @hazelcast #jbreak #hazelcastjet
> whoami

4. @gAmUssA @hazelcast #jbreak #hazelcastjet
Solutions Architect
> whoami

5. @gAmUssA @hazelcast #jbreak #hazelcastjet
Solutions Architect
Developer Advocate
> whoami

6. @gAmUssA @hazelcast #jbreak #hazelcastjet
Solutions Architect
Developer Advocate
@gamussa in internetz
> whoami

7. @gAmUssA @hazelcast #jbreak #hazelcastjet
Solutions Architect
Developer Advocate
@gamussa in internetz
Please, follow me on Twitter
> whoami

8. @gAmUssA @hazelcast #jbreak #hazelcastjet
Solutions Architect
Developer Advocate
@gamussa in internetz
Please, follow me on Twitter
I’m very interesting ©
> whoami

11. Developer Advocate @JFrog
on the internetz
Developer Advocate @Hazelcast
@gAmUssA on the internetz

12. CLICK AND HACK
THE TYPE-IT BROTHERS

13. @tagir_valeev
@gamussa #PhillyETE

14. @gamussa #PhillyETE

15. @gamussa #PhillyETE

16. @gamussa #PhillyETE

18. 1. Two One entertaining guy on
the stage

19. 1. Two One entertaining guy on
the stage
2. Funny puzzling questions

20. 1. Two One entertaining guy on
the stage
2. Funny puzzling questions
3. You think and vote

21. 1. Two One entertaining guy on
the stage
2. Funny puzzling questions
3. You think and vote
4.Official twitter hashtags
#javapuzzlersng #PhillyETE

22. FIRST RULE OF THE PUZZLERS:
NO CHEATING!

23. Which Java version are you on?
@gamussa #PhillyETE

24. Which Java version are you on?
A. Java 7
@gamussa #PhillyETE

25. Which Java version are you on?
A. Java 7
B. Java 8
@gamussa #PhillyETE

26. Which Java version are you on?
A. Java 7
B. Java 8
C. Java 9
@gamussa #PhillyETE

27. Which Java version are you on?
A. Java 7
B. Java 8
C. Java 9
D. Java 6
@gamussa #PhillyETE

28. Which Java version are you on?
A. Java 7
B. Java 8
C. Java 9
D. Java 6
E. Java 5
@gamussa #PhillyETE

29. Which Java version are you on?
A. Java 7
B. Java 8
C. Java 9
D. Java 6
E. Java 5
F. Java 2
@gamussa #PhillyETE

30. Which Java version are you on?
A. Java 7
B. Java 8
C. Java 9
D. Java 6
E. Java 5
F. Java 2
@gamussa #PhillyETE

31. Watching the puzzlers like… #dafaq
@gamussa #PhillyETE

32. Watching the puzzlers like… #dafaq
@gamussa #PhillyETE

33. Everything works (or doesn't)
in the latest Java 8 and/or 9 update
@gamussa #PhillyETE

35. RUSSIAN HACKERS
HACKING THE BANK

36. public class PerfectRobbery {
private Semaphore bankAccount = new Semaphore(-42);
public static void main(String[] args) {
PerfectRobbery perfectRobbery = new PerfectRobbery();
perfectRobbery.takeAllMoney();
perfectRobbery.checkBalance();
}
public void takeAllMoney(){
bankAccount.drainPermits();
}
public void checkBalance(){
System.out.println(bankAccount.availablePermits());
}
}

37. public class PerfectRobbery {
private Semaphore bankAccount = new Semaphore(-42);
public static void main(String[] args) {
PerfectRobbery perfectRobbery = new PerfectRobbery();
perfectRobbery.takeAllMoney();
perfectRobbery.checkBalance();
}
public void takeAllMoney(){
bankAccount.drainPermits();
}
public void checkBalance(){
System.out.println(bankAccount.availablePermits());
}
}
A. IllegalArgumentException – can’t create semaphore with negative

38. public class PerfectRobbery {
private Semaphore bankAccount = new Semaphore(-42);
public static void main(String[] args) {
PerfectRobbery perfectRobbery = new PerfectRobbery();
perfectRobbery.takeAllMoney();
perfectRobbery.checkBalance();
}
public void takeAllMoney(){
bankAccount.drainPermits();
}
public void checkBalance(){
System.out.println(bankAccount.availablePermits());
}
}
A. IllegalArgumentException – can’t create semaphore with negative
B. UnsupportedOperationException – can’t drain when negative

39. public class PerfectRobbery {
private Semaphore bankAccount = new Semaphore(-42);
public static void main(String[] args) {
PerfectRobbery perfectRobbery = new PerfectRobbery();
perfectRobbery.takeAllMoney();
perfectRobbery.checkBalance();
}
public void takeAllMoney(){
bankAccount.drainPermits();
}
public void checkBalance(){
System.out.println(bankAccount.availablePermits());
}
}
A. IllegalArgumentException – can’t create semaphore with negative
B. UnsupportedOperationException – can’t drain when negative
C. 0

40. public class PerfectRobbery {
private Semaphore bankAccount = new Semaphore(-42);
public static void main(String[] args) {
PerfectRobbery perfectRobbery = new PerfectRobbery();
perfectRobbery.takeAllMoney();
perfectRobbery.checkBalance();
}
public void takeAllMoney(){
bankAccount.drainPermits();
}
public void checkBalance(){
System.out.println(bankAccount.availablePermits());
}
}
A. IllegalArgumentException – can’t create semaphore with negative
B. UnsupportedOperationException – can’t drain when negative
C. 0
D. -42

41. public class PerfectRobbery {
private Semaphore bankAccount = new Semaphore(-42);
public static void main(String[] args) {
PerfectRobbery perfectRobbery = new PerfectRobbery();
perfectRobbery.takeAllMoney();
perfectRobbery.checkBalance();
}
public void takeAllMoney(){
bankAccount.drainPermits();
}
public void checkBalance(){
System.out.println(bankAccount.availablePermits());
}
}
A. IllegalArgumentException – can’t create semaphore with negative
B. UnsupportedOperationException – can’t drain when negative
C. 0
D. -42

42. @gamussa #PhillyETE

43. @gamussa #PhillyETE

44. @gamussa #PhillyETE

45. A. IllegalArgumentException – can’t create semaphore with negative
B. UnsupportedOperationException – can’t drain when negative
C. 0
D. -42
public class PerfectRobbery {
private Semaphore bankAccount = new Semaphore(-42);
public static void main(String[] args) {
PerfectRobbery perfectRobbery = new PerfectRobbery();
perfectRobbery.takeAllMoney();
perfectRobbery.checkBalance();
}
public void takeAllMoney(){
bankAccount.drainPermits();
}
public void checkBalance(){
System.out.println(bankAccount.availablePermits());
}
}

46. @gamussa #PhillyETE

47. @gamussa #PhillyETE

48. @gamussa #PhillyETE

49. Available
-42?!
@gamussa #PhillyETE

50. Available
-42?!
@gamussa #PhillyETE

51. @gamussa #PhillyETE

52. Collections.emptyList() == Collections.emptyList();
Collections.emptyIterator() == Collections.emptyIterator();
@gamussa #PhillyETE

53. A. true/true
Collections.emptyList() == Collections.emptyList();
Collections.emptyIterator() == Collections.emptyIterator();
@gamussa #PhillyETE

54. A. true/true
B. true/false
Collections.emptyList() == Collections.emptyList();
Collections.emptyIterator() == Collections.emptyIterator();
@gamussa #PhillyETE

55. A. true/true
B. true/false
C. false/true
Collections.emptyList() == Collections.emptyList();
Collections.emptyIterator() == Collections.emptyIterator();
@gamussa #PhillyETE

56. A. true/true
B. true/false
C. false/true
D. false/false
Collections.emptyList() == Collections.emptyList();
Collections.emptyIterator() == Collections.emptyIterator();
@gamussa #PhillyETE

57. A. true/true
B. true/false
C. false/true
D. false/false
Collections.emptyList() == Collections.emptyList();
Collections.emptyIterator() == Collections.emptyIterator();
@gamussa #PhillyETE

58. @gamussa #PhillyETE

59. @gamussa #PhillyETE

60. Spliterators.emptySpliterator() == Spliterators.emptySpliterator();
Stream.empty() == Stream.empty();

61. A. true/true
Spliterators.emptySpliterator() == Spliterators.emptySpliterator();
Stream.empty() == Stream.empty();

62. A. true/true
B. true/false
Spliterators.emptySpliterator() == Spliterators.emptySpliterator();
Stream.empty() == Stream.empty();

63. A. true/true
B. true/false
C. false/true
Spliterators.emptySpliterator() == Spliterators.emptySpliterator();
Stream.empty() == Stream.empty();

64. A. true/true
B. true/false
C. false/true
D. false/false
Spliterators.emptySpliterator() == Spliterators.emptySpliterator();
Stream.empty() == Stream.empty();

65. A. true/true
B. true/false
C. false/true
D. false/false
Spliterators.emptySpliterator() == Spliterators.emptySpliterator();
Stream.empty() == Stream.empty();

66. Singleton Strikes Back!
@gamussa #PhillyETE

67. Singleton Strikes Back!
@gamussa #PhillyETE

68. A. true/true
B. true/false
C. false/true
D. false/false
Spliterators.emptySpliterator() == Spliterators.emptySpliterator();
Stream.empty() == Stream.empty();
@gamussa #PhillyETE

69. Even empty Stream has state!
@gamussa #PhillyETE

70. Even empty Stream has state!
@gamussa #PhillyETE

71. Even empty Stream has state!
@gamussa #PhillyETE

73. ”Identical”
1. Has the same state
2. Not related to “equals and hashcode” contract
3. Not related to references to objects in
memory
@gamussa #PhillyETE

74. List[] twins = new List[2];
Arrays.setAll(twins, ArrayList::new);
@gamussa #PhillyETE

75. List[] twins = new List[2];
Arrays.setAll(twins, ArrayList::new);
A. Absolutely identical empty lists
@gamussa #PhillyETE

76. List[] twins = new List[2];
Arrays.setAll(twins, ArrayList::new);
A. Absolutely identical empty lists
B. Absolutely identical non-empty lists
@gamussa #PhillyETE

77. List[] twins = new List[2];
Arrays.setAll(twins, ArrayList::new);
A. Absolutely identical empty lists
B. Absolutely identical non-empty lists
C. Non-identical empty lists
@gamussa #PhillyETE

78. List[] twins = new List[2];
Arrays.setAll(twins, ArrayList::new);
A. Absolutely identical empty lists
B. Absolutely identical non-empty lists
C. Non-identical empty lists
D. Non-identical non-empty lists
@gamussa #PhillyETE

79. List[] twins = new List[2];
Arrays.setAll(twins, ArrayList::new);
A. Absolutely identical empty lists
B. Absolutely identical non-empty lists
C. Non-identical empty lists
D. Non-identical non-empty lists
@gamussa #PhillyETE

80. @gamussa #PhillyETE

81. @gamussa #PhillyETE

82. List[] twins = new List[2];
Arrays.setAll(twins, ArrayList::new);
A. Absolutely identical empty lists
B. Absolutely identical non-empty lists
C. Non-identical empty lists
D. Non-identical non-empty lists
@gamussa #PhillyETE

83. @gamussa #PhillyETE

84. @gamussa #PhillyETE

85. @gamussa #PhillyETE

86. How single is a Single Abstract Method
Interface?
@gamussa #PhillyETE

87. public interface Single<T> {
default void partyHard(String songName) { System.out.println(songName); }
void partyHard(T songName);
void drinkIn(T drinkName);
void drinkIn(String dringName);
}
@FunctionalInterface
public interface SingleAndHappy extends Single<String> { }
@gamussa #PhillyETE

88. A. WTF?! ’Single’ means one, not three!
public interface Single<T> {
default void partyHard(String songName) { System.out.println(songName); }
void partyHard(T songName);
void drinkIn(T drinkName);
void drinkIn(String dringName);
}
@FunctionalInterface
public interface SingleAndHappy extends Single<String> { }
@gamussa #PhillyETE

89. A. WTF?! ’Single’ means one, not three!
B. Problem is with partyHard(T), remove it and it will work
public interface Single<T> {
default void partyHard(String songName) { System.out.println(songName); }
void partyHard(T songName);
void drinkIn(T drinkName);
void drinkIn(String dringName);
}
@FunctionalInterface
public interface SingleAndHappy extends Single<String> { }
@gamussa #PhillyETE

90. A. WTF?! ’Single’ means one, not three!
B. Problem is with partyHard(T), remove it and it will work
C. Problem is the drinkIn methods, removing one of them and it will
work
public interface Single<T> {
default void partyHard(String songName) { System.out.println(songName); }
void partyHard(T songName);
void drinkIn(T drinkName);
void drinkIn(String dringName);
}
@FunctionalInterface
public interface SingleAndHappy extends Single<String> { }
@gamussa #PhillyETE

91. A. WTF?! ’Single’ means one, not three!
B. Problem is with partyHard(T), remove it and it will work
C. Problem is the drinkIn methods, removing one of them and it will
work
D. It will work fine! Both partyHard() and drinkIn() are merged in
SingleAndHappy, leaving one abstract method
public interface Single<T> {
default void partyHard(String songName) { System.out.println(songName); }
void partyHard(T songName);
void drinkIn(T drinkName);
void drinkIn(String dringName);
}
@FunctionalInterface
public interface SingleAndHappy extends Single<String> { }
@gamussa #PhillyETE

92. A. WTF?! ’Single’ means one, not three!
B. Problem is with partyHard(T), remove it and it will work
C. Problem is the drinkIn methods, removing one of them and it will
work
D. It will work fine! Both partyHard() and drinkIn() are merged in
SingleAndHappy, leaving one abstract method
public interface Single<T> {
default void partyHard(String songName) { System.out.println(songName); }
void partyHard(T songName);
void drinkIn(T drinkName);
void drinkIn(String dringName);
}
@FunctionalInterface
public interface SingleAndHappy extends Single<String> { }
@gamussa #PhillyETE

95. A. WTF?! ’Single’ means one, not three!
B. Problem is with partyHard(T), remove it and it will work
C. Problem are the drinkIn methods, removing it will leave one
abstract method
D. Yes! Both partyHard() and drinkIn() are merged in SingleAndHappy,
leaving one abstract method
public interface Single<T> {
default void partyHard(String songName) { System.out.println(songName); }
void partyHard(T songName);
void drinkIn(T drinkName);
void drinkIn(String dringName);
}
@FunctionalInterface
public interface SingleAndHappy extends Single<String> { }
@gamussa #PhillyETE

96. @gamussa #PhillyETE

97. RUSSIAN HACKERS
STILL TRYING TO HACK THE BANK

98. Hacking the bank
☑Bank software written in Java
☑Hack into it
☑Analyze the accounts
@gamussa #PhillyETE

99. Given the code above, which statement is wrong:
Set<String> accounts= new HashSet<>(Arrays.asList("Gates", "Buffett", "Bezos", "Zuckerberg"));
System.out.println(”accounts= " + accounts);
@gamussa #PhillyETE

100. Given the code above, which statement is wrong:
A. The Set is ordered by hashcode
Set<String> accounts= new HashSet<>(Arrays.asList("Gates", "Buffett", "Bezos", "Zuckerberg"));
System.out.println(”accounts= " + accounts);
@gamussa #PhillyETE

101. Given the code above, which statement is wrong:
A. The Set is ordered by hashcode
B. The order is predictable across multiple runs of the JVM on the same machine
Set<String> accounts= new HashSet<>(Arrays.asList("Gates", "Buffett", "Bezos", "Zuckerberg"));
System.out.println(”accounts= " + accounts);
@gamussa #PhillyETE

102. Given the code above, which statement is wrong:
A. The Set is ordered by hashcode
B. The order is predictable across multiple runs of the JVM on the same machine
C. The order of elements in Set is not predictable
Set<String> accounts= new HashSet<>(Arrays.asList("Gates", "Buffett", "Bezos", "Zuckerberg"));
System.out.println(”accounts= " + accounts);
@gamussa #PhillyETE

103. Given the code above, which statement is wrong:
A. The Set is ordered by hashcode
B. The order is predictable across multiple runs of the JVM on the same machine
C. The order of elements in Set is not predictable
D. Statements A & B are correct
Set<String> accounts= new HashSet<>(Arrays.asList("Gates", "Buffett", "Bezos", "Zuckerberg"));
System.out.println(”accounts= " + accounts);
@gamussa #PhillyETE

104. Given the code above, which statement is wrong:
A. The Set is ordered by hashcode
B. The order is predictable across multiple runs of the JVM on the same machine
C. The order of elements in Set is not predictable
D. Statements A & B are correct
Set<String> accounts= new HashSet<>(Arrays.asList("Gates", "Buffett", "Bezos", "Zuckerberg"));
System.out.println(”accounts= " + accounts);
@gamussa #PhillyETE

107. Given the code above, which statement is wrong:
A. The Set is ordered
B. The order is predictable across multiple runs of the JVM on the same machine
C. The order of elements in Set is not predictable
D. Statements A & B are correct
Set<String> accounts= new HashSet<>(Arrays.asList("Gates", "Buffett", "Bezos", "Zuckerberg"));
System.out.println(”accounts= " + accounts);
@gamussa #PhillyETE

108. public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
@gamussa #PhillyETE

109. Your turn, FBI
@gamussa #PhillyETE

111. Given the code above, which statement is wrong:
Set<String> accounts = Set.of("Gates", "Buffett", "Bezos", "Zuckerberg");
System.out.println(”accounts= " + accounts);
@gamussa #PhillyETE

112. Given the code above, which statement is wrong:
A. The Set is ordered
Set<String> accounts = Set.of("Gates", "Buffett", "Bezos", "Zuckerberg");
System.out.println(”accounts= " + accounts);
@gamussa #PhillyETE

113. Given the code above, which statement is wrong:
A. The Set is ordered
B. The order is predictable across multiple runs of the JVM on the same machine
Set<String> accounts = Set.of("Gates", "Buffett", "Bezos", "Zuckerberg");
System.out.println(”accounts= " + accounts);
@gamussa #PhillyETE

114. Given the code above, which statement is wrong:
A. The Set is ordered
B. The order is predictable across multiple runs of the JVM on the same machine
C. The order of elements in Set is not predictable
Set<String> accounts = Set.of("Gates", "Buffett", "Bezos", "Zuckerberg");
System.out.println(”accounts= " + accounts);
@gamussa #PhillyETE

115. Given the code above, which statement is wrong:
A. The Set is ordered
B. The order is predictable across multiple runs of the JVM on the same machine
C. The order of elements in Set is not predictable
D. Statements A & B are correct
Set<String> accounts = Set.of("Gates", "Buffett", "Bezos", "Zuckerberg");
System.out.println(”accounts= " + accounts);
@gamussa #PhillyETE

116. Given the code above, which statement is wrong:
A. The Set is ordered
B. The order is predictable across multiple runs of the JVM on the same machine
C. The order of elements in Set is not predictable
D. Statements A & B are correct
Set<String> accounts = Set.of("Gates", "Buffett", "Bezos", "Zuckerberg");
System.out.println(”accounts= " + accounts);
@gamussa #PhillyETE

117. @gamussa #PhillyETE

118. @gamussa #PhillyETE

119. @gamussa #PhillyETE

120. Given the code above, which statement is wrong:
A. The Set is ordered
B. The order is predictable across multiple runs of the JVM on the same machine
C. The order of elements in Set is not predictable
D. Statements A & B are correct
Set<String> accounts = Set.of("Gates", "Buffett", "Bezos", "Zuckerberg");
System.out.println(”accounts= " + accounts);
@gamussa #PhillyETE

121. private int probe(Object pe) {
int idx = Math.floorMod(pe.hashCode() ^ SALT,
elements.length);
while (true) {
E ee = elements[idx];
if (ee == null) {
return -idx - 1;
} else if (pe.equals(ee)) {
return idx;
} else if (++idx == elements.length) {
idx = 0;
}
}
}
@gamussa #PhillyETE

122. Juggling Accident

123. Juggling Accident

124. What’s correct?
@gamussa #PhillyETE

125. What’s correct?
A. If you convert your application to module, classpath
dependencies will still be resolved correctly
@gamussa #PhillyETE

126. What’s correct?
A. If you convert your application to module, classpath
dependencies will still be resolved correctly
B. If one of the dependencies was converted to a module,
you have to declare it in module-info in order to use
@gamussa #PhillyETE

127. What’s correct?
A. If you convert your application to module, classpath
dependencies will still be resolved correctly
B. If one of the dependencies was converted to a module,
you have to declare it in module-info in order to use
C. Once you added the module-info to your project you
have to declare the dependencies twice, in classpath
and in module-info
@gamussa #PhillyETE

128. What’s correct?
A. If you convert your application to module, classpath
dependencies will still be resolved correctly
B. If one of the dependencies was converted to a module,
you have to declare it in module-info in order to use
C. Once you added the module-info to your project you
have to declare the dependencies twice, in classpath
and in module-info
D. None of the above
@gamussa #PhillyETE

129. What’s correct?
A. If you convert your application to module, classpath
dependencies will still be resolved correctly
B. If one of the dependencies was converted to a module,
you have to declare it in module-info in order to use
C. Once you added the module-info to your project you
have to declare the dependencies twice, in classpath
and in module-info
D. None of the above
@gamussa #PhillyETE

132. What’s correct?
A. If you convert your application to module, classpath
dependencies will still be resolved correctly
B. If one of the dependencies was converted to a module,
you have to declare it in module-info in order to use
C. Once you added the module-info to your project you
have to declare the dependencies twice, in classpath
and in module-info
D. None of the above
@gamussa #PhillyETE

133. @gamussa #PhillyETE

134. @gamussa #PhillyETE

136. static void killThemAll(Collection<Hero> expendables) {
Iterator<Hero> heroes = expendables.iterator();
heroes.forEachRemaining(e -> {
if (heroes.hasNext()) {
heroes.next();
heroes.remove();
}
});
System.out.println(expendables);
}

137. A. You killed them all
static void killThemAll(Collection<Hero> expendables) {
Iterator<Hero> heroes = expendables.iterator();
heroes.forEachRemaining(e -> {
if (heroes.hasNext()) {
heroes.next();
heroes.remove();
}
});
System.out.println(expendables);
}

138. A. You killed them all
B. You killed only even ones
static void killThemAll(Collection<Hero> expendables) {
Iterator<Hero> heroes = expendables.iterator();
heroes.forEachRemaining(e -> {
if (heroes.hasNext()) {
heroes.next();
heroes.remove();
}
});
System.out.println(expendables);
}

139. A. You killed them all
B. You killed only even ones
C. They all survived
static void killThemAll(Collection<Hero> expendables) {
Iterator<Hero> heroes = expendables.iterator();
heroes.forEachRemaining(e -> {
if (heroes.hasNext()) {
heroes.next();
heroes.remove();
}
});
System.out.println(expendables);
}

140. A. You killed them all
B. You killed only even ones
C. They all survived
D. You killed only odd ones
static void killThemAll(Collection<Hero> expendables) {
Iterator<Hero> heroes = expendables.iterator();
heroes.forEachRemaining(e -> {
if (heroes.hasNext()) {
heroes.next();
heroes.remove();
}
});
System.out.println(expendables);
}

141. A. You killed them all
B. You killed only even ones
C. They all survived
D. You killed only odd ones
E. All answers are correct
static void killThemAll(Collection<Hero> expendables) {
Iterator<Hero> heroes = expendables.iterator();
heroes.forEachRemaining(e -> {
if (heroes.hasNext()) {
heroes.next();
heroes.remove();
}
});
System.out.println(expendables);
}

142. A. You killed them all
B. You killed only even ones
C. They all survived
D. You killed only odd ones
E. All answers are correct
static void killThemAll(Collection<Hero> expendables) {
Iterator<Hero> heroes = expendables.iterator();
heroes.forEachRemaining(e -> {
if (heroes.hasNext()) {
heroes.next();
heroes.remove();
}
});
System.out.println(expendables);
}

143. @gamussa #PhillyETE

144. @gamussa #PhillyETE

145. A. You killed them all
B. You killed only even ones
C. They all survived
D. You killed only odd ones
E. All answers are correct
static void killThemAll(Collection<Hero> expendables) {
Iterator<Hero> heroes = expendables.iterator();
heroes.forEachRemaining(e -> {
if (heroes.hasNext()) {
heroes.next();
heroes.remove();
}
});
System.out.println(expendables);
}

146. Don’t do that. Really, don’t.
@gamussa #PhillyETE

147. Don’t do that. Really, don’t.
killThemAll(new ArrayList<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[]
@gamussa #PhillyETE

148. Don’t do that. Really, don’t.
killThemAll(new ArrayList<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[]
killThemAll(new LinkedList<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
@gamussa #PhillyETE

149. Don’t do that. Really, don’t.
killThemAll(new ArrayList<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[]
killThemAll(new LinkedList<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[S,S,S,V]
@gamussa #PhillyETE

150. Don’t do that. Really, don’t.
killThemAll(new ArrayList<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[]
killThemAll(new LinkedList<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[S,S,S,V]
killThemAll(new ArrayDeque<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[N,S,W,S,L,S,L,V]
@gamussa #PhillyETE

151. Don’t do that. Really, don’t.
killThemAll(new ArrayList<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[]
killThemAll(new LinkedList<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[S,S,S,V]
killThemAll(new ArrayDeque<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[N,S,W,S,L,S,L,V]
@gamussa #PhillyETE

152. Don’t do that. Really, don’t.
killThemAll(new ArrayList<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[]
killThemAll(new LinkedList<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[S,S,S,V]
killThemAll(new ArrayDeque<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[N,S,W,S,L,S,L,V]
killThemAll(new TreeSet<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
@gamussa #PhillyETE

153. Don’t do that. Really, don’t.
killThemAll(new ArrayList<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[]
killThemAll(new LinkedList<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[S,S,S,V]
killThemAll(new ArrayDeque<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[N,S,W,S,L,S,L,V]
killThemAll(new TreeSet<String>(Arrays.asList("N","S","W","S","L","S","L","V")));
[N,W,L,L]
@gamussa #PhillyETE

154. Subtle Difference
@gamussa #PhillyETE

155. @FunctionalInterface
public interface OriginalPredicate<T> {
boolean test(T t);
}
OriginalPredicate<Object> lambda = (Object obj) -> "adidas".equals(obj);
OriginalPredicate<Object> methodRef = "adidas"::equals;

156. A. Both work just fine
@FunctionalInterface
public interface OriginalPredicate<T> {
boolean test(T t);
}
OriginalPredicate<Object> lambda = (Object obj) -> "adidas".equals(obj);
OriginalPredicate<Object> methodRef = "adidas"::equals;

157. A. Both work just fine
B. Lambda works, method ref fails
@FunctionalInterface
public interface OriginalPredicate<T> {
boolean test(T t);
}
OriginalPredicate<Object> lambda = (Object obj) -> "adidas".equals(obj);
OriginalPredicate<Object> methodRef = "adidas"::equals;

158. A. Both work just fine
B. Lambda works, method ref fails
C. Method ref works, lambda fails
@FunctionalInterface
public interface OriginalPredicate<T> {
boolean test(T t);
}
OriginalPredicate<Object> lambda = (Object obj) -> "adidas".equals(obj);
OriginalPredicate<Object> methodRef = "adidas"::equals;

159. A. Both work just fine
B. Lambda works, method ref fails
C. Method ref works, lambda fails
D. Won’t compile
@FunctionalInterface
public interface OriginalPredicate<T> {
boolean test(T t);
}
OriginalPredicate<Object> lambda = (Object obj) -> "adidas".equals(obj);
OriginalPredicate<Object> methodRef = "adidas"::equals;

160. A. Both work just fine
B. Lambda works, method ref fails
C. Method ref works, lambda fails
D. Won’t compile
@FunctionalInterface
public interface OriginalPredicate<T> {
boolean test(T t);
}
OriginalPredicate<Object> lambda = (Object obj) -> "adidas".equals(obj);
OriginalPredicate<Object> methodRef = "adidas"::equals;

163. A. Both work just fine
B. Lambda works, method ref fails
C. Method ref works, lambda fails
D. Not a functional interface, will fail on annotation processing
@FunctionalInterface
public interface CopyCatPredicate {
<T> boolean test(T t);
}
CopyCatPredicate lambda = (Object obj) -> "adadas".equals(obj);
CopyCatPredicate methodRef = "adadas"::equals;

164. A. Both work just fine
B. Lambda works, method ref fails
C. Method ref works, lambda fails
D. Not a functional interface, will fail on annotation processing
@FunctionalInterface
public interface CopyCatPredicate {
<T> boolean test(T t);
}
CopyCatPredicate lambda = (Object obj) -> "adadas".equals(obj);
CopyCatPredicate methodRef = "adadas"::equals;

168. A. Both work just fine
B. Lambda works, method ref fails
C. Method ref works, lambda fails
D. Not a functional interface, will fail on annotation processing
@FunctionalInterface
public interface CopyCatPredicate {
<T> boolean test(T t);
}
CopyCatPredicate lambda = (Object obj) -> "adadas".equals(obj);
CopyCatPredicate methodRef = "adadas"::equals;

169. @gamussa #PhillyETE

170. A generic function type for a functional interface may be implemented by a
method reference expression (§15.13), but not by a lambda expression
(§15.27) as there is no syntax for generic lambda expressions.
“
@gamussa #PhillyETE

172. List<String> list = Stream.of("Spock", "Kirk", "Data", "Data", "Kirk",
"Spock").sequential()
.filter(new TreeSet<>()::add).collect(Collectors.toList());
System.out.println(list);
@gamussa #PhillyETE

173. A.[Data, Kirk, Spock]
List<String> list = Stream.of("Spock", "Kirk", "Data", "Data", "Kirk",
"Spock").sequential()
.filter(new TreeSet<>()::add).collect(Collectors.toList());
System.out.println(list);
@gamussa #PhillyETE

174. A.[Data, Kirk, Spock]
B.[Spock, Kirk, Data, Data, Kirk, Spock]
List<String> list = Stream.of("Spock", "Kirk", "Data", "Data", "Kirk",
"Spock").sequential()
.filter(new TreeSet<>()::add).collect(Collectors.toList());
System.out.println(list);
@gamussa #PhillyETE

175. A.[Data, Kirk, Spock]
B.[Spock, Kirk, Data, Data, Kirk, Spock]
C.[Spock, Kirk, Data]
List<String> list = Stream.of("Spock", "Kirk", "Data", "Data", "Kirk",
"Spock").sequential()
.filter(new TreeSet<>()::add).collect(Collectors.toList());
System.out.println(list);
@gamussa #PhillyETE

176. A.[Data, Kirk, Spock]
B.[Spock, Kirk, Data, Data, Kirk, Spock]
C.[Spock, Kirk, Data]
D.[Data, Data, Kirk, Kirk, Spock, Spock]
List<String> list = Stream.of("Spock", "Kirk", "Data", "Data", "Kirk",
"Spock").sequential()
.filter(new TreeSet<>()::add).collect(Collectors.toList());
System.out.println(list);
@gamussa #PhillyETE

177. A.[Data, Kirk, Spock]
B.[Spock, Kirk, Data, Data, Kirk, Spock]
C.[Spock, Kirk, Data]
D.[Data, Data, Kirk, Kirk, Spock, Spock]
E.Are you nuts? Won’t compile! Data with Kirk?!
List<String> list = Stream.of("Spock", "Kirk", "Data", "Data", "Kirk",
"Spock").sequential()
.filter(new TreeSet<>()::add).collect(Collectors.toList());
System.out.println(list);
@gamussa #PhillyETE

180. A.[Data, Kirk, Spock]
B.[Spock, Kirk, Data, Data, Kirk, Spock]
C.[Spock, Kirk, Data]
D.[Data, Data, Kirk, Kirk, Spock, Spock]
E.Are you nuts? Won’t compile! Data with Kirk?!
List<String> list = Stream.of("Spock", "Kirk", "Data", "Data", "Kirk",
"Spock").sequential()
.filter(new TreeSet<>()::add).collect(Collectors.toList());
System.out.println(list);
@gamussa #PhillyETE

181. A.[Data, Kirk, Spock]
B.[Spock, Kirk, Data, Data, Kirk, Spock]
C.[Spock, Kirk, Data]
D.[Data, Data, Kirk, Kirk, Spock, Spock]
E.Are you nuts? Won’t compile! Data with Kirk?!
List<String> list = Stream.of("Spock", "Kirk", "Data", "Data", "Kirk",
"Spock").sequential()
.filter(new TreeSet<>()::add).collect(Collectors.toList());
System.out.println(list);
@gamussa #PhillyETE

184. A.[Data, Kirk, Spock]
B.[Spock, Kirk, Data, Data, Kirk, Spock]
C.[Spock, Kirk, Data]
D.[Data, Data, Kirk, Kirk, Spock, Spock]
E.Are you nuts? Won’t compile! Data with Kirk?!
List<String> list = Stream.of("Spock", "Kirk", "Data", "Data", "Kirk",
"Spock").sequential()
.filter(new TreeSet<>()::add).collect(Collectors.toList());
System.out.println(list);
@gamussa #PhillyETE

185. @gamussa #PhillyETE

186. filter(new TreeSet<>()::add)
@gamussa #PhillyETE

187. filter(new TreeSet<>()::add) filter(i -> new TreeSet<>().add(i))
@gamussa #PhillyETE

188. filter(new TreeSet<>()::add) filter(i -> new TreeSet<>().add(i))!=
@gamussa #PhillyETE

189. filter(new TreeSet<>()::add) filter(i -> new TreeSet<>().add(i))!=
New instance is
created every time!
@gamussa #PhillyETE

190. filter(new TreeSet<>()::add) filter(i -> new TreeSet<>().add(i))!=
New instance is
created every time!
Instance method is
created once!
@gamussa #PhillyETE

191. @gamussa #PhillyETE

192. Optional.of("obvious").orElseGet(null);
Optional.empty().map(null).orElse("obvious");
@gamussa #PhillyETE

193. A. obvious / obvious
Optional.of("obvious").orElseGet(null);
Optional.empty().map(null).orElse("obvious");
@gamussa #PhillyETE

194. A. obvious / obvious
B. obvious / NullPointerException
Optional.of("obvious").orElseGet(null);
Optional.empty().map(null).orElse("obvious");
@gamussa #PhillyETE

195. A. obvious / obvious
B. obvious / NullPointerException
C. NullPointerException / obvious
Optional.of("obvious").orElseGet(null);
Optional.empty().map(null).orElse("obvious");
@gamussa #PhillyETE

196. A. obvious / obvious
B. obvious / NullPointerException
C. NullPointerException / obvious
D. NullPointerException / NullPointerException
Optional.of("obvious").orElseGet(null);
Optional.empty().map(null).orElse("obvious");
@gamussa #PhillyETE

197. @gamussa #PhillyETE

198. @gamussa #PhillyETE

199. A. obvious / obvious
B. obvious / NullPointerException
C. NullPointerException / obvious
D. NullPointerException / NullPointerException
Optional.of("obvious").orElseGet(null);
Optional.empty().map(null).orElse("obvious");
@gamussa #PhillyETE

200. A. obvious / obvious
B. obvious / NullPointerException
C. NullPointerException / obvious
D. NullPointerException / NullPointerException
Optional.of("obvious").orElseGet(null);
Optional.empty().map(null).orElse("obvious");
Will never happen
@gamussa #PhillyETE

201. A. obvious / obvious
B. obvious / NullPointerException
C. NullPointerException / obvious
D. NullPointerException / NullPointerException
Optional.of("obvious").orElseGet(null);
Optional.empty().map(null).orElse("obvious");
Will never happen
Will never happen
@gamussa #PhillyETE

202. A. obvious / obvious
B. obvious / NullPointerException
C. NullPointerException / obvious
D. NullPointerException / NullPointerException
Optional.of("obvious").orElseGet(null);
Optional.empty().map(null).orElse("obvious");
Will never happen
Will never happen
@gamussa #PhillyETE

203. @gamussa #PhillyETE

204. @gamussa #PhillyETE

205. A. obvious / obvious
B. obvious / NullPointerException
C. NullPointerException / obvious
D. NullPointerException / NullPointerException
Optional.of("obvious").orElseGet(null);
Optional.empty().map(null).orElse("obvious");
@gamussa #PhillyETE

206. @gamussa #PhillyETE

207. @gamussa #PhillyETE

208. @gamussa #PhillyETE

209. @gamussa #PhillyETE

210. Identical?
@gamussa #PhillyETE

211. When agentA == agentB?

212. 1. Consumer<String> agentA = s -> System.out.println(s);
Consumer<String> agentB = s -> System.out.println(s);
When agentA == agentB?

213. 1. Consumer<String> agentA = s -> System.out.println(s);
Consumer<String> agentB = s -> System.out.println(s);
2. Consumer<String> agentA = System.out::println;
Consumer<String> agentB = System.out::println;
When agentA == agentB?

214. 1. Consumer<String> agentA = s -> System.out.println(s);
Consumer<String> agentB = s -> System.out.println(s);
2. Consumer<String> agentA = System.out::println;
Consumer<String> agentB = System.out::println;
3. Supplier<Consumer<String>> supplier = () -> s -> System.out.println(s);
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
When agentA == agentB?

215. 1. Consumer<String> agentA = s -> System.out.println(s);
Consumer<String> agentB = s -> System.out.println(s);
2. Consumer<String> agentA = System.out::println;
Consumer<String> agentB = System.out::println;
3. Supplier<Consumer<String>> supplier = () -> s -> System.out.println(s);
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
4. Supplier<Consumer<String>> supplier = () -> System.out::println;
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
When agentA == agentB?

216. A.All
1. Consumer<String> agentA = s -> System.out.println(s);
Consumer<String> agentB = s -> System.out.println(s);
2. Consumer<String> agentA = System.out::println;
Consumer<String> agentB = System.out::println;
3. Supplier<Consumer<String>> supplier = () -> s -> System.out.println(s);
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
4. Supplier<Consumer<String>> supplier = () -> System.out::println;
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
When agentA == agentB?

217. A.All
B.3 and 4
1. Consumer<String> agentA = s -> System.out.println(s);
Consumer<String> agentB = s -> System.out.println(s);
2. Consumer<String> agentA = System.out::println;
Consumer<String> agentB = System.out::println;
3. Supplier<Consumer<String>> supplier = () -> s -> System.out.println(s);
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
4. Supplier<Consumer<String>> supplier = () -> System.out::println;
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
When agentA == agentB?

218. A.All
B.3 and 4
C.Only 3
1. Consumer<String> agentA = s -> System.out.println(s);
Consumer<String> agentB = s -> System.out.println(s);
2. Consumer<String> agentA = System.out::println;
Consumer<String> agentB = System.out::println;
3. Supplier<Consumer<String>> supplier = () -> s -> System.out.println(s);
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
4. Supplier<Consumer<String>> supplier = () -> System.out::println;
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
When agentA == agentB?

219. A.All
B.3 and 4
C.Only 3
D.Other
1. Consumer<String> agentA = s -> System.out.println(s);
Consumer<String> agentB = s -> System.out.println(s);
2. Consumer<String> agentA = System.out::println;
Consumer<String> agentB = System.out::println;
3. Supplier<Consumer<String>> supplier = () -> s -> System.out.println(s);
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
4. Supplier<Consumer<String>> supplier = () -> System.out::println;
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
When agentA == agentB?

220. A.All
B.3 and 4
C.Only 3
D.Other
1. Consumer<String> agentA = s -> System.out.println(s);
Consumer<String> agentB = s -> System.out.println(s);
2. Consumer<String> agentA = System.out::println;
Consumer<String> agentB = System.out::println;
3. Supplier<Consumer<String>> supplier = () -> s -> System.out.println(s);
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
4. Supplier<Consumer<String>> supplier = () -> System.out::println;
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
When agentA == agentB?

221. @gamussa #PhillyETE

222. @gamussa #PhillyETE

223. A.All
B.3 and 4
C.Only 3
D.Other
1. Consumer<String> agentA = s -> System.out.println(s);
Consumer<String> agentB = s -> System.out.println(s);
2. Consumer<String> agentA = System.out::println;
Consumer<String> agentB = System.out::println;
3. Supplier<Consumer<String>> supplier = () -> s -> System.out.println(s);
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
4. Supplier<Consumer<String>> supplier = () -> System.out::println;
Consumer<String> agentA = supplier.get();
Consumer<String> agentB = supplier.get();
When agentA == agentB?

224. Reuse is only possible for pure functions
@gamussa #PhillyETE

225. Reuse is only possible for pure functions
Consumers accept parameters ==
have state
@gamussa #PhillyETE

226. Reuse is only possible for pure functions
Consumers accept parameters ==
have state
Supplier in 4 has state – the
resolved method reference
@gamussa #PhillyETE

227. Conclusions
@gamussa #PhillyETE

229. -Write readable code!

230. -Write readable code!
-Comment all the tricks

231. -Write readable code!
-Comment all the tricks
-Sometimes it’s just a bug

232. -Write readable code!
-Comment all the tricks
-Sometimes it’s just a bug
-Static code analysis FTW -
IntelliJ IDEA!

233. -Write readable code!
-Comment all the tricks
-Sometimes it’s just a bug
-Static code analysis FTW -
IntelliJ IDEA!
-RTFM!

234. -Write readable code!
-Comment all the tricks
-Sometimes it’s just a bug
-Static code analysis FTW -
IntelliJ IDEA!
-RTFM!
-Don’t abuse lambdas and
streams!

236. -Trust us, we have much
more where those came
from.

237. -Trust us, we have much
more where those came
from.
-Puzzlers? Gotchas? Fetal
position inducing behavior?

238. -Trust us, we have much
more where those came
from.
-Puzzlers? Gotchas? Fetal
position inducing behavior?
-puzzlers@jfrog.com

240. -Did you like it?

241. -Did you like it?
-Praise me on twitter!

242. -Did you like it?
-Praise me on twitter!
-#javapuzzlersng #PhillyETE

243. -Did you like it?
-Praise me on twitter!
-#javapuzzlersng #PhillyETE
-@gamussa

244. -Did you like it?
-Praise me on twitter!
-#javapuzzlersng #PhillyETE
-@gamussa
-Didn’t like it?

245. -Did you like it?
-Praise me on twitter!
-#javapuzzlersng #PhillyETE
-@gamussa
-Didn’t like it?
-/dev/null