The contents of this string are copied into the specified character array using the JavaString getChars() class. The getChars() method has four arguments. The getChars() method is passed by four arguments.
Syntax:
getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
The getChars() method signature is given below:
Signature:
public void getChars(int srcBeginIndex, int srcEndIndex, char[] destination, int dstBeginIndex)
Parameters:
| Name | Description | Type |
| srcBegin | index after the last character in the string to copy. | int |
| srcEnd | index of the first character in the string to copy. | int |
| dst | the destination array. | char |
| dstBegin | the start offset in the destination array. | int |
int srcBeginIndex:
An index based on where the characters were copied.
int srcEndIndex:
The index at the location of the last character to which the copy will be made.
Target Char[]:
A char array into which to copy the characters from the string that calls the getChars() method.
int dstEndIndex:
From where the characters from the string will be moved, you can see their place in the target field.
Returns:
It’s not going to give you any value.
Exception Throws in Java
If any of the conditions specified above are fulfilled, this method will throw a StringIndexOutOfBoundsException.
- If the srcBeginIndex value is lower than zero.
- If the srcBeginIndex is greater than the srcEndIndex.
- If srcEndIndex exceeds the size of a string which is invoked by this method
- If the dstEndIndex is not at least zero.
- If dstEndIndex + (srcEndIndex – srcBeginIndex) is greater than the size of the destination array.
Internal implementation:
The signature or syntax of string getChars() method is given below:
void getChars(char dst[], int dstBegin)
{
// copies value from 0 to dst - 1
System.arraycopy(value, 0, dst, dstBegin, value.length);
}
Example:
import java.util.*;
public class TechVidvan
{
public static void main(String args[])
{
String str = new String("hello worldworld how r u");
char[] ch = new char[10];
try
{
str.getChars(6, 16, ch, 0);
System.out.println(ch);
}
catch(Exception ex)
{
System.out.println(ex);
}
}
}
Output:
worldworld
Use of getChars () method in Java:
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) The getChars() method is used to copy characters from a given string into the destination character array.
charAt(int index):
Returns the character from the given index in a string by this method.
length():
Returns the length of string number characters.
substring(int beginIndex, int endIndex):
Returns a new string from startIndexinclusive to endIndexexclusive, which is a substring of the original string.
indexOf:char ch:
Returns an index to the initial occurrence of a given character in this string.
LastIndexOf().char ch:
Returns an index for the most recent occurrence of a specified character in this string.
toCharArray():
Converts the string into an array of characters.
Advantages
Performance:
It may be better to use the String.getChars() method instead of manually adjusting characters in a string, and copying them into an array.
It aims at efficient mass copying of characters, which will allow it to be more effective in dealing with long strings.
Reduced Memory Usage:
You may be creating temporary strings or other objects that can increase memory consumption when you simply iterate over a string and copy the characters to an array.
You can copy characters directly into an existing array of characters using a method named String.getChars(), which reduces the need for additional objects.
Array Reuse:
For a number of calls to String.getChars(), the destination character array can be reused. This helps to avoid excessive memory allocations and allocation of resources.
Efficiency:
The String.getChars() method provides a way to directly access the internal character array of the String without creating additional String objects, which can be more memory-efficient and faster when working with large strings.
Direct Character Manipulation:
If you need to do operations on each character, such as changes, comparisons and analyses, this method is useful.
Disadvantages
Requires a Preallocated Array:
The fact that you must include a preallocated character array in order to copy characters into is one of the major drawbacks of String.getChars().
This means that in order to extract the substring you’re looking for, you must know its size beforehand.
You may get an IndexOutOfBoundsException if the array is not large enough to hold characters.
No Bounds Checking:
To ensure that the target range of characters really exists in your string, String.getChars() will not perform a bounds check. You may end up copying unexpected data or making errors in your program if you provide incorrect indices.
No Built-in String Manipulation:
While this method copies characters effectively, it does not have the ability to manipulate strings. You will need to manipulate the character array by direct manipulation if you want a substring modification after extraction.
Lack of Flexibility:
The String.getChars() method only provides the ability to copy characters into a character array.
You will have to manually convert the characters again if you need to copy them onto another type of destination.
Alternative ways of handling strings and character arrays in modern Java programming are: using the String.substring(). method which returns a new string that contains an original substring, or Using the “String.toCharArray” method to convert your whole string into a set of characters. The choice of method is a matter of your particular use case and requirements.
Considerations:
Index Validity:
For the avoidance of exceptions such as IndexOutOfBoundsException, it is important to ensure that indicesBegin, srcEnd, dsrcbegin are within a valid range.
Mutability:
If changes are not controlled, the characters in the destination array may be changed, which may affect the original string.
What Is the String Constant Pool?
The String constant pool, sometimes known as the String intern pool, is a specific memory location where the JVM saves String instances.
Conclusion:
Finally, when you need to efficiently extract characters from the string and perform directly with them in a character array, using String.getChars() can be an excellent tool. In comparison to the creation of intermediate String objects, this can help manage memory use and execution time. Nevertheless, caution should be exercised with this method to ensure that index values are not exceeded and take account of any possible mutability considerations when changing characters in the destination array.