Guava Lists.partition() method in Java
In this post, we will discuss how to partition a list into sublists in Java using Guava Lists.partition() method, and explain its advantages and disadvantages. We will also compare it with some other alternatives that you can use to partition a list in Java.
The standard Java collections API does not provide a built-in method to split a large list into smaller sublists of a fixed size. You might have to write your own logic using loops and indexes, which can be tedious and error-prone. The Lists.partition() method provides a better way to partition a list in Java.
1. Overview of Lists.partition() method
The Guava Lists.partition() method is a static method that takes a list and a size as parameters, and returns a list of sublists of that size. Each sublist is a view of the original list, which means that changes in the original list are reflected in the sublists. The syntax of the Lists.partition() method is as follows:
|
1 |
public static <T> List<List<T>> partition(List<T> list, int size) |
The list parameter is the list that you want to partition into sublists. The size parameter is the desired size of each sublist. The size must be positive, otherwise an IllegalArgumentException will be thrown. The return value is a list of sublists, each of which has the same size as the size parameter, except possibly the last one, which may be smaller if the original list size is not divisible by the size parameter. For example, if you want to partition a list of integers into sublists of size 3, you can use the Lists.partition() method as follows:
|
1 2 3 4 5 6 7 8 9 10 |
import com.google.common.collect.Lists; import java.util.List; class Main { public static void main(String[] args) { List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8); List<List<Integer>> partitions = Lists.partition(numbers, 3); System.out.println(partitions); // [[1, 2, 3], [4, 5, 6], [7, 8]] } } |
2. Advantages and Disadvantages of Using Lists.partition() method
The Lists.partition() method has some advantages and disadvantages when compared with other methods of partitioning a list in Java.
- One advantage is that it is simple and convenient to use. You don’t have to write any loops or indexes to split the list into sublists. You just need to pass the list and the size to the method, and get the result as a list of sublists.
- Another advantage is that it is efficient and lazy. The method does not create any copies of the original list or its elements. It only creates views of the original list using the
List.subList()method internally. This means that it does not consume any extra memory or time for creating new lists or elements. Moreover, the sublists are created on demand, which means that they are only computed when they are accessed. - One disadvantage is that it needs an additional dependency on the Guava library. This means that you may have to include Guava as an external dependency if your project does not already use it. This could make your project bigger and more complicated.
- Another disadvantage is that it does not support concurrent modification of the original list. Since the sublists are views of the original list, any changes in the original list will affect the sublists as well. However, this also means that if you try to modify the original list while iterating over the sublists, you might get a
ConcurrentModificationException. Therefore, you should avoid modifying the original list while using theLists.partition()method.
3. Alternatives to Lists.partition() method
One alternative is to use the Stream API from Java 8 or higher. You can use the Stream.collect() method with a custom Collector that partitions the stream elements into sublists of a given size. For example, you can create a Collector which creates a list of sublists, each of which has the same size as the size parameter, except possibly the last one, which may be smaller. We can use an ArrayList to store the sublists, and another ArrayList to store the elements of each sublist. Then, you can use this Collector with the Stream.collect() method as follows:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
import java.util.ArrayList; import java.util.List; import java.util.stream.Collector; class Main { public static <T> Collector<T, ?, List<List<T>>> partitioningBySize(int size) { return Collector.of( ArrayList::new, (list, element) -> { List<T> lastPartition = list.isEmpty() ? null : list.get(list.size() - 1); if (lastPartition == null || lastPartition.size() == size) { lastPartition = new ArrayList<>(size); list.add(lastPartition); } lastPartition.add(element); }, (list1, list2) -> { List<List<T>> result = new ArrayList<>(list1); result.addAll(list2); return result; } ); } public static void main(String[] args) { List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8); List<List<Integer>> partitions = numbers.stream().collect(partitioningBySize(3)); System.out.println(partitions); // [[1, 2, 3], [4, 5, 6], [7, 8]] } } |
The result will be the same as using the Lists.partition() method. The advantage of using this alternative is that it does not require any external dependency on Guava. It also supports concurrent modification of the original list, since it creates copies of the elements and sublists. The disadvantage of using this alternative is that it is more verbose and complex than using the Lists.partition() method. It also consumes more memory and time than using the Lists.partition() method, since it creates copies of the elements and sublists.
Another alternative is to use a third-party library that provides a similar functionality as the Lists.partition() method. For example, you can use the Apache Commons Collections library, which has a ListUtils.partition() method that works in a similar way as the Lists.partition() method. You can use it as follows:
|
1 2 3 4 5 6 7 8 9 10 |
import org.apache.commons.collections4.ListUtils; import java.util.List; class Main { public static void main(String[] args) { List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8); List<List<Integer>> partitions = ListUtils.partition(numbers, 3); System.out.println(partitions); // [[1, 2, 3], [4, 5, 6], [7, 8]] } } |
The result will be the same as using the Lists.partition() method. The advantage of using this alternative is that it is simple and convenient to use. It also supports concurrent modification of the original list. An extra dependency on the Apache Commons Collections library is required by this alternative, which is a disadvantage. It also does not support lazy evaluation of the sublists, which means that it creates all the sublists eagerly when the method is called.
4. Conclusion
In this post, we have covered how to use the Guava Lists.partition() method in Java, which is a simple and efficient way to partition a list into sublists of a fixed size. We have also explained its advantages and disadvantages, and compared it with some other alternatives that you can use to partition a list in Java.
If you want to learn more about this method, you can check out the Guava official website or its GitHub repository.
Thanks for reading.
To share your code in the comments, please use our online compiler that supports C, C++, Java, Python, JavaScript, C#, PHP, and many more popular programming languages.
Like us? Refer us to your friends and support our growth. Happy coding :)