{"id":17440,"date":"2023-10-08T08:08:22","date_gmt":"2023-10-08T07:08:22","guid":{"rendered":"https:\/\/www.baeldung.com\/?p=166768"},"modified":"2023-10-08T08:08:22","modified_gmt":"2023-10-08T07:08:22","slug":"partition-a-stream-in-java","status":"publish","type":"post","link":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/2023\/10\/08\/partition-a-stream-in-java\/","title":{"rendered":"Partition a Stream in Java"},"content":{"rendered":"

\"\"<\/p>\n

1. Overview<\/h2>\n
<\/div>\n

In this tutorial, we’ll explore various techniques for partitioning a Java 8 Stream<\/em> based on a fixed maximum size.<\/p>\n

We’ll start by revisiting how to accomplish this with List<\/em>s. Subsequently, we’ll enhance our approach by incorporating Stream<\/em>-specific functionalities, such as lazy evaluation and thread safety.<\/p>\n

2. Partitioning a List<\/em><\/h2>\n
<\/div>\n

There are various ways of partitioning a List<\/em><\/a> in Java. One easy way of doing it would be to start by determining the desired number of batches based on the desired batch size and the size of the source list:<\/strong><\/p>\n

static <T> Stream<List<T>> partitionList(List<T> source, int batchSize) {\r\n    int nrOfFullBatches = (source.size() - 1) \/ batchSize;\r\n    \/\/ ...\r\n}<\/code><\/pre>\n
To partition the source list into smaller sub-lists, our initial step involves computing the indices that demarcate the starting and ending points of each batch. While performing this calculation, we should keep in mind that the last batch may have a smaller size compared to the others:<\/p>\n
int startIndex = batch * batchSize;\r\nint endIndex = (batch == nrOfFullBatches) ? source.size() : (batch + 1) * batchSize;<\/code><\/pre>\n
Finally, we can add some validations and cover all the corner case scenarios. For example, when the source list is empty or if batchSize<\/em> is a negative number:<\/p>\n
static <T> Stream<List<T>> partitionList(List<T> source, int batchSize) {\r\n    if (batchSize <= 0) {\r\n        throw new IllegalArgumentException(String.format("The batchSize cannot be smaller than 0. Actual value: %s", batchSize));\r\n    }\r\n    if (source.isEmpty()) {\r\n        return Stream.empty();\r\n    }\r\n    int nrOfFullBatches = (source.size() - 1) \/ batchSize;\r\n    return IntStream.rangeClosed(0, nrOfFullBatches)\r\n      .mapToObj(batch -> {\r\n          int startIndex = batch * batchSize;\r\n          int endIndex = (batch == nrOfFullBatches) ? source.size() : (batch + 1) * batchSize;\r\n          return source.subList(startIndex, endIndex);\r\n      });\r\n}<\/code><\/pre>\n
Finally, let’s test the solution. For an input list of numbers from 1<\/em> to 8<\/em> and a batch size of 3<\/em>, we’ll expect three sub-lists:<\/p>\n
@Test\r\nvoid whenPartitionList_thenReturnThreeSubLists() {\r\n    List<Integer> source = List.of(1, 2, 3, 4, 5, 6, 7, 8);\r\n    Stream<List<Integer>> result = partitionList(source, 3);\r\n    assertThat(result).containsExactlyInAnyOrder(\r\n      List.of(1, 2, 3),\r\n      List.of(4, 5, 6),\r\n      List.of(7, 8)\r\n    );\r\n}<\/code><\/pre>\n
3. Partitioning a Parallel Stream<\/em><\/h2>\n
<\/div>\n
Stream<\/em><\/a>s come with distinctive characteristics, such as lazy evaluation and the capacity for parallel processing. Embracing these features can be achieved by creating a custom Collector<\/a>. <\/em><\/strong><\/p>\n
Moreover, given that the desired return type is a list of sub-lists, we’ll also make use of certain functions already defined by Collectors.toList()<\/em>, which we’ll refer to as the downstream<\/em> collector:<\/p>\n
static <T> List<List<T>> partitionStream(Stream<T> source, int batchSize) {\r\n    return source.collect(partitionBySize(batchSize, Collectors.toList()));\r\n}\r\nstatic <T, A, R> Collector<T, ?, R> partitionBySize(int batchSize, Collector<List<T>, A, R> downstream) {\r\n    return Collector.of( ... );\r\n}<\/code><\/pre>\n
We can create a Collector<\/em> using the static<\/em> factory method Collector.of()<\/em>. Let’s consult the documentation<\/a> and see what each of the parameters represents:<\/p>\n