Cacher is the code snippet organizer for pro developers

// Выполнить для всех элементов метод класса, используя значение элемента. 
// Конструкци может принимать и два аргумента в зависимости от класса

List<String> list=new ArrayList();
list.add("ankit");
list.add("mayank");
list.add("irfan");
list.add("jai");

list.forEach(System.out::println);

List<String> list=new ArrayList();
list.add("ankit");
list.add("mayank");
list.add("irfan");
list.add("jai");

list.replaceAll(e -> e + " = 1");

list.forEach(
        (n)->System.out.println(n)
);

// Описываем интерфейс. Реализуем метод через лямбду. 
// Можно явно указывать типы параметров
// К внешним переменным возможно обращаться только с модификатором final

Print myPrint = number -> number * number;
System.out.println(myPrint.pow(10));

private static interface Print{
    public int pow (int s);

}

class ChainingComparator1 implements Comparator<Squirrel> {
    public int compare(Squirrel s1, Squirrel s2) {
        Comparator<Squirrel> c = Comparator.comparing(Squirrel::getSpecies).thenComparingInt(Squirrel::getWeight);
        return c.compare(s1, s2);
    }
}

// Принимает один аргумент, возвращает boolean, не Boolean!
String str = "abc";
Predicate<String> methodRef2 = str::startsWith;
Predicate<String> lambda2 = s -> str.startsWith(s);

methodRef2 = methodRef2.and(lambda2);

System.out.println(lambda2.test(""));

// Принимает два аргумента, возвращает boolean

BiPredicate<String, String> b1 = String::startsWith;
BiPredicate<String, String> b2 = (string, prefix) -> string.startsWith(prefix);

// Принимает один аргумент, возвращает void

List<Integer> list = Arrays.asList(20,-10,5,9,24,9);

Consumer<List<Integer>> methodRef1 = Collections::sort;
Consumer<List<Integer>> lambda1 = l -> Collections.sort(l);

// Принимает два аргумента, возвращает void

methodRef1.accept(list);

Map<String, Integer> map = new HashMap<>();

BiConsumer<String, Integer> b1 = map::put;
BiConsumer<String, Integer> b2 = (k, v) -> map.put(k, v);

b1.accept("chicken", 7);
b2.accept("chick", 1);

// Не принимает аргумент, возвращает любой тип

Supplier<ArrayList> methodRef4 = ArrayList::new;
Supplier<ArrayList> lambda4 = () -> new ArrayList();

List c = methodRef4.get();

// Принимает аргумент и возвращает тот же тип

UnaryOperator<Integer> c = i -> i*i;
System.out.println(c.andThen(i -> i+1).apply(-1));

// Принимает два аргумент и возвращает тот же тип. Все переменные одного типа

BinaryOperator<String> b1 = String::concat;
BinaryOperator<String> b2 = (string, toAdd) -> string.concat(toAdd);

System.out.println(b1.apply("baby ", "chick")); // baby chick
System.out.println(b2.apply("baby ", "chick")); // baby chick

//Принимает один или два типа и возвращает один указанный тип

Function<String, Integer> f1 = String::length;
Function<String, Integer> f2 = x -> x.length();
System.out.println(f1.apply("cluck")); // 5
System.out.println(f2.apply("cluck")); // 5

BiFunction<String, String, String> b1 = String::concat;
BiFunction<String, String, String> b2 = (string, toAdd) -> string.concat(toAdd);
System.out.println(b1.apply("baby ", "chick")); // baby chick
System.out.println(b2.apply("baby ", "chick")); // baby chick

Map<String, String> favorites = new HashMap<>();
favorites.put("Jenny", "Bus Tour");
favorites.put("Tom", null);

favorites.putIfAbsent("Jenny", "Tram"); // Not Added
favorites.putIfAbsent("Sam", "Tram"); //Added
favorites.putIfAbsent("Tom", "Tram"); //Added, if null then put



//Add logic and if null or doesn't exist put in any case

BiFunction<String, String, String> mapper = (v1, v2)
-> v1.length() > v2.length() ? v1: v2;

Map<String, String> favorites = new HashMap<>();
favorites.put("Jenny", "Bus Tour");
favorites.put("Tom", "Tram");

String jenny = favorites.merge("Jenny", "Skyride", mapper);
String tom = favorites.merge("Tom", "Skyride", mapper);

System.out.println(favorites); // {Tom=Skyride, Jenny=Bus Tour}
System.out.println(jenny); // Bus Tour
System.out.println(tom); // Skyride

//Change value by Key

Map<String, Integer> counts = new HashMap<>();
counts.put("Jenny", 1);

BiFunction<String, Integer, Integer> mapper = (k, v) -> v + 1;
Integer jenny = counts.computeIfPresent("Jenny", mapper);
Integer sam = counts.computeIfPresent("Sam", mapper);
System.out.println(counts); // {Jenny=2}
System.out.println(jenny); // 2

//Change value by Key if key isn't present or value == null

Map<String, Integer> counts = new HashMap<>();
counts.put("Jenny", 15);
counts.put("Tom", null);
Function<String, Integer> mapper = (k) -> 1;
Integer jenny = counts.computeIfAbsent("Jenny", mapper); // 15
Integer sam = counts.computeIfAbsent("Sam", mapper); // 1
Integer tom = counts.computeIfAbsent("Tom", mapper); // 1
System.out.println(counts); // {Tom=1, Jenny=15, Sam=1}
System.out.println(sam); // null

  {
  Integer valueTest = 10;

  Optional<Integer> answer = getPositiveNumber(valueTest);

  Optional<Integer> easyAnswer = Optional.ofNullable(valueTest);

  Integer cleanValue = 0;
  
  if(answer.isPresent())
      cleanValue = answer.get();

  answer = Optional.of(10);


  answer.ifPresent(System.out::println);
  answer.orElse(0);
  answer.orElseGet(() -> 0);
  //answer.orElseThrow(() -> new RuntimeException());
  }
  
  public static Optional<Integer> getPositiveNumber(int i){
        return i >= 0 ? Optional.of(i) : Optional.empty();
    }