Guava Chars.asList() method in Java
In this post, we will learn how to use the Guava Chars.asList() method in Java, which is a simple and convenient way to convert char arrays to lists of Character objects. We will also see the advantages and disadvantages of using this method compared to the built-in method, and how it compares with other ways to achieve the same in Java.
1. Limitations of Arrays.asList() method
To convert Character array to a list of Character objects, you can use the built-in Arrays.asList() method, which takes an array of objects as an argument and returns a list of objects. For example:
|
1 2 3 4 5 6 7 8 9 10 |
import java.util.Arrays; import java.util.List; class Main { public static void main(String[] args) { Character[] charArray = {'a', 'b', 'c', 'd', 'e'}; List<Character> list = Arrays.asList(charArray); System.out.println(list); // [a, b, c, d, e] } } |
However, this method has some limitations and drawbacks. It does not work with arrays of primitive types. If you pass an array of primitive type char as an argument, it will return a list of char[], not a list of Character. For example:
|
1 2 3 4 5 6 7 8 9 10 |
import java.util.Arrays; import java.util.List; class Main { public static void main(String[] args) { char[] charArray = {'a', 'b', 'c', 'd', 'e'}; List<char[]> list = Arrays.asList(charArray); // not what you want System.out.println(list); } } |
Also, it returns a fixed-size list backed by the original array. This means that you cannot add or remove elements from the list, or modify the original array without affecting the list. For example:
|
1 2 3 4 5 6 7 8 9 10 |
import java.util.Arrays; import java.util.List; class Main { public static void main(String[] args) { Character[] charArray = {'a', 'b', 'c', 'd', 'e'}; List<Character> list = Arrays.asList(charArray); list.add('f'); // throws UnsupportedOperationException } } |
2. Overview of Chars.asList() method
There is a better way to convert char arrays to lists of Character objects in Java. The Guava Chars.asList() method is a static method that takes an array of primitive type char as an argument and returns a list of wrapper type Character. The method returns a fixed-size list backed by the specified array. It is part of the Guava com.google.common.primitives package. The syntax is as follows:
|
1 |
public static List<Character> asList(char... backingArray) |
Here, backingArray is the array to back the list. The method infers the generic type parameter from the argument, so you don’t have to specify it explicitly. For example:
|
1 2 3 4 5 6 7 8 9 10 |
import com.google.common.primitives.Chars; import java.util.List; class Main { public static void main(String[] args) { char[] charArray = {'a', 'b', 'c', 'd', 'e'}; List<Character> list = Chars.asList(charArray); System.out.println(list); // [a, b, c, d, e] } } |
3. Advantages and Disadvantages of Chars.asList() method
The Guava Chars.asList() method is very simple and easy to use. However, it also has some advantages and disadvantages that you should be aware of. Some of the advantages of using the Guava Chars.asList() method are:
- It works with arrays of primitive types. Unlike the built-in
Arrays.asList()method, it can take an array of primitive type char as an argument and return a list of wrapper type Character. This can help you avoid unnecessary boxing and unboxing overheads or creating intermediate arrays. - It reduces boilerplate code and improves readability. You don’t have to specify the generic type parameter explicitly, which can be verbose and redundant.
Some of the disadvantages of using the Chars.asList() method are:
- It returns a fixed-size list backed by the original array. This means that you cannot add or remove elements from the list, or modify the original array without affecting the list.
- It requires an external dependency on the Guava library. This means that you have to add the library to your project and manage its version and compatibility. This can be an issue if you want to keep your project lightweight or avoid conflicts with other libraries.
4. Comparing with other methods in Java
There are other ways to convert char arrays to lists of Character objects in Java, besides the built-in Arrays.asList() method and the Guava Chars.asList() method. The recommended option is to using the Stream API from Java 8. You can use the IntStream.range() method to create a stream of int values from the array indices, and then use the mapToObj() method to convert them to Character objects, and then use the collect() method to collect them into a list. For example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import java.util.List; import java.util.stream.Collectors; import java.util.stream.IntStream; class Main { public static void main(String[] args) { char[] charArray = {'a', 'b', 'c', 'd', 'e'}; List<Character> list = IntStream.range(0, charArray.length) .mapToObj(i -> charArray[i]) .collect(Collectors.toList()); System.out.println(list); // [a, b, c, d, e] } } |
Alternatively, you can use the for-each loop to iterate over the elements of the array and add them to a new list. For example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import java.util.ArrayList; import java.util.List; class Main { public static void main(String[] args) { char[] charArray = {'a', 'b', 'c', 'd', 'e'}; List<Character> list = new ArrayList<>(); for (char c : charArray) { list.add(c); } System.out.println(list); // [a, b, c, d, e] } } |
That’s all about Guava Chars.asList() method in Java. For more information about this method, you can check out the Guava official documentation 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 :)