[In-house study session] Java basics-Lambda expression and Stream API- (2017/07/13)

0. Introduction

What i want to tell

• Know Java 8 Now and Useful Notation

Prerequisite knowledge

• Java for loop, anonymous function

Reference books

"Introduction to Java -From the basics of modern style to object-oriented and practical libraries "Technical Review Co., Ltd.

This book is quoted unless otherwise specified.

table of contents

1. Lambda expression

What is a lambda expression?

Lambda expressions are powerful notations, as if you could pass the process itself to a method argument, etc.

• Quoted from "Introduction to Java" P151

List<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 3, 2, 1, 4, 5);

//Writing without lambda expression (anonymous class)
Collections.sort(list, new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
		return Integer.compare(o1, o2);
	}
});

//How to write using a lambda expression
Collections.sort(list,
		(o1, o2) -> Integer.compare(o1, o2)
);

The lambda expression is just "easy to write an implementation method of an anonymous class", but when combined with the Stream API described later, it can be written in an easy-to-understand manner.

[Supplement] Anonymous class

Often used in event listener settings.

//How to write when setting a click event on Android
findViewById(R.id.hogehoge).setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        //Processing at the time of clicking
    }
});

Use as an alternative to functional interfaces

• Functional interface: An interface with only one abstract method

• [Try] Check JavaDoc. JavaDoc Comparator

• Functional interfaces are replaced by lambda expressions

Lambda expression basic grammar

• Basic grammar: (argument)-> {processing}
• Various can be omitted depending on the conditions --Type of argument part --Argument parentheses (when there is one argument) --return and curly braces (when there is one process)

//Lambda expression basic grammar
Collections.sort(list,
		(Integer o1, Integer o2) -> {
           return Integer.compare(o1, o2);
        }
);

//Omit argument type
Collections.sort(list,
		(o1, o2) -> {
           return Integer.compare(o1, o2);
        }
);

//Argument type, return, and curly braces omitted
Collections.sort(list,
		(o1, o2) -> Integer.compare(o1, o2)
);

Method reference

The method itself can also be assigned.

List<String> list = Arrays.asList("X", "Y", "Z");
//How to write using method references
list.forEach(System.out::println);

//How to write using a lambda expression
list.forEach(str -> System.out.println(str));

The argument of the forEach method is a functional interface called java.util.function.Consumer.

2.Stream API

What is Stream API?

The Stream API was introduced as a way to efficiently describe "stream processing" that sequentially processes large amounts of data.

• Quoted from "Introduction to Java" P150

List<Integer> list = Arrays.asList(100, 60, 30, 50, 70);

list.stream() //Stream instantiation
    .filter(s -> s>=70) //Intermediate operation.//Extract over 70.
    .forEach(s -> System.out.println(s)); //Termination operation.

Display TODO Stream image

• Reference site http://www.oracle.com/technetwork/jp/articles/java/ma14-java-se-8-streams-2177646-ja.html

Stream API features

Stream API is "API that describes What, not How".

• How: Individual processing

• What: Purpose of processing

• Stream API writes the purpose without writing the loop processing

• Same idea as SQL.

Stream API classification

• Stream creation
• Stream intermediate operation
• Stream termination operation

Stream API list

API to create Stream

//Create Stream from List or Set
List<Integer> list = Arrays.asList(100, 60, 30, 50, 70);
list.stream() //Stream instantiation
    .forEach(System.out::println);
    

//Create a Stream from a numeric range
IntStream.range(1, 5) //Does not include the end
    .forEach(System.out::println);

IntStream.rangeClosed(1, 5) //Including the end
    .forEach(System.out::println);

Intermediate operations on Stream

List<Integer> list = Arrays.asList(10, 6, 3, 5, 7);

//map:Replace element with another value
list.stream()
    .map(s -> s * s)
    .forEach(System.out::println);
    
//filter:Narrow down only the elements that match the conditions
list.stream()
    .filter(s -> s>=7)
    .forEach(System.out::println);

//sort:
list.stream()
    .sorted((s1,s2) -> s2 - s1) //descending order
    .forEach(System.out::println);

Termination operation for Stream

List<Integer> list = Arrays.asList(10, 6, 3, 5, 7);

//forEach:Take action on an element
list.stream()
    .forEach(System.out::println);
    
//collect:Create results
List<Integer> newList = list.stream()
    .filter(s -> s>=7)
    .collect(Collectors.toList());

//average:Returns the average(Aggregation operation)
list.stream()
    .average();

Functional language

JavaScript too. .. ..