DEV Community: Yasushi Takehara

Java Lambda expression

Yasushi Takehara — Sat, 09 Jan 2021 16:32:59 +0000

Overview

Java Lambda implemented in version 8 is a function that a definition of a method can be described as an expression.

Before Java8

Programmers must have implemented an interface to pass logic codes.

public class Main {
    interface IGreeter {
        void greet(String name);
    }

    static void delegate(IGreeter iGreeter, String name){
        iGreeter.greet(name);
    }

    public static void main(String[] args) throws Exception {
        // need to put an object implemented the interface 'IGreeter'
        delegate(new IGreeter(){
            public void greet(String name){
                System.out.println("Hello, " + name + "."); // => Hello, Taro.
            }
        }, "Taro");
    }
}

From Java8

That can be written simpler than before, and it increased the readability for programmers.

public class Main {
    interface IGreeter {
        void greet(String name);
    }

    static void delegate(IGreeter iGreeter, String name){
        iGreeter.greet(name);
    }

    public static void main(String[] args) throws Exception {
        // The below callings print 'Hello, Taro.'
        delegate((name) -> {System.out.println("Hello, " + name + ".");}, "Taro"); // (arg) -> {sentences}

        delegate(name -> {System.out.println("Hello, " + name + ".");}, "Taro"); // arg -> {sentences}  #if only having one arg, it can omit ()

        delegate(name -> System.out.println("Hello, " + name + "."), "Taro"); // arg -> expression
    }
}

"This" reference

Between a Lambda method and an anonymous interface, the meanings of "this" reference are different, be careful.

public class Main {
    private final String value = "aaa";
    interface IPrinter {
        void printValue();
    }

    void delegate(IPrinter iPrinter){
        iPrinter.printValue();
    }

    void callDelegate(){
        delegate(() -> System.out.println("value => " + this.value)); // value => aaa
    }

    public static void main(String[] args) throws Exception {
        // 1) Lambda expression
        new Main().callDelegate(); 

        // 2) Anonymous interface
        new Main().delegate(new IPrinter(){
            private final String value = "bbb";
            public void printValue(){
                System.out.println("value => " + this.value); // value => bbb
            }
        }); 

    }
}

Accessible variables

From Lambda expression, Substantially 'final' variables can be accessed.
Even without 'final' keyword, if the value is not changed, it is accessible.

public class Main {
    interface IPrinter {
        void printValue();
    }

    static void delegate(IPrinter iPrinter){
        iPrinter.printValue();
    }

    public static void main(String[] args) throws Exception {
        int aaa = 100;
        delegate(() -> System.out.println(aaa)); // 100

        //aaa = 200;
        //If the above sentence is uncommented, a compile error will occur with the below error message.
        //Main.java:14: error: local variables referenced from a lambda expression must be final or effectively final
    }
}

Stateful Lambda expression

If you would like to have a Lambda expression with state, there are two ways.

1) Use instance field

public class Main {
    interface ICounter {
        int nextValue();
    }

    private int count; // the default value is zero
    ICounter makeCounter(){
        return () -> count++;
    }

    public static void main(String[] args) throws Exception {
        ICounter iCounter = new Main().makeCounter();
        System.out.println(iCounter.nextValue()); // 0
        System.out.println(iCounter.nextValue()); // 1
        System.out.println(iCounter.nextValue()); // 2
    }
}

2) Use referred object

public class Main {
    interface ICounter {
        int nextValue();
    }

    private int count; // the default value is zero
    ICounter makeCounter(){
        // https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicInteger.html
        AtomicInteger count = new AtomicInteger();
        return () -> count.getAndIncrement();
    }

    public static void main(String[] args) throws Exception {
        ICounter iCounter = new Main().makeCounter();
        System.out.println(iCounter.nextValue()); // 0
        System.out.println(iCounter.nextValue()); // 1
        System.out.println(iCounter.nextValue()); // 2
    }
}

Reference

改訂2版　パーフェクトJava
https://gihyo.jp/book/2014/978-4-7741-6685-8

Method Reference

Yasushi Takehara — Sat, 09 Jan 2021 15:36:43 +0000

Java8 has a function named "Method Reference" that points to a method.

Before Java8

It needed to create an object, which implements an interface, to refer a method.

public class Main {
    interface IGreeter {
        void greet(String name);
    }

    static void delegate(IGreeter iGreeter, String name){
        iGreeter.greet(name);
    }

    public static void main(String[] args) throws Exception {
        // need to put an object implemented the interface 'IGreeter'
        delegate(new IGreeter(){
            public void greet(String name){
                System.out.println("Hello, " + name + "."); // => Hello, Taro.
            }
        }, "Taro");
    }
}

From Java8

Programmers can use 'ClassName(ObjectVariableName)::MethodName' to refer it.

public class Main {

    @FunctionalInterface // This annotation can be omitted
    interface IGreeter {
        void greet(String name);
    }

    // This method can work instead of the above greet method.
    static void referredGreet(String name){
        System.out.println("Hello, " + name + ".");
    }

    static void delegate(IGreeter iGreeter, String name){
        iGreeter.greet(name);
    }

    public static void main(String[] args) throws Exception {
        // can put a method reference as 'ClassName::MethodName'
        delegate(Main::referredGreet, "Taro"); // => Hello, Taro.
    }
}

The most notable point is the name of the referred method "referredGreet" can be different from the one "greet" in the interface.

There are two rules.

The interface must have only one method.
The method of the interface must match the referred one in terms of 'type' of arguments and return value.

The referred method can use the parent type.
For example,

static void referredGreet(String name){

can be

static void referredGreet(Object name){

In other words, interface method can use sub type of the one of the referred method.

The method reference helps developers to write code simpler
For example,

List<String> list = Arrays.asList("aaa", "bbb", "ccc");
list.forEach(System.out::println); // => aaa
//bbb
//ccc

This the spec of 'forEach' method.
https://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html#forEach-java.util.function.Consumer-

The referred method (Consumer) must have one argument and void-return.
https://docs.oracle.com/javase/8/docs/api/java/util/function/Consumer.html
System.out::println meets the condition. That's why it can be set to 'forEach'.

Reference

改訂2版　パーフェクトJava
https://gihyo.jp/book/2014/978-4-7741-6685-8

Dealing with integer by different radix

Yasushi Takehara — Sun, 13 Dec 2020 13:21:46 +0000

In Java, numbers can be written by various radix.

// radix 10
int value = 255;

// radix 16
value = 0xff; // starts from 0x
value = 0xFF; // ff can be written as upper case, but not common
value = 0Xff; // x can be upper case, but not common

// radix 8
value = 0377; // starts from 0

// radix 2
value = 0b11111111; // starts from 0b
value = 0b1111_1111; // under score can be put for separation

These are all same values essentially and given for convenience for programmers when reading.

Reference
https://gihyo.jp/book/2014/978-4-7741-6685-8

If you would like to confirm a result of your code quickly

Yasushi Takehara — Sun, 13 Dec 2020 12:09:29 +0000

You can see the result of your program code from the web service "paiza.io".

https://paiza.io/ja/projects/new

Many programming languages have been supported.

This web page can be printed in English or Spanish :-)

StringJoiner class provides utility functions to concatenate words

Yasushi Takehara — Sun, 13 Dec 2020 11:54:37 +0000

The following code can be improved by StringJoiner class in Java.

String[] names = new String[]{"George", "Sally", "Fred"};
StringBuilder sb = new StringBuilder("[");
for(String name : names){
  sb.append(name).append(":");
}
sb.deleteCharAt(sb.length() - 1);
sb.append("]");
System.out.println(sb.toString()); //=> [George:Sally:Fred]

In the case of StringJoiner class

String[] names = new String[]{"George", "Sally", "Fred"};
StringJoiner sj = new StringJoiner(":", "[", "]");
for(String name : names){
  sj.add(name);
}
System.out.println(sj.toString()); //=> [George:Sally:Fred]

The code has become more concise :-)

Reference
https://cr.openjdk.java.net/~iris/se/11/latestSpec/api/java.base/java/util/StringJoiner.html#

StringBuilder is implicitly used when there is String += in Java

Yasushi Takehara — Sun, 13 Dec 2020 11:13:44 +0000

In Java, StringBuilder Object is implicitly used when a String variable is operated by "+=".

Example

String s = "hoge";
s += "fuga";
s += "piyo";

The above code will be compiled to the below code.

String s = "hoge";
s = (new StringBuilder(String.valueOf(s))).append("fuga")
.toString();
s = (new StringBuilder(String.valueOf(s))).append("piyo")
.toString();

This is a waste of machine resource, hence the code should be written, like

StringBuilder sb = new StringBuilder("hoge");
sb.append("fuga");
sb.append("piyo");
String s = sb.toString();

Or, it can be written more simply

String s = new StringBuilder("hoge").append("fuga").append("piyo")
.toString();

Reference
https://www.ne.jp/asahi/hishidama/home/tech/java/string.html
https://gihyo.jp/book/2014/978-4-7741-6685-8