[Java] Functional interface / lambda expression

What is a lambda expression?

• ** Syntax for passing methods **

If you don't use a lambda expression

• When you want to extract individual elements from a given character string and add brackets before and after to output

public class MethodRefUnuse {
//Output string contents with bracket
  public void walkArray(String[] data) {
    for (var value : data) {
      System.out.printf("[%s]\n", value);
    }
  }
}

//Output the contents of the character string array data in order
public class MethodRefUnuseBasic {

  public static void main(String[] args) {
    var data = new String[] { "Spring is Akebono", "Summer is night", "Autumn is dusk" };
    var un = new MethodRefUnuse();
    un.walkArray(data); //[Spring is Akebono][Summer is night][Autumn is dusk]
  }
}

• It is difficult to prepare multiple walkArray methods when you want to put out the first five characters of the character string, instead of brackets.
• ** → Make it possible to extract only the process of processing character strings from the outside **
• It's no use creating similar methods! That means

Method reference

• Let's cut out only the code that processes array elements

MethodRefUnuse.java

public class MethodRefUse {

//Make it possible to receive the processing method of array elements by method reference
  //In the argument output"Refer to a method that receives an argument as a String type and has a return value of void"To pass

  public void walkArray(String[] data, Output output) {
    for (var value : data) {
      output.print(value);
    }
  }
//Method corresponding to Output type (enclose character string with bracket)
  //The actual state of the print method defined in the functional interface is the addQuote method.
  static void addQuote(String value) {
    System.out.printf("[%s]\n", value);
  }
}

• The type of the method is represented by ** functional interface **
• ** An interface with one abstract method under it ** (SAM interface)
• The number / type of arguments and the type of return value must be fixed.
• Name is irrelevant and ** return type ** is the key to determine
• cf: Method signature is keyed by method name, number of arguments / type
• Declare that the target interface is functional by annotating @FunctionalInterface

Output.java

//A method type that takes a String type argument and returns a void method type
@FunctionalInterface
public interface Output {
  void print(String str);
}

• Pass the method reference to the method
• ** Class method **: Class name :: Method name
• ** stance method **: object variable :: method name
• ** Constructor **: Class name :: new

MethodRefUnuseBasic.java

public class MethodRefUseBasic {

  public static void main(String[] args) {
    var data = new String[] {"Spring is Akebono", "Summer is night", "Autumn is dusk"};
    var u = new MethodRefUse();
    //Pass the method reference to the walkArray method
    u.walkArray(data, MethodRefUse::addQuote);
  }
}

Replace method

• The method passed to the argument output is ** freely changeable with the type declared in the functional interface **
• The walkAttar method can be implemented by referring to the method without rewriting, and the details can be designed by the user!
• output
• addOuote (String value) Then enclose it in brackets
• Output the total string length value of the array after addLength (String value)

//Counter class that counts strings
public class Counter {
  private int result = 0;

  public int getResult() {
    return this.result;
  }

  public void addLength(String value) {
    this.result += value.length();
  }
}

public class CounterBasic {

  public static void main(String[] args) {
    var data = new String[] {"Spring is Akebono", "Summer is night", "Autumn is dusk"};
    var u = new MethodRefUse();
    var c = new Counter();
    //The addLength method of the Counter class adds the string length of value to the result field
    u.walkArray(data, c::addLength);
    System.out.println(c.getResult());
  }
}

Lambda expression appears here

• It's annoying to define addQuote and addLength just by passing it to the walkArray method.
• Methods whose purpose is to pass processing are disposable
• It's annoying to name each one. .. ..
• → ** Use lambda expression **!
• By writing the method definition as an expression (literal), you can write it directly in the method call statement and the code is refreshing!
• ** (Argument type formal argument)-> {method body} **
• There is a function interface like java.util.function, so you don't have to prepare it yourself!

//walkArray method argument Consumer interface
//Consumer is a no-return method that takes a T-type argument and performs some processing
import java.util.function.Consumer;

public class MethodLambda {

  public void walkArray(String[] data, Consumer<String> output) {
    for (var value : data) {
      output.accept(value);
    }
  }
}

public class MethodLambdaBasic {

  public static void main(String[] args) {
    var data = new String[] { "Spring is Akebono", "Summer is night", "Autumn is dusk" };
    var ml = new MethodLambda();
    ml.walkArray(data, (String value) -> {
      System.out.printf("[%s]\n", value);
    });
  }
}

Easier lambda expression

• If it is one sentence of the text, {} can be omitted
• return optional
  • (String value) -> System.out.printf("[%s]\n", value)
• Type inference
  • (value) -> System.out.printf("[%s]\n", value)
• With one argument
  • value -> System.out.printf("[%s]\n", value)

Proper use with anonymous classes

• Rewrite with anonymous class
• The second argument of the walkArray method is a Consumer type object.
• Removes what can be inferred if it is a lambda expression

import java.util.function.Consumer;

public class MethodLambdaBasic {

  public static void main(String[] args) {
    var data = new String[] { "Spring is Akebono", "Summer is night", "Autumn is dusk" };
    var ml = new MethodLambda();

    ml.walkArray(data, new Consumer<String>() {
      @Override
      public void accept(String value) {
        System.out.printf("[%s]\n", value);
      }
    });

     ml.walkArray(data, (String value) -> System.out.printf("[%s]\n", value));
     ml.walkArray(data, (value) -> System.out.printf("[%s]\n", value));
     ml.walkArray(data, value -> System.out.printf("[%s]\n", value));
  }
}

Lambda expression collection framework method example

** replaceAll method **

• public void replaceAll(UnaryOperator<E> operator)
• ** Arguments / return values must return the same type **, so it cannot receive a string list and return a string length (int) list

//Extract only the first 3 characters and output 2 or less characters as they are
import java.util.ArrayList;
import java.util.Arrays;

public class CollReplace {

  public static void main(String[] args) {
    var list = new ArrayList<String>(
        Arrays.asList("Neko", "Inu", "Niwatori"));
    list.replaceAll(v -> {
      if (v.length() < 3) {
        return v;
      } else {
        return v.substring(0, 3);
      }
    });
    System.out.println(list); //[Nek, Inu, Niw]
  }
}

• ** Replace with the rules specified in the map **
• Argument function receives each key / value as an argument and returns the result of conversion

//Add key acronym to map value
import java.util.HashMap;
import java.util.Map;

public class CollReplaceMap {

  public static void main(String[] args) {
    var map = new HashMap<String, String>(
      Map.of("cat", "Cat", "dog", "Dog", "bird", "Bird"));
    map.replaceAll((k, v) -> k.charAt(0) + v);
    System.out.println(map); //{cat=c cat, dog=d dog, bird=b Tori}
  }
}

** removeIf method **

• ** Remove elements that match the conditions from the list **
• Delete only the elements that meet the receiving conditions of each element with the argument filter

//Delete all strings of 5 or more characters
import java.util.ArrayList;
import java.util.Arrays;

public class CollRemove {

  public static void main(String[] args) {
    var list = new ArrayList<String>(
      Arrays.asList("rose", "Tulips", "Morning glory", "Hyacinth"));
    list.removeIf(v -> v.length() > 4);
    System.out.println(list); //[rose",Morning glory]
  }
}

** compute method **

• Set the processing result on the map
• ** compute **: Set the unconditionally specified processing result
• ** computeIfPresent **: Set if the specified key exists
• ** computeIfAbsent **: Set if the specified key does not exist
• When calling a method from multiple places, the method reference is cleaner.

import java.util.HashMap;
import java.util.Map;

//Add the first character of the key to the value (compute/computeIfPresent）
public class CollCompute {
  public static String trans(String key, String value) {
    return key.charAt(0) + value;
  }
//Set the key itself to the value (computeIfAbsent)
  public static String trans(String key) {
    return key;
  }

  public static void main(String[] args) {
    var map = new HashMap<String, String>(Map.of("orange", "Mandarin orange"));

//compute
      map.compute("orange", CollCompute::trans);
      map.compute("melon", CollCompute::trans);
      System.out.println(map); //{orange ＝ o mandarin orange, melon=mnull}

/*
computeIfPresent: Processing is executed only when the key exists
    map.computeIfPresent("orange", CollCompute::trans);
    map.computeIfPresent("melon", CollCompute::trans);
    System.out.println(map); //{orange ＝ o mandarin orange}
*/

/*computeIfAbsent: Process only those that do not have a key
    map.computeIfAbsent("orange", CollCompute::trans);
    map.computeIfAbsent("melon", CollCompute::trans);
    System.out.println(map); //{orange = mandarin orange, melon=melon}
*/
  }
}

merge method

• ** Process duplicate key values **
• Set new value if key does not exist
• public V merge(K key, V value, BiFunction<? super V,? super V,? extends V>remap)

//Concatenate values separated by commas when duplicate values
import java.util.HashMap;
import java.util.Map;

public class CollMerge {
    public static String concat(String v1, String v2) {
        if(v2 == "") {return null;}
        return v1 + "," + v2;
    }
    public static void main(String[] args) {
        var map = new HashMap<String, String>(Map.of("cat", "three colored cat"));
        map.merge("dog", "Pomera An", CollMerge::concat);
        map.merge("cat", "Persian", CollMerge::concat);
        map.merge("dog", "Poodle", CollMerge::concat);
        System.out.println(map); //{dog=Pomera An,Poodle, cat=three colored cat,Persian}

        //Join function(remap)Discards the key itself if returns null
        map.merge("cat", "", CollMerge::concat);
        System.out.println(map); //{dog=Pomera An,Poodle}
    }
}