Upgrade to Pro — share decks privately, control downloads, hide ads and more …

[Philly ETE] Java Puzzlers NG

[Philly ETE] Java Puzzlers NG

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!

0680be1c881abcf19219f09f1e8cf140?s=128

Viktor Gamov

April 18, 2017
Tweet

More Decks by Viktor Gamov

Other Decks in Programming

Transcript

  1. This slide is intentionally left blank

  2. JAVA PUZZLERS NG DOWN THE RABBIT HOLE http://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
  9. None
  10. None
  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

  17. None
  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
  34. None
  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

  72. None
  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
  93. None
  94. None
  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
  105. None
  106. None
  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

  110. None
  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
  130. None
  131. None
  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

  135. None
  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;
  161. None
  162. None
  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;

  165. None
  166. None
  167. None
  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
  171. None
  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
  178. None
  179. None
  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
  182. None
  183. None
  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

  228. None
  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!
  235. None
  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
  239. None
  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