Java 8 Streams Intermediate Operation

In the previous journal entry “Understanding Java 8 Streams with Examples” we have looked at the core concepts of Java 8 Streams API with some examples. Now, in this journal we will take a look at some more examples of Java 8 Stream operations: Intermediate.

Java 8 Stream Intermediate Operation Example

Let’s have a look at some of the basic use cases of intermediate operation methods provided by Stream API.

1. filter()
2. map()
3. sorted()
4. flatMap()

filter(): We can use filter() method to test stream elements for a condition and generate filtered list.

Java Stream filter() Example for a List

public class Java8StreamFilter {

    public static void main(String[] args) {

        List<String> lines = Arrays.asList("java", "stream", "oldjava");

        List<String> result = lines.stream()                // convert list to stream
                .filter(line -> !"oldjava".equals(line))    // filter and remove the oldjava from the list
                .collect(Collectors.toList());              // collect the output and convert streams to a List

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

    }

}

//OUTPUT : java, stream

Java Stream filter() Example with Objects

class Person {
	private String name;
	private int age;

	public Person() {}

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return this.name;
	}

	public void setName(String value) {
		this.name = value;
	}

	public int getAge() {
		return this.age;
	}

	public void setAge(int value) {
		this.age = value;
	}
}

public class Java8StreamFilter {
	
	public static void main(String[] args) {
		List<Person> personList = Arrays.asList(
			new Person("Smith", 37),
			new Person("John", 24),
			new Person("Kirsten", 33)
		);

		Person result = personList.stream()                     // Convert to steam
                .filter(x -> "John".equals(x.getName()))        // we want "John" only
                .findAny()                                      // If 'findAny' then return found
                .orElse(null);                                  // If not found, return null

        System.out.println(result);
	}

}

// OUTPUT : Person{name="John", age=24}

map(): We can use map() to apply functions to an stream. In the below example we will try to apply lower case function to a list of Strings.

Java Stream map() Example

Stream<String> names = Stream.of("Kirsten", "John", "Philips");
System.out.println(names.map(s -> {
		return s.toLowerCase();
	}).collect(Collectors.toList()));

//OUTPUT: [kirsten, john, philips]

sorted(): We can use sorted() to sort the stream elements by passing Comparator argument.

Java Stream sorted() Example

Stream<String> reverseSortedName = Stream.of("Kirsten", "John", "Philips");
List<String> reverseSorted = reverseSortedName
                                        .sorted(Comparator.reverseOrder())
                                        .collect(Collectors.toList());
System.out.println("Reverse Sort: " + reverseSorted);

Stream<String> sortedName = Stream.of("Kirsten", "John", "Philips");
List<String> naturalSorted = sortedName.sorted().collect(Collectors.toList());
System.out.println("Default Natural Sort: " + naturalSorted);


// OUTPUT
Reverse Sort: [Philips, Kirsten, John]
Default Natural Sort: [John, Kirsten, Philips]

flatMap(): Create a stream from the stream of list. Let’s see a simple example to clear this doubt.

Java Stream flatMap() Example

Stream<List<String>> namesList = Stream.of(
			Arrays.asList("Smith"),
			Arrays.asList("John","Kirsten"),
			Arrays.asList("Philips")
		);

Stream<String> flatMapStream = namesList
				.flatMap(stringList -> stringList.stream());

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

//OUTPUT
Smith
John
Kirsten
Philips