[Must-see for apprentice java engineer] How to use Stream API

Article summary

This article focuses on how to use the Stream API. Many source code examples and explanations are provided so that even those who are new to the Stream API can understand it. It also introduces applied usage such as Strategy pattern using Stream API.

Benefits of learning the Stream API

――Because the processing is done like words, readability is improved. --Clear input and output make it easier to write test code --Bugs are hard to hide because it does not cause state changes --Combining functions does not affect each other --Supports parallel processing

When can I use the Stream API?

It can be used in places where loop processing such as for statements is performed most often.

How to use Stream API

The basic flow is to create a Stream instance, perform as many processes as you want (intermediate operation), and finally bring it to the desired state (end point operation).

Let's compare ** if you did not use the Stream API ** and ** if you did use ** to imagine this process.

The code written below shows the source code that converts the character string stored in the List to uppercase and extracts and displays only the 4-character character string.

//Code written without using Stream API
List<String> list2 = Arrays.asList("hoge", "foo", "bar","hoga");
		List<String> stream2 = new ArrayList<String>();
		for(String s :list2){
			String sUpperCase = s.toUpperCase();
			if(sUpperCase.length() == 4){
				stream2.add(sUpperCase);
			}
		}
		for(int i = 0; i < stream2.size(); i++){
			System.out.println(stream2.get(i));
		}

/*
The result is as follows
HOGE
HOGA
*/

//When using Stream API
		List<String> list1 = Arrays.asList("hoge", "foo", "bar","hoga");
		List<String> stream1 = list1.stream()
								.map(String::toUpperCase)
								.filter(s -> s.length() == 4)
								.collect(Collectors.toList());
		stream1.forEach(System.out::println);

/*
The result is as follows
HOGE
HOGA
*/

Using the Stream API like this is better readability because you only have to write what you want to do declaratively. (There is an advantage because there is no other state change and unnecessary processing does not run due to processing delay)

Now that you have an image of how to use the Stream API, I will explain in detail how to use it.

I will explain the flow of Stream separately as follows. ** 1. Stream instance creation ** ** 2. Intermediate operation ** ** 3. End point operation **

1. Create Stream instance

There are many ways to create a Stream instance, but here are four that you might use most often.

How to write source code

// Collection#stream()
List<String> list = Arrays.asList("hoge", "foo", "bar");
Stream<String> stream = list.stream();

// Arrays#stream (T[] array)
String[] array = {"hoge", "foo", "bar"};
Stream<String> stream2 = Arrays.stream(array);

// Stream#of (T[] array)
Stream<String> stream3 = Stream.of("hoge", "foo", "bar");

// Stream#iterate (T seed, UnaryOperator f)
Stream<Integer> stream4 = Stream.iterate(2, x -> x * 2);

2. Intermediate operation

Intermediate operations are roughly divided into three processing methods.

--Narrow down the elements --Processing of elements --Sort elements

** 1. I think you understand how to create a Stream instance **, so I will narrow down the intermediate operations for the generated Stream instance.

• There are Predicate and Function, but I will explain them in detail later. For the time being, the process to return true and false is written in Prediate, Please think that the processing to be processed is written in Function.

Narrow down the elements

Since it is narrowed down, the number of inputs and outputs will change.

How to write source code

List<String> list = Arrays.asList("hoge", "foo", "bar","hoga","hoga");
//I used filter to extract only a 4-character string
System.out.println("****↓　filter****");
list.stream()
	.filter(s -> s.length() == 4)
	.forEach(System.out::println);

/*
Output result
hoge
hoga
hoga
*/

List<String> list = Arrays.asList("hoge", "foo", "bar","hoga","hoga");
//Extracted up to 3 strings from the first character using limit
list.stream()
	.limit(3)
	.forEach(System.out::println);

/*
Output result
hoge
foo
bar
*/

List<String> list = Arrays.asList("hoge", "foo", "bar","hoga","hoga");
//I used skip to skip the element string from the first character
list.stream()
	.skip(1)
	.limit(2)
	.forEach(System.out::println);

/*
Output result
foo
bar
*/

List<String> list = Arrays.asList("hoge", "foo", "bar","hoga","hoga");
//Removed duplicate strings using distinct
list.stream()
	.distinct()
	.forEach(System.out::println);

/*
Output result
hoge
foo
bar
hoga
*/

Processing of elements

The number of inputs and outputs does not change because it is only processed. For example, you can change from lowercase to uppercase, or from a string to the number of characters in a string.

How to write source code

List<String> list = Arrays.asList("hoge", "foo", "bar","hoga");
list.stream()
	.map(String::length)
	.forEach(System.out::println);

/*
Output result
4
3
3
4
*/

Sorting elements

How to write source code

List<Person> people = Arrays.asList(
		new Person("Suzuki",24),
		new Person("Yamada",53),
		new Person("Henri Fortin",9),
		new Person("Yokouchi",39));

//When sorted by age
people.stream()
		.sorted(comparing(Person::getAge))
		.forEach(s -> System.out.println(s.toString()));
/*
Output result
Henri Fortin:9
Suzuki:24
Yokouchi:39
Yamada:53
*/


//Sort by name.reversed()When using in descending order
people.stream()
		.sorted(comparing(Person::getName).reversed())
		.forEach(s -> System.out.println(s.toString()));
}

/*
Output result
Suzuki:24
Yokouchi:39
Yamada:53
Henri Fortin:9
*/

//Person class used above
public class Person {
	private String name;
	private int age;
	public Person(String name, int age){
		this.name = name;
		this.age = age;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	public String toString(){
		return name + ":" + age;
	}
}

3. End point operation

The end point operation is the last operation that creates a Stream instance and finishes intermediate operations.

How to write source code Since the amount is large this time, I wrote an example by extracting about 3 appropriately. There is an optional return value, which will be explained later.

List<Person> people = Arrays.asList(
		new Person("Suzuki",24),
		new Person("Yamada",53),
		new Person("Henri Fortin",9),
		new Person("Yokouchi",39));

//Sort by age and store in List
List<Person> sortedPeople = people.stream()
								.sorted(comparing(Person::getAge))
								.collect(Collectors.toList());
System.out.println(sortedPeople);
/*
Output result
[Henri Fortin:9,Suzuki:24,Yokouchi:39,Yamada:53]
 */

//Sort by age in descending order and get the first Person
Optional<Person> firstPerson = people.stream()
								.sorted(comparing(Person::getAge).reversed())
								.findFirst();
System.out.println(firstPerson);
/*
Output result
Optional[Yamada:53]
*/

//True if all Persons are 10 or older, false otherwise
boolean ss = people.stream()
					.allMatch(p -> p.getAge() > 10);
System.out.println(ss);
/*
Output result
false
*/

About Optional

What is Optional?

A container object that can be stored with or without non-null values. There is no need to perform nullpo processing such as if (xxx == null). Please read it as it is organized in an easy-to-understand document. https://docs.oracle.com/javase/jp/8/docs/api/java/util/Optional.html

How to use Optional

This is an example using the ifPresent (Consumer <? Super T> consumer) method. This program outputs the first value found when the last name has 3 or more characters.

//If Optional is not used
List<String> people = Arrays.asList("Yamada","Tanaka","Suzuki");
String firsPerson = null;
for(String s : people){
	if(s.length() == 3){
		firsPerson = s;
		break;
	}
}
//null check
if(firsPerson != null){
	System.out.println(firsPerson);
}

//Use Optional and execute only when the value exists
Optional<String> firstPerson = Stream.of("Yamada","Tanaka","Suzuki")
									.filter(s -> s.length() == 3)
									.findFirst();
firstPerson.ifPresent(System.out::println);

If the value exists, it calls the specified consumer with that value, otherwise it does nothing.

Predicate

What is Predicate?

Returns the boolean of the processing result. In addition, processing can be connected, so if there is processing that connects a large number of if statements, It can be used effectively.

How to use Predicate

Implement the process of receiving a T type value as an argument and returning a boolean value. The value of boolean is returned by giving the argument T to the test method.

Predicate<String> predicate = s -> s.length() == 5;
System.out.println(predicate.test("tarou"));

Function

What is Function?

Represents a function that takes a single argument and produces a result.

How to use Function

Implement the process of receiving a T-type argument and returning an R-type value. It can be executed by giving the argument T to the apply method.

Function<String,String> toUpper = s -> s.toUpperCase();
System.out.println(toUpper.apply("tarou"));

Consumer

What is Optional?

How to use Optional

It receives a T type value as an argument and implements processing without a return value. It can be executed by giving the argument T to the accept method.

Consumer<String> consumer = string -> System.out.println("Cunsumer : " + string);
consumer.accept("tarou");

Parallel processing

comming soon

Recursive processing by lazy evaluation

comming soon