Java Streams is a powerful feature introduced in Java 8 that simplifies the processing of collections and sequences of data. Streams enable you to perform complex operations on data with concise and expressive code.
Stream is a sequence of data that you can process in a declarative and functional style. It allows you to perform operations such as filtering, mapping, and reducing on a collection of data. Streams can be used with various data sources, including arrays, collections, and even I/O channels.
- Arrays: You can create a stream from an array using the
Arrays.stream() method.List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Stream<String> nameStream = names.stream();
- Collections: Java collections such as lists, sets, and maps can be converted to streams using the
stream() method.List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Stream<String> nameStream = names.stream();
- I/O Channels: Java provides classes like
BufferedReader for reading from input sources like files. These classes can be wrapped into streams using methods like lines().try (Stream<String> lines = Files.lines(Paths.get("file.txt"))) {
// Process the lines in the file
} catch (IOException e) {
e.printStackTrace();
}
- Stream.of() is a static factory method in Java's Stream class that allows you to create a stream from a sequence of elements.Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);
Once you have a Stream, you can perform various operations on it. Stream operations can be categorized into two types: intermediate and terminal operations.
Intermediate operations transform the elements of the stream and produce a new stream as a result. Some common intermediate operations in Java streams include
filter, map, flatMap, distinct, sorted, limit, and skip, among others.import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<String> words = Arrays.asList("apple", "banana", "orange", "grape", "banana");
// Filter words starting with 'a'
List<String> filteredWords = words.stream()
.filter(word -> word.startsWith("a"))
.collect(Collectors.toList());
System.out.println("Words starting with 'a': " + filteredWords);
// Map each word to its length
List<Integer> wordLengths = words.stream()
.map(String::length)
.collect(Collectors.toList());
System.out.println("Word lengths: " + wordLengths);
// Remove duplicates
List<String> distinctWords = words.stream()
.distinct()
.collect(Collectors.toList());
System.out.println("Distinct words: " + distinctWords);
// Sort words alphabetically
List<String> sortedWords = words.stream()
.sorted()
.collect(Collectors.toList());
System.out.println("Sorted words: " + sortedWords);
// Limit to first 3 words
List<String> firstThreeWords = words.stream()
.limit(3)
.collect(Collectors.toList());
System.out.println("First three words: " + firstThreeWords);
// Skip first 2 words
List<String> skippedFirstTwoWords = words.stream()
.skip(2)
.collect(Collectors.toList());
System.out.println("Skipped first two words: " + skippedFirstTwoWords);
}
}
Words starting with 'a': [apple]
Word lengths: [5, 6, 6, 5, 6]
Distinct words: [apple, banana, orange, grape]
Sorted words: [apple, banana, banana, grape, orange]
First three words: [apple, banana, orange]
Skipped first two words: [orange, grape, banana]
Terminal operations in Java streams are the final operations that produce a result or a side-effect. Once a terminal operation is applied to a stream, it consumes the stream and produces a result, such as a list, a value, or even performing an action like printing elements.
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<String> words = Arrays.asList("apple", "banana", "orange", "grape", "banana");
// forEach terminal operation
System.out.println("Printing each word:");
words.stream().forEach(System.out::println);
// count terminal operation
long wordCount = words.stream().count();
System.out.println("Total words count: " + wordCount);
// min/max terminal operation
Optional<String> minWord = words.stream().min(String::compareToIgnoreCase);
minWord.ifPresent(min -> System.out.println("Minimum word: " + min));
// findFirst terminal operation
Optional<String> firstWord = words.stream().findFirst();
firstWord.ifPresent(first -> System.out.println("First word: " + first));
// anyMatch terminal operation
boolean hasApple = words.stream().anyMatch(word -> word.equals("apple"));
System.out.println("Does the list contain 'apple'? " + hasApple);
// allMatch terminal operation
boolean allHaveLengthGreaterThanTwo = words.stream().allMatch(word -> word.length() > 2);
System.out.println("Do all words have length greater than 2? " + allHaveLengthGreaterThanTwo);
// noneMatch terminal operation
boolean noneHaveLengthGreaterThanTen = words.stream().noneMatch(word -> word.length() > 10);
System.out.println("Do none of the words have length greater than 10? " + noneHaveLengthGreaterThanTen);
// collect terminal operation toList
List<String> collectedList = words.stream().filter(word -> word.length() > 5).collect(Collectors.toList());
System.out.println("Words with length greater than 5: " + collectedList);
// reduce terminal operation
Optional<String> concatenatedWords = words.stream().reduce((word1, word2) -> word1 + ", " + word2);
concatenatedWords.ifPresent(concatenated -> System.out.println("Concatenated words: " + concatenated));
// toArray terminal operation
Object[] wordsArray = words.stream().toArray();
System.out.println("Words as array: " + Arrays.toString(wordsArray));
}
}
Printing each word:
apple
banana
orange
grape
banana
Total words count: 5
Minimum word: apple
First word: apple
Does the list contain 'apple'? true
Do all words have length greater than 2? true
Do none of the words have length greater than 10? true
Words with length greater than 5: [orange, banana]
Concatenated words: apple, banana, orange, grape, banana
Words as array: [apple, banana, orange, grape, banana]
