In Java, there are multiple ways to convert a char to a String. Below are the three most commonly used methods:
- Using the Character.toString() method
- Using the String.valueOf() method
- Using the String constructor that accepts a char array
Convert char to String using the Character.toString() method
To convert a character to a string, use the toString() method from the Character Wrapper class, as shown in the example below:
Note that this is an instance method, not a static method. To learn more about the difference between these two, refer to the Java Instance and Static Methods tutorial.
public class Test {
public static void main(String[] args) {
char ch = 'a';
String str = Character.toString(ch); // returns String representation of the provided char
}
}
Convert char to String in Java using the String.valueOf() method
There is a valueOf() static method in the String class that returns the String representation of its argument, which can be a char or any other data type.
public class Test {
public static void main(String[] args) {
char ch = 'a';
String str = String.valueOf(ch);
}
}
Using the String constructor that accepts a char array
We can convert a char to a String by creating a new String object and passing a char array as an argument. For example:
public class Test {
public static void main(String[] args) {
char ch = 'a';
String str = new String(new char[]{ch});
}
}
Here, we passed an anonymous char array to the constructor of the String class, and we populated it with our input char. This constructor returned a String representation of the provided char array.
Converting an array of chars to a String using the String constructor
In addition to the String constructor that accepts a char array, there are two more constructors that accept char arrays: String(char[] value, int offset, int count) and String(char[] value, int offset, int count, int valueOffset).
The first constructor takes three arguments: value, offset, and count. value is the char array from which the String is created, offset is the index of the first char to include in the String, and count is the number of chars to include. For example:
char[] chars = {'h', 'e', 'l', 'l', 'o'};
String s = new String(chars, 0, 2); // s is "he"
In this example, the String constructor creates a new String object from the chars array, starting at index 0 (the first char, ‘h’) and taking two chars (‘h’ and ‘e’).
The second constructor takes four arguments: value, offset, count, and valueOffset. value, offset, and count are the same as in the first constructor, and valueOffset is the index of the char array at which to start looking for chars to include in the String. For example:
char[] chars = {'h', 'e', 'l', 'l', 'o'};
String s = new String(chars, 1, 3, 1); // s is "ell"
In this example, the String constructor creates a new String object from the chars array, starting at index 1 (the second char, ‘e’) and taking three chars (‘e’, ‘l’, and ‘l’). However, the valueOffset argument tells the constructor to start looking for chars at index 1 of the chars array, so the resulting String is “ell”.
These constructors allow you to create a String from a subset of a char array, which can be useful in some situations. However, keep in mind that creating a new String object involves creating a new array and copying the chars, so this approach may be less efficient than using the Character.toString() or String.valueOf() methods for converting a single char to a String.
Converting a single char to a String using concatenation
Another way to convert a char to a String is by concatenating it with an empty String. This approach involves using the overloaded + operator, which is defined for String and char types. For example:
char c = 'a'; String s = "" + c;
In this example, the char variable c is concatenated with an empty String, resulting in a new String object that contains the character “a”. This approach is less efficient than using the Character.toString() or String.valueOf() methods, because it involves creating an extra String object and performing a concatenation operation. However, it can be useful in some situations, such as when you need to concatenate multiple char variables or literals into a single String.
Here’s an example that demonstrates the use of concatenation to convert multiple char values to a String:
char a = 'a'; char b = 'b'; char c = 'c'; String s = "" + a + b + c; System.out.println(s); // Output: "abc"
In this example, the char variables a, b, and c are concatenated using the + operator and an empty String, resulting in a new String object that contains the characters “abc”. However, keep in mind that using concatenation to convert char values to String can be slower and less efficient than using the Character.toString() or String.valueOf() methods, especially when dealing with large strings or loops.
Performance considerations
When it comes to converting char to String in Java, there are a few performance considerations to keep in mind.
Firstly, if you’re converting a single char to a String, using concatenation (e.g., String s = "" + c;) is generally less efficient than using the Character.toString() or String.valueOf() methods. This is because concatenation creates a new String object and copies the char to it, whereas the toString() and valueOf() methods create only one object.
Secondly, when converting an array of chars to a String, using the String constructor that accepts a char array (e.g., String s = new String(chars);) can be slower than using the String constructor that accepts a subset of the char array (e.g., String s = new String(chars, offset, count);). This is because the former creates a new array and copies all the chars to it, whereas the latter simply references the existing array.
That said, the performance differences between these methods are usually negligible in most use cases. Therefore, it’s important to choose the method that best fits your needs and preferences, rather than solely based on performance considerations.