Java String getChars() method
Syntax and Examples

The getChars() method in Java allows you to copy a specific portion of a string into a character array. Think of it as cutting out a piece of your string and pasting it somewhere else.

Syntax

public void getChars(int srcBegin,
          int srcEnd,
          char[] dst,
          int dstBegin)

Parameters

Let's break down what each parameter does:

• srcBegin: The index in the original string where you want to start copying characters.
• srcEnd: The index after the last character you want to copy from the original string. This means the copied sequence will go up to, but not include, this index.
• dst: The character array where you want to paste the copied characters.
• dstBegin: The index in dst where you want to start placing the copied characters.

Parameter	Description
srcBegin	Starting index of the substring to be copied.
srcEnd	Ending index (exclusive) of the substring to be copied.
dst	Destination character array.
dstBegin	Starting index in the destination array.

Return Value

The getChars() method is a void method, meaning it doesn't return any value. Its purpose is to modify the character array you provide.

Examples

Example 1: Basic Copy

This example copies the characters from index 0 up to (but not including) index 5 of a string into a char array, starting at index 0 of the array.

public class GetCharsExample1 {
  public static void main(String[] args) {
    String str = "Hello World";
    char[] charArray = new char[5];
    str.getChars(0, 5, charArray, 0);

    System.out.print("Copied characters: ");
    for (int i = 0; i < charArray.length; i++) {
      System.out.print(charArray[i]);
    }
    System.out.println();
  }
}

Copied characters: Hello

Explanation: We're taking the substring from index 0 (inclusive) to 5 (exclusive), which is "Hello". This substring is then copied into charArray starting at index 0. The loop prints the contents of `charArray`.

Example 2: Copying with Offset

This example copies a portion of a string, but starts pasting it into the destination array at an offset.

public class GetCharsExample2 {
  public static void main(String[] args) {
    String str = "Java is fun";
    char[] charArray = new char[10];
    str.getChars(5, 9, charArray, 2);

    System.out.print("Copied characters: ");
    for (int i = 0; i < charArray.length; i++) {
      System.out.print(charArray[i]);
    }
    System.out.println();
  }
}

Copied characters:  isfu

Explanation: We're copying the substring from index 5 (inclusive) to 9 (exclusive) of "Java is fun", which is "is f". This gets pasted into charArray, starting at index 2. Notice how `charArray` has a length of 10 to accommodate this offset. The first two elements are skipped.

Example 3: Copying with Different Lengths

This example demonstrates copying when the substring's length is smaller than the destination array’s available space from its start index.

public class GetCharsExample3 {
  public static void main(String[] args) {
    String str = "Short";
    char[] charArray = new char[15];
    str.getChars(0, 2, charArray, 5);

    System.out.print("Copied characters: ");
    for (int i = 0; i < charArray.length; i++) {
      System.out.print(charArray[i]);
    }
    System.out.println();
  }
}

Copied characters:     Sh

Explanation: We're copying "Sh" from index 0 to 2 of the string 'Short', and placing it into charArray at index 5. The remaining elements in charArray (before index 5) will retain their existing values or default initialization if they haven’t been assigned, as seen in the output.

Example 4: Handling Out-of-Bounds

This example demonstrates what happens when the `srcEnd` is beyond the string's length. It doesn't throw an exception but copies up to the end of the string.

public class GetCharsExample4 {
  public static void main(String[] args) {
    String str = "Hello";
    char[] charArray = new char[5];
    str.getChars(1, 10, charArray, 0);

    System.out.print("Copied characters: ");
    for (int i = 0; i < charArray.length; i++) {
      System.out.print(charArray[i]);
    }
    System.out.println();
  }
}

Copied characters: ello

Explanation: We attempt to copy from index 1 up to (but not including) index 10. Since the string's length is only 5, the copying stops at the end of the string, effectively copying "ello". It is important to handle potential out-of-bounds situations in your code.