jupyter/chapter25-stream.ipynb

{
  "cells": [{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["# Stream\n", "A stream is an API that defines a query on a source of values.\n", "It's an abstraction of loops over values using a declarative API,\n", "an API that describe the result you want and not how to compute it.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["By example, to count the number of persons with a name starting by 'E',\n", "one can write\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var names = List.of(\"Evan\", \"Helen\", \"Ebo\");\n", "var count = 0;\n", "for(var name: names) {\n", "  if (name.startsWith(\"E\")) {\n", "    count++;\n", "  }\n", "}\n", "System.out.println(count);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["But using a stream, it's simpler\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var names = List.of(\"Evan\", \"Helen\", \"Ebo\");\n", "var count = names.stream().filter(name -> name.startsWith(\"E\")).count();\n", "System.out.println(count);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Why using streams instead of loops\n", "The main reason is that it makes the code more readable,\n", "obviously once you are used to read stream query,\n", "- by allowing to easily compose operations\n", "- by removing the declaration of intermediary local variables/states\n", "  (the variable `count` in the example above).\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Sources\n", "There are several ways to create a stream depending on the source\n", "(The following examples are using `count()` to compute the number of values,\n", "we will see later that the API is richer)\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["- stream of values\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var empty = Stream.empty();\n", "var one = Stream.of(4);\n", "var many = Stream.of(\"hello\", \"stream\");\n", "System.out.println(\"empty count \" + empty.count());\n", "System.out.println(\"one count \" + one.count());\n", "System.out.println(\"many count \" + many.count());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["- stream from a collection\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var listStream = List.of(1, 2, 3, 4).stream();\n", "var mapStream = Map.of(\"bob\", 3, \"ana\", 7).keySet().stream();\n", "System.out.println(\"list count \" + listStream.count());\n", "System.out.println(\"map keys count \" + mapStream.count());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["- stream from a range\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var range = IntStream.range(0, 10);\n", "System.out.println(\"range count \" + range.count());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Primitive version\n", "Streams are represented by several classes, `java.util.stream.Stream` for a stream of objects and\n", "`IntStream`, `DoubleStream` and `LongStream` for a stream of ints, doubles and longs.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Stream<String> many = Stream.of(\"hello\", \"stream\");\n", "IntStream ints = IntStream.range(0, 10);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Using specialized classes for the numeric types:\n", "- avoid boxing, an IntStream is more efficient than a Stream<Integer>\n", "- `boxed()` convert to a Stream of wrapper\n", "- offer supplementary numeric methods like, `min`, `max`, `sum()`, etc.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["To sum of the values between [0, 10[\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var range = IntStream.range(0, 10);\n", "System.out.println(\"range sum: \" + range.sum());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Filter, map and flatMap\n", "The main transformation methods are `filter`, `map` and `reduce`.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### filtering\n", "`filter()` take a function as parameter and keep in the stream the values\n", "for which the function returned true.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Employee(String name, int age) { }\n", "var employees = List.of(new Employee(\"bob\", 55), new Employee(\"Ana\", 32));\n", "var youngCount = employees.stream().filter(e -> e.age() < 30).count();\n", "System.out.println(youngCount);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### mapping\n", "`map()` transforms a value to another value\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Employee(String name, int age) { }\n", "var employees = List.of(new Employee(\"Bob\", 55), new Employee(\"Ana\", 32));\n", "var array = employees.stream().map(Employee::name).toArray();\n", "System.out.println(Arrays.toString(array));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["`map()` has variations (`mapToInt`, `mapToLong`, etc) to transform to numeric streams\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Employee(String name, int age) { }\n", "var employees = List.of(new Employee(\"bob\", 55), new Employee(\"Ana\", 32));\n", "var average = employees.stream().mapToInt(Employee::age).average();\n", "System.out.println(average);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### flatMap\n", "`flatMap()` transforms one value to 0 to _n_ values\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Friend(String name, List<String> pets) { }\n", "var friends = List.of(new Friend(\"Bob\", List.of()),\n", "   new Friend(\"Ana\", List.of(\"dog\", \"cat\")),\n", "   new Friend(\"Uno\", List.of(\"rabbit\"))\n", "   );\n", "System.out.println(friends.stream().flatMap(friends -> friends.pets().stream()).count());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Like map, flatMap has also variation to numeric streams\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Friend(String name, List<Integer> kidAges) { }\n", "var friends = List.of(new Friend(\"Bob\", List.of(1, 3)),\n", "   new Friend(\"Ana\", List.of(15, 17)),\n", "   new Friend(\"Uno\", List.of())\n", "   );\n", "System.out.println(friends.stream().flatMapToInt(friends -> friends.kidAges().stream().mapToInt(x -> x)).average());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["You can notice that while there is a method boxed() to transform a numeric stream to an object stream,\n", "there is no method unboxToInt() equivalent because `mapToInt()` can be used instead.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### flatMap is a generalization of filter and map\n", "`filter()` result in a stream with 0 or 1 value, `map()` result in a stream with one transformed value so\n", "both can be simulated with `flatMap()`.\n", "So instead of\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Employee(String name, int age) { }\n", "var employees = List.of(new Employee(\"Bob\", 55), new Employee(\"Ana\", 32));\n", "System.out.println(employees.stream().filter(e -> e.age() < 30).count());\n", "System.out.println(Arrays.toString(employees.stream().map(Employee::name).toArray()));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["one can write\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["System.out.println(employees.stream().flatMap(e -> (e.age() < 30)? Stream.of(e): Stream.empty()).count());\n", "System.out.println(Arrays.toString(employees.stream().flatMap(e -> Stream.of(e.name())).toArray()));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["While flatMap can simulate filter and map, please use `filter()` and `map()` directly because \n", "the code is more readable and they are implemented in a more effective way.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Distinct, sorted, min and max\n", "Like in SQL, you can ask to filter values to only have distinct values or sort\n", "the value with a comparator.\n", "`distinct()` or `sorted()` are operations that requires to store all the values\n", "in an intermediary collection so they are not cheap.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["`distinct()` ask for unique values\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["System.out.println(IntStream.range(0, 10).map(x -> x / 2).distinct().count());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["`sorted()` ask to sort the values with a comparator\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Employee(String name, int age) { }\n", "var employees = List.of(new Employee(\"Bob\", 55), new Employee(\"Ana\", 32));\n", "var youngest = employees.stream().sorted(Comparator.comparingInt(Employee::age)).findFirst();\n", "System.out.println(youngest);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["The Stream API also provides `min()` and `max()` that are more efficient that sorting\n", "all the values if you just want the minimum or the maximum\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var youngest = employees.stream().min(Comparator.comparingInt(Employee::age));\n", "System.out.println(youngest);\n", "var oldest = employees.stream().max(Comparator.comparingInt(Employee::age));\n", "System.out.println(oldest);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## ForEach, reduce, collect and toArray\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### forEach\n", "Takes a consumer as parameter that is called for each values of the stream\n", "This method is not used often because if you want to do a side effect on collection\n", "using the method `collect` is easier.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Point(int x, int y) { }\n", "var points = List.of(\n", "  new Point(1, 2), new Point(2, 5), new Point(3, -1));\n", "points.stream().filter(p -> p.x() <= 2).forEach(System.out::println);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Note: collections (`java.util.Collection`) already have a method `forEach()`,\n", "so no need to create a stream if you don't want to do a transformation on the\n", "elements of the collection \n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Point(int x, int y) { }\n", "var points = List.of(new Point(2, 5));\n", "points.stream().forEach(System.out::println); // stupid !\n", "points.forEach(System.out::println);  // better\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### reduce\n", "Reduce allows to reduce all the values of a stream to only one result\n", "by applying iteratively the same accumulator function on each value of the stream.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["There are two forms of reduce\n", "- reduce the stream values\n", "- reduce using projected values\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["reduce with the stream values\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Point(int x, int y) { }\n", "var points = List.of(\n", "  new Point(1, 2), new Point(2, 5), new Point(3, -1));\n", "var sum = points.stream().reduce((p1, p2) -> new Point(p1.x() + p2.x(), p1.x() + p2.x()));\n", "System.out.println(\"sum \" + sum);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["You can notice that the result is an `Optional` because is the stream is empty, `reduce`\n", "has no result to return\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["reduce using projected values\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Point(int x, int y) { }\n", "var points = List.of(\n", "  new Point(1, 2), new Point(2, 5), new Point(3, -1));\n", "var sumX = points.stream().reduce(0, (acc, p) -> acc + p.x(), Integer::sum);\n", "System.out.println(\"sumX \" + sumX);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["The first argument is the initial accumulator value, this is also the value\n", "returned is the stream is empty so this variation of reduce doesn't return an `Optional`. \n", "The last argument of `reduce()` is only used in parallel to aggregate the values\n", "process on different threads (see below for more info on parallel streams).\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### collect\n", "reduce works well when the result is one value but not well when the result\n", "is a list, a map or any data structures because collections are mutable\n", "in Java.\n", "For that, there is another mechanism, called `collect` that takes\n", "a `Collector` as parameter and is tailored to create, mutate, merge and\n", "optionally makes unmodifiable any mutable collections.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["This section contains only a small number of example because there is a following chapter\n", "dedicated to collector.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["While you can create your own collector by implementing the interface `Collector`,\n", "there are already more than 20 collectors available in the class `Collectors` \n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["import java.util.stream.Collectors;\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["`toList()`: gather all values to a list\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var names = List.of(\"Bob\", \"Ana\", \"Elvis\", \"Emma\", \"Josh\");\n", "var endsWithA = names.stream().filter(name -> name.endsWith(\"a\")).collect(Collectors.toList());\n", "System.out.println(endsWithA);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["`toUnmodifiableist()`: gather all values to an unmodifiable list\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var names = List.of(\"Bob\", \"Ana\", \"Elvis\", \"Emma\", \"Josh\");\n", "var uppercases = names.stream().map(String::toUpperCase).collect(Collectors.toUnmodifiableList());\n", "System.out.println(uppercases);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["`toMap()`: gather all values to a map\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var names = List.of(\"Bob\", \"Ana\", \"Elvis\", \"Emma\", \"Josh\");\n", "var uppercaseMap = names.stream().collect(Collectors.toMap(name -> name, String::toUpperCase));\n", "System.out.println(uppercaseMap);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["`joining()`: gather all strings to one string\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var names = List.of(\"Bob\", \"Ana\", \"Elvis\", \"Emma\", \"Josh\");\n", "var asString = names.stream().collect(Collectors.joining(\", \"));\n", "System.out.println(asString);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["`groupingBy()`: gather all values into a map of list of values \n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var names = List.of(\"Bob\", \"Ana\", \"Elvis\", \"Emma\", \"Josh\");\n", "var nameByLength = names.stream().collect(Collectors.groupingBy(String::length));\n", "System.out.println(nameByLength);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### toArray\n", "Because in Java, array are typed at runtime there are two ways to create an array\n", "from a stream\n", "- as an array of Object\n", "- as an array of a specific type\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["As an array Object\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var names = List.of(14, 67, 32, 78);\n", "Object[] array = names.stream().toArray();\n", "System.out.println(Arrays.toString(array));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["As an array of a specific type, passing the constructor as argument\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var names = List.of(14, 67, 32, 78);\n", "Integer[] array = names.stream().toArray(Integer[]::new);\n", "System.out.println(Arrays.toString(array));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Note that you can provide an array type with a more specific type\n", "because the VM will do a runtime check when the values are inserted\n", "The following example compiles but throws a ClassCastException at runtime\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["List<Object> names = List.<Object>of(14, 67, 32, \"boom !\");\n", "Integer[] array = names.stream().toArray(Integer[]::new);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Infinite Stream\n", "Streams can be infinite (like you can create an infinite loop),\n", "and you have shortcut methods to stop the loop.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["generate an infinite number of random values between [0, 10[ as String\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var random = new Random(0);\n", "var stream = Stream.generate(() -> \"\" + random.nextInt(10));\n", "System.out.println(stream.limit(5).collect(Collectors.toList()));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["iterate over all the power of two values\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var stream = IntStream.iterate(1, x -> x* 2);\n", "System.out.println(stream.limit(5).boxed().collect(Collectors.toList()));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Shortcut method `limit()`\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var sum = IntStream.iterate(1, x -> x* 2).limit(10).sum();\n", "System.out.println(\"sum: \" + sum);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Shortcut method `dropWhile()`\n", "All lines after the one that starts with `#` have a length greater than 10\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var text = \"\"\"\n", "  # a line\n", "  # another one\n", "  a line that doesn't start with #\n", "  \"\"\";\n", "var result = text.lines().dropWhile(l -> l.startsWith(\"#\")).allMatch(s -> s.length() > 10);\n", "System.out.println(result);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Shortcut method `takeWhile()`\n", "Find the first words that have a length lesser than 5\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var list = List.of(\"foo\", \"bar\", \"baz\", \"whizzzz\", \"bob\");\n", "var result = list.stream().takeWhile(s -> s.length() < 5).collect(Collectors.joining(\", \"));\n", "System.out.println(result);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Sequential vs parallel API\n", "By default stream are executed sequentially in the same thread (think CPU core if you don't know what a thread is).\n", "You can ask to split the processing of the stream on several threads using `.parallel()`\n", "Using `.parallel()` is usually slower because you have to first distribute the calculation\n", "and at the end gather the results from several threads. As a rule of thumb, it only worth to use `.parallel()`\n", "if either you have a lot of value (like 100_000 or more) or the calculation is slooow.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["By example, if you want to calculate the square root (not a slow operation) on the first 1_000_000 values\n", "and prints only the first 10 values\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["import static java.util.stream.Collectors.toList;\n", "var squareRoots = IntStream.range(0, 1_000_000).parallel().mapToDouble(Math::sqrt).toArray();\n", "System.out.println(Arrays.stream(squareRoots).limit(10).boxed().collect(toList()));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### findAny()/findFirst(), forEach()/forEachOrdered()\n", "Because a stream can be evaluated in parallel and maintaining a strict order in parallel cost a lot,\n", "usual methods like `findAny()` or `forEach()` doesn't maintain the order on a parallel stream.\n", "You have to use specialized method (resp `findFirst()` and `forEachOrdered()`) to maintain the order.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Limitations\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Reusing stream objects\n", "You can not reuse a stream for several queries\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var stream = Stream.of(1, 2, 3);\n", "System.out.println(stream.count());\n", "System.out.println(stream.count());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["> One query, one stream !\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Source mutation\n", "A stream can not modify the source from which it was created\n", "The following example throws a ConcurrentModificationException\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var list = new ArrayList<>(List.of(\"foo\", \"bar\"));\n", "list.stream().map(String::toUpperCase).forEach(list::add); \n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Use an iterator (in the example a `ListIterator`) for that\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var list = new ArrayList<>(List.of(\"foo\", \"bar\"));\n", "var it = list.listIterator();\n", "while(it.hasNext()) {\n", "  var value = it.next();\n", "  it.add(value.toUpperCase());\n", "}\n", "System.out.println(list);\n"]
}
],
  "metadata": {
    "kernelspec": {
      "display_name": "Java",
      "language": "java",
      "name": "java"
    },
    "language_info": {
      "codemirror_mode": "java",
      "file_extension": ".java",
      "mimetype": "text/x-java-source",
      "name": "Java",
      "pygments_lexer": "java",
      "version": "15"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}