Java String copyValueOf() Method

What You’ll Learn

The copyValueOf() method is a static factory on the String class. It builds a new String by copying characters from a char[] array—either the whole array or a slice defined by offset and count.

Definition and Usage

In Java, String.copyValueOf(char[] data) and String.copyValueOf(char[] data, int offset, int count) create a brand-new String whose characters are copied from the given array. The original array can be changed later without affecting the String, because strings are immutable.

This method is handy when you read characters into a buffer—from a file, network stream, or parser—and need a String representation of all or part of that buffer.

📝 Syntax

The copyValueOf() method has two static overloads in the String class:

public static String copyValueOf(char[] data)
public static String copyValueOf(char[] data, int offset, int count)

Parameters

• data — the source character array. Must not be null.
• offset — (two-arg form) index in data where copying starts. Must be ≥ 0.
• count — (two-arg form) number of characters to copy. Must be ≥ 0 and offset + count must not exceed data.length.

Return Value

Returns a new String containing the copied characters.

Exceptions

• NullPointerException if data is null.
• IndexOutOfBoundsException if offset or count are negative, or if offset + count > data.length.

Examples Gallery

These programs run in Java 8+. They show copying an entire array, extracting a substring range, handling an empty array, comparing with the constructor, and invalid bounds.

public class CopyValueOfExample {
    public static void main(String[] args) {
        char[] charArray = {'H', 'e', 'l', 'l', 'o'};

        String result = String.copyValueOf(charArray);

        System.out.println(result);
    }
}

Hello

public class PartialCopyDemo {
    public static void main(String[] args) {
        char[] charArray = {'H', 'e', 'l', 'l', 'o'};

        String slice = String.copyValueOf(charArray, 1, 3);

        System.out.println(slice);
    }
}

ell

public class EmptyArrayCopy {
    public static void main(String[] args) {
        char[] empty = new char[0];

        String text = String.copyValueOf(empty);

        System.out.println("Length: " + text.length());
        System.out.println("Is empty? " + text.isEmpty());
    }
}

Length: 0
Is empty? true

public class CopyVsConstructor {
    public static void main(String[] args) {
        char[] data = {'J', 'a', 'v', 'a'};

        String viaCopy        = String.copyValueOf(data);
        String viaConstructor = new String(data);

        System.out.println("copyValueOf:  " + viaCopy);
        System.out.println("constructor:  " + viaConstructor);
        System.out.println("Equal text?   " + viaCopy.equals(viaConstructor));
    }
}

copyValueOf:  Java
constructor:  Java
Equal text?   true

public class BoundsDemo {
    public static void main(String[] args) {
        char[] data = {'A', 'B', 'C'};

        try {
            // offset 1 + count 3 exceeds length 3
            String bad = String.copyValueOf(data, 1, 3);
            System.out.println(bad);
        } catch (IndexOutOfBoundsException ex) {
            System.out.println("Caught: " + ex.getClass().getSimpleName());
        }
    }
}

Caught: IndexOutOfBoundsException

🚀 Common Use Cases

• File or stream buffers — turn a filled char[] read from input into a String.
• Partial token extraction — copy only the meaningful slice after parsing fixed-width fields.
• Legacy APIs — integrate with libraries that still expose char[] instead of String.
• Test data setup — build strings from character arrays in unit tests without string concatenation.
• Custom parsers — convert a working buffer segment into text once parsing completes.

📝 Notes

• copyValueOf() is static—invoke it as String.copyValueOf(...).
• The returned String is independent of the source array; mutating the array afterward does not change the string.
• For a full array, new String(char[]) is an alternative with the same practical result in modern Java.
• The two-argument form is the clearest way to build a string from part of a buffer without manual copying.
• An empty array produces "", not null.

⚡ Optimization

copyValueOf() is implemented efficiently inside the JDK and is the right choice for array-to-string conversion. Avoid building strings character by character in a loop when you already hold the data in a char[]. If you repeatedly convert the same unchanged array, store the resulting String in a variable instead of calling copyValueOf() on every iteration.

💡 Best Practices