Module 2 - Streams

Learning Objectives

• Recall that streams are only evaluated when a terminal operation is invoked
  Streams use lazy evaluation—intermediate operations create a pipeline but don't execute until a terminal operation is called. This allows for optimization and avoids unnecessary computation.

  List<String> names = Arrays.asList("John", "Jane", "Adam", "Eve");
  
  // This creates the pipeline but doesn't execute yet
  Stream<String> filteredStream = names.stream()
    .filter(name -> {
      System.out.println("Filtering: " + name);
      return name.startsWith("J");
    });
  
  // Terminal operation - NOW the pipeline executes
  filteredStream.count(); // Prints "Filtering: " messages
  
• Use streams to perform an operation on every object in a Collection
  The forEach() terminal operation allows you to execute an action on each element of a stream.

  List<Product> products = getProducts();
  
  // Print all product names
  products.stream()
    .forEach(product -> System.out.println(product.getName()));
  
  // Update all products
  products.stream()
    .forEach(product -> product.applyDiscount(0.1));
  
• Use streams to find all elements of a Collection that satisfy a provided condition
  The filter() method creates a stream consisting only of elements that match a given predicate.

  List<User> users = getUsers();
  
  // Find active premium users
  List<User> premiumActiveUsers = users.stream()
    .filter(User::isActive)
    .filter(user -> user.getSubscriptionType() == SubscriptionType.PREMIUM)
    .collect(Collectors.toList());
  
• Use streams to apply a Function to each element of a Collection
  The map() operation transforms each element in a stream by applying a function to it, creating a new stream of the transformed elements.

  List<Order> orders = getOrders();
  
  // Extract order IDs from order objects
  List<String> orderIds = orders.stream()
    .map(Order::getId)
    .collect(Collectors.toList());
  
  // Calculate total price for each order
  List<Double> orderTotals = orders.stream()
    .map(order -> order.getItems().stream()
      .mapToDouble(item -> item.getPrice() * item.getQuantity())
      .sum())
    .collect(Collectors.toList());
  
• Implement code to collect the elements of a Stream into a specified Collection
  The collect() terminal operation allows you to accumulate stream elements into different types of collections or custom containers.

  List<String> names = getNames();
  
  // Collect into a List
  List<String> namesList = names.stream()
    .filter(name -> name.length() > 3)
    .collect(Collectors.toList());
  
  // Collect into a Set (removes duplicates)
  Set<String> namesSet = names.stream()
    .collect(Collectors.toSet());
  
  // Collect into a Map
  Map<String, Integer> nameLengthMap = names.stream()
    .collect(Collectors.toMap(
      name -> name, // Key mapper
      name -> name.length() // Value mapper
    ));
  
• Compare and contrast stateful and stateless stream operations
  Stateless operations (like filter, map) don't need to know about other elements, while stateful operations (like sorted, distinct) need knowledge of all elements in the stream, potentially impacting performance.
• Recall that terminal operations are Stream methods that produce a non-Stream result
  Terminal operations like forEach(), collect(), count(), min(), max(), and reduce() trigger the processing of the stream pipeline and produce a final result or side effect.
• Recall that a short-circuiting terminal operation ends the stream as soon as it is satisfied
  Operations like findFirst(), findAny(), anyMatch(), allMatch(), and noneMatch() don't need to process the entire stream if they can determine the result early.

  boolean hasAdminUser = users.stream()
    .anyMatch(user -> user.getRole() == Role.ADMIN);
  
  Optional<User> firstActiveUser = users.stream()
    .filter(User::isActive)
    .findFirst();