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]"