JAVA 8 Cheat Sheet

(int a) -> a * 2; // Calculate the double of aa -> a * 2; // or simply without type

(a, b) -> a + b; // Sum of 2 parameters

(x, y) -> {    int sum = x + y;    int avg = sum / 2;    return avg;}

interface MyMath {    int getDoubleOf(int a);}MyMath d = a -> a * 2; // associated to the interfaced.getDoubleOf(4); // is 8

interface Pair<A, B> {    A first();    B second();}

stream.sorted(    Comparator.<Pair<String, Long>, String>comparing(Pair::first)    .thenComparing(Pair::second)) // ok

List<String> list = [Bohr, Darwin, Galilei, Tesla, Einstein, Newton]

list.sort((a, b) -> a.length() - b.length())list.sort(Comparator.comparing(n -> n.length())); // samelist.sort(Comparator.comparing(String::length)); // same//> [Bohr, Tesla, Darwin, Newton, Galilei, Einstein]

list.removeIf(w -> w.length() < 6);//> [Darwin, Galilei, Einstein, Newton]

Map<String, String> names = new HashMap<>();names.put("Albert", "Ein?");names.put("Marie", "Curie");names.put("Max", "Plank");// Value "Albert" exists// {Marie=Curie, Max=Plank, Albert=Einstein}names.merge("Albert", "stein", (old, val) -> old.substring(0, 3) + val);// Value "Newname" don't exists// {Marie=Curie, Newname=stein, Max=Plank, Albert=Einstein}names.merge("Newname", "stein", (old, val) -> old.substring(0, 3) + val);

// Lambda Form:getPrimes(numbers, a -> StaticMethod.isPrime(a));// Method Reference:getPrimes(numbers, StaticMethod::isPrime);

// Will compute just 3 "filter"Stream<String> longNames = list   .filter(n -> n.length() > 8)   .limit(3);

Stream<Integer> stream = Stream.of(1, 2, 3, 5, 7, 11);Stream<String> stream = Stream.of("Jazz", "Blues", "Rock");Stream<String> stream = Stream.of(myArray); // or from an arraylist.stream(); // or from a list// Infinit stream [0; inf[Stream<Integer> integers = Stream.iterate(0, n -> n + 1);

// Collect into an array (::new is the constructor reference)String[] myArray = stream.toArray(String[]::new);// Collect into a List or SetList<String> myList = stream.collect(Collectors.toList());Set<String> mySet = stream.collect(Collectors.toSet());// Collect into a StringString str = list.collect(Collectors.joining(", "));

// Apply "toLowerCase" for each elementres = stream.map(w -> w.toLowerCase());res = stream.map(String::toLowerCase);//> bohr darwin galilei tesla einstein newtonres = Stream.of(1,2,3,4,5).map(x -> x + 1);//> 2 3 4 5 6

// Filter elements that begin with "E"res = stream.filter(n -> n.substring(0, 1).equals("E"));//> Einsteinres = Stream.of(1,2,3,4,5).filter(x -> x < 3);//> 1 2

String reduced = stream    .reduce("", (acc, el) -> acc + "|" + el);//> |Bohr|Darwin|Galilei|Tesla|Einstein|Newton

res = stream.limit(3);//> Bohr Darwin Galilei

res = strem.skip(2); // skip Bohr and Darwin//> Galilei Tesla Einstein Newton

res = Stream.of(1,0,0,1,0,1).distinct();//> 1 0

res = stream.sorted();//> Bohr Darwin Einstein Galilei Newton Tesla 

// Check if there is a "e" in each elementsboolean res = words.allMatch(n -> n.contains("e"));

IntStream stream = IntStream.of(1, 2, 3, 5, 7);stream = IntStream.of(myArray); // from an arraystream = IntStream.range(5, 80); // range from 5 to 80Random gen = new Random();IntStream rand = gen(1, 9); // stream of randoms

// Groupe by lengthMap<Integer, List<String>> groups = stream    .collect(Collectors.groupingBy(w -> w.length()));//> 4=[Bohr], 5=[Tesla], 6=[Darwin, Newton], ...

// Same as before but with Set... Collectors.groupingBy(    w -> w.substring(0, 1), Collectors.toSet()) ...

// Average length of each element of a groupCollectors.averagingInt(String::length)

Stream<String> parStream = list.parallelStream();Stream<String> parStream = Stream.of(myArray).parallel();

stream.parallelStream().unordered().distinct();

// Optional<String> contains a string or nothingOptional<String> res = stream   .filter(w -> w.length() > 10)   .findFirst();// length of the value or "" if nothingint length = res.orElse("").length();// run the lambda if there is a valueres.ifPresent(v -> results.add(v));

Optional<Double> squareRoot(double x) {   if (x >= 0) { return Optional.of(Math.sqrt(x)); }   else { return Optional.empty(); }}