limit(n)
filter map
collect forEach
java
List<String> names = Arrays.asList("Naveen", "Bob", "Charlie");
Stream<String> nameStream = names.stream();
java
String[] namesArray = {"Alice", "Bob", "Charlie"};
Stream<String> arrayStream = Arrays.stream(namesArray);
java
// Stream.of
Stream<Integer> numbersStream = Stream.of(1, 2, 3, 4, 5);
// Stream.iterate (infinite)
Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 2); // even numbers
// Stream.generate (infinite)
Stream<Double> randomNumbers = Stream.generate(Math::random);
java
try (Stream<String> lines = Files.lines(Paths.get("file.txt"))) {
lines.forEach(System.out::println);
} catch (IOException e) {
e.printStackTrace();
}
java
String str = "hello";
IntStream charStream = str.chars(); // Returns IntStream of char values
filter(Predicate<T>) stream.filter(n -> n > 5)
map(Function<T,R>) stream.map(String::toUpperCase)
stream.flatMap(s ->
flatMap(Function<T,Stream<R>>)
Arrays.stream(s.split("")))
distinct() stream.distinct()
sorted() stream.sorted()
sorted(Comparator<T>) stream.sorted(Comparator.reverseOrder()
peek(Consumer<T>) stream.peek(System.out::println)
limit(long n) stream.limit(5)
skip(long n) stream.skip(2)
forEach(Consumer<T>) stream.forEach(System.out::println)
collect(Collector<T,A,R>) stream.collect(Collectors.toList())
reduce(BinaryOperator<T>) stream.reduce(0, Integer::sum)
count() stream.count()
stream.anyMatch(s ->
anyMatch(Predicate<T>)
s.startsWith("A"))
allMatch(Predicate<T>) stream.allMatch(n -> n > 0)
noneMatch(Predicate<T>) stream.noneMatch(n -> n < 0)
findFirst() stream.findFirst()
findAny() stream.findAny()
min(Comparator<T>) stream.min(Comparator.naturalOrder())
max(Comparator<T>) stream.max(Comparator.naturalOrder())
toArray() stream.toArray()
java
List<String> names = Arrays.asList("Naveen", "Bob", "Charlie", "David", "Eva");
List<String> filteredNames = names.stream()
.filter(name -> name.length() > 4)
.collect(Collectors.toList());
// Result: [Naveen, Charlie, David]
java
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<Integer> nameLengths = names.stream()
.map(String::length)
.collect(Collectors.toList());
// Result: [5, 3, 7]
java
List<List<Integer>> nestedLists = Arrays.asList(
Arrays.asList(1, 2, 3),
Arrays.asList(4, 5, 6),
Arrays.asList(7, 8, 9)
);
List<Integer> flatList = nestedLists.stream()
.flatMap(Collection::stream)
.collect(Collectors.toList());
// Result: [1, 2, 3, 4, 5, 6, 7, 8, 9]
java
List<String> names = Arrays.asList("Charlie", "Naveen", "Bob", "Eva", "David");
// Natural ordering
List<String> sortedNames = names.stream()
.sorted()
.collect(Collectors.toList());
// Result: [Bob, Charlie, David, Eva, Naveen]
// Custom ordering
List<String> sortedByLength = names.stream()
.sorted(Comparator.comparing(String::length))
.collect(Collectors.toList());
// Result: [Bob, Eva, David, Naveen, Charlie]
java
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// Sum of all numbers
int sum = numbers.stream()
.reduce(0, Integer::sum);
// Result: 15
// Finding maximum
int max = numbers.stream()
.reduce(Integer.MIN_VALUE, Integer::max);
// Result: 5
// Concatenating strings
String concatenated = Stream.of("A", "B", "C")
.reduce("", String::concat);
// Result: "ABC"
java
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eva");
// To List
List<String> namesList = names.stream()
.filter(n -> n.length() > 3)
.collect(Collectors.toList());
// To Set
Set<String> namesSet = names.stream()
.filter(n -> n.length() > 3)
.collect(Collectors.toSet());
// To Map
Map<String, Integer> nameLengthMap = names.stream()
.collect(Collectors.toMap(
Function.identity(), // Key mapper
String::length // Value mapper
));
// Result: {Naveen=6, Bob=3, Charlie=7, David=5, Eva=3}
// Joining strings
String joined = names.stream()
.collect(Collectors.joining(", "));
// Result: "Naveen, Bob, Charlie, David, Eva"
// Grouping
Map<Integer, List<String>> groupedByLength = names.stream()
.collect(Collectors.groupingBy(String::length));
// Result: {3=[Bob, Eva], 5=[David], 6=[Naveen], 7=[Charlie]}
// Partitioning
Map<Boolean, List<String>> partitioned = names.stream()
.collect(Collectors.partitioningBy(n -> n.length() > 4));
// Result: {false=[Bob, Eva], true=[Naveen, Charlie, David]}
java
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// Count
long count = numbers.stream().count();
// Result: 10
// Sum
int sum = numbers.stream().mapToInt(Integer::intValue).sum();
// Result: 55
// Average
OptionalDouble average = numbers.stream().mapToInt(Integer::intValue).average();
// Result: OptionalDouble[5.5]
// Min and Max
OptionalInt min = numbers.stream().mapToInt(Integer::intValue).min();
// Result: OptionalInt[1]
OptionalInt max = numbers.stream().mapToInt(Integer::intValue).max();
// Result: OptionalInt[10]
// Statistics
IntSummaryStatistics stats = numbers.stream().mapToInt(Integer::intValue).summaryStatis
// Result: IntSummaryStatistics{count=10, sum=55, min=1, average=5.500000, max=10}
java
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eva");
// anyMatch
boolean anyStartsWithN = names.stream()
.anyMatch(name -> name.startsWith("N"));
// Result: true
// allMatch
boolean allLongerThan2 = names.stream()
.allMatch(name -> name.length() > 2);
// Result: true
// noneMatch
boolean noneStartWithZ = names.stream()
.noneMatch(name -> name.startsWith("Z"));
// Result: true
// findFirst
Optional<String> first = names.stream()
.filter(name -> name.startsWith("D"))
.findFirst();
// Result: Optional[David]
// findAny (may return any matching element, useful in parallel streams)
Optional<String> any = names.stream()
.filter(name -> name.length() > 3)
.findAny();
// Result: Optional containing any matching name
java
// Creating IntStream
IntStream intStream = IntStream.range(1, 6); // 1, 2, 3, 4, 5
IntStream closedRange = IntStream.rangeClosed(1, 5); // 1, 2, 3, 4, 5
// Mapping to specialized stream
List<String> names = Arrays.asList("Naveen", "Bob", "Charlie");
IntStream lengths = names.stream()
.mapToInt(String::length); // Returns IntStream instead of Stream<Integer>
// Boxing back to Stream<Integer>
Stream<Integer> boxedStream = IntStream.range(1, 6).boxed();
// Statistical operations on primitive streams
double avg = IntStream.rangeClosed(1, 100).average().orElse(0);
// Result: 50.5
java
// Creating parallel stream from a collection
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int sum = numbers.parallelStream()
.reduce(0, Integer::sum);
// Converting sequential stream to parallel
int sumParallel = numbers.stream()
.parallel()
.reduce(0, Integer::sum);
java
// Example showing potential issues with parallelism and state
// DO NOT DO THIS:
StringBuilder sb = new StringBuilder();
IntStream.range(0, 1000)
.parallel()
.forEach(i -> sb.append(i)); // Incorrect: shared mutable state
// Result will be unpredictable!
// CORRECT APPROACH:
String result = IntStream.range(0, 1000)
.parallel()
.mapToObj(String::valueOf)
.collect(Collectors.joining());
java
// Instead of:
stream.map(s -> s.toUpperCase())
// Use:
stream.map(String::toUpperCase)
java
// BAD:
List<String> collected = new ArrayList<>();
stream.forEach(s -> collected.add(s));
// GOOD:
List<String> collected = stream.collect(Collectors.toList());
java
// INEFFICIENT (filters all elements, then limits):
stream.filter(predicate).limit(n)
// EFFICIENT (stops filtering after finding n matching elements):
stream.limit(n).filter(predicate)
java
Stream<String> stream = list.stream();
long count = stream.count();
List<String> collected = stream.collect(Collectors.toList()); // ERROR: stream alre
java
// INCORRECT:
stream.filter(predicate); // Does nothing without terminal operation
// CORRECT:
stream.filter(predicate).collect(Collectors.toList());
java
// Will never terminate:
Stream.iterate(0, n -> n + 1).forEach(System.out::println);
// Correct:
Stream.iterate(0, n -> n + 1).limit(100).forEach(System.out::println);
java
// May return different values in parallel:
list.parallelStream().findAny()
java
// Instead of:
stream.filter(s -> s.length() > 3).collect(Collectors.toList());
// Consider:
stream.collect(Collectors.filtering(s -> s.length() > 3, Collectors.toList()));
java
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int sum = numbers.stream()
.filter(n -> n % 2 == 0) // Keep only even numbers
.mapToInt(n -> n * 2) // Double each number
.sum(); // Sum them up
System.out.println(sum); // Result: 60 (2*2 + 4*2 + 6*2 + 8*2 + 10*2)
java
class Person {
private String name;
private int age;
// Constructor, getters, setters...
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() { return name; }
public int getAge() { return age; }
}
List<Person> people = Arrays.asList(
new Person("Naveen", 25),
new Person("Bob", 30),
new Person("Nina", 20),
new Person("Nick", 35),
new Person("Charlie", 40)
);
double averageAge = people.stream()
.filter(p -> p.getName().startsWith("N"))
.mapToInt(Person::getAge)
.average()
.orElse(0);
System.out.println(averageAge); // Result: 26.67
java
List<String> sentences = Arrays.asList(
"Hello world",
"Hello Java",
"Java streams are powerful",
"Streams in Java"
);
Map<String, Long> wordFrequency = sentences.stream()
.flatMap(sentence -> Arrays.stream(sentence.toLowerCase().split("\\s+")))
.collect(Collectors.groupingBy(
Function.identity(),
Collectors.counting()
));
System.out.println(wordFrequency);
// Result: {hello=2, world=1, java=3, streams=2, are=1, powerful=1, in=1}
java
List<String> words = Arrays.asList("apple", "banana", "cherry", "date");
String result = words.stream()
.collect(Collectors.joining(
", ", // delimiter
"Fruits: [", // prefix
"]" // suffix
));
System.out.println(result);
// Result: "Fruits: [apple, banana, cherry, date]"
