Java String Length: Counting Strings

In Java, the String class is one of the most fundamental and widely used classes. It represents a sequence of characters and provides a rich set of methods for manipulating and working with strings. One of the essential operations when dealing with strings is determining their length, which involves counting the number of characters in the string. This article will explore various ways to find the length of a string in Java, along with examples and best practices.

The length() Method

The most straightforward way to get the length of a string in Java is by using the length() method. This method is a built-in class method and returns an int value representing the number of characters in the string.

Here's an example:

String str = "Hello, World!";
int length = str.length(); System.out.println("Length of the string: " + length); // Output: Length of the string: 13

In the above example, the length() method is called on the str object, which holds the string "Hello, World!". The method returns the value 13, which is the number of characters in the string, including spaces.

It's important to note that the length() method counts each character in the string, including whitespace characters like spaces, tabs, and newlines. If you need to exclude whitespace characters or count specific types of characters, you'll need to use additional string manipulation techniques, which we'll discuss later in this article.

Counting Code Points

In Java, characters are represented using Unicode code points, which can consist of one or more code units (bytes) depending on the character. The length() method returns the number of code units, not the number of code points. For most common characters, one code point is represented by one code unit, but for some complex characters (like emojis or certain Asian scripts), one code point can be represented by two or more code units.

To get the actual number of code points (characters) in a string, you can use the codePointCount() method introduced in Java 5. Here's an example:

String str = "Hello, World!🌎";
int codePointCount = str.codePointCount(0, str.length());
System.out.println("Number of code points: " + codePointCount); // Output: Number of code points: 14

In this example, the codePointCount() method is called with two arguments: the start index (0) and the end index (str.length()). The method returns the number of code points between these two indices, which is 14 in this case (13 characters for "Hello, World!" plus 1 for the emoji).

While the length() method is sufficient for most use cases, the codePointCount() method provides a more accurate count of the characters in a string, especially when dealing with Unicode characters that span multiple code units.

String Length Validation

In many applications, it's common to enforce length constraints on user input or data processing. For example, you might want to ensure that a username or password meets certain length requirements, or that a text field doesn't exceed a specific character limit.

To validate the length of a string, you can use the length() method in combination with conditional statements or exceptions. Here's an example of validating a username length:

String username = "johndoe";
int minLength = 6;
int maxLength = 15;
if (username.length() < minLength) {              System.out.println("Username is too short.");
} else if (username.length() > maxLength) {      System.out.println("Username is too long.");
} else {
     System.out.println("Username is valid.");

In this example, the length of the username string is checked against the minLength and maxLength values. If the length is less than minLength, a "Username is too short" message is printed. If the length is greater than maxLength, a "Username is too long" message is printed. Otherwise, the username is considered valid, and a "Username is valid" message is printed.

You can also use exceptions to handle invalid string lengths. For example, you could define a custom exception class and throw an exception when the string length is invalid:

class InvalidStringLengthException extends Exception{
  public InvalidStringLengthException(String message) {

void validateStringLength(String str, int minLength, int maxLength) throws InvalidStringLengthException {
   if (str.length() < minLength) {
       throw new InvalidStringLengthException("String is too short.");
    }else if (str.length() > maxLength) {            throw new InvalidStringLengthException("String is too long.");
// String length is valid

In this example, the validateStringLength() method takes a string, a minimum length, and a maximum length as arguments. If the string length is invalid, an InvalidStringLengthException is thrown with an appropriate error message. The calling code can then handle the exception as needed.

Additional String Length Operations

While the length() method provides a simple way to get the length of a string, there are additional string operations that involve string lengths or character counting. Here are a few examples:

1. Trimming Strings

The trim() method removes leading and trailing whitespace characters from a string. This method can be useful when you want to get the length of a string without considering the surrounding whitespace. Here's an example:

String str = " Hello, World! ";
int trimmedLength = str.trim().length(); System.out.println("Trimmed length: " + trimmedLength); // Output: Trimmed length: 13

In this example, the trim() method is called on the str object to remove the leading and trailing spaces, and then the length() method is called on the trimmed string to get its length, which is 13.

2. Counting Substrings

You can use the indexOf() and lastIndexOf() methods to find the index of a specific substring within a string. By comparing these indices, you can count the occurrences of the substring within the string. Here's an example:

String str = "Hello, World! Hello, Java!";
String substring = "Hello";
int count = 0;
int index = -1;
while ((index = str.indexOf(substring, index + 1)) != -1) {
System.out.println("Number of occurrences of '" + substring + "': " + count); // Output: Number of occurrences of 'Hello': 2

In this example, a while loop is used to iterate through the str string and find all occurrences of the substring ("Hello"). The indexOf() method is called repeatedly, starting from the next character after the previous match. The count variable keeps track of the number of occurrences found.

3. Character Counting

Sometimes you might need to count specific characters within a string. You can use the charAt() method to access individual characters and then iterate through the string to count the occurrences of a particular character. Here's an example:

String str = "Hello, World!";
char charToCount = 'l';
int count = 0;

for (int i = 0; i < str.length(); i++) {
     if (str.charAt(i) == charToCount) {
System.out.println("Number of occurrences of '" + charToCount + "': " + count); // Output: Number of occurrences of 'l': 3

In this example, the charAt() method is used inside a for loop to iterate through each character of the str string. If the character matches the charToCount ('l'), the count variable is incremented. Finally, the count of occurrences is printed.


In Java, the length() method provides a simple and efficient way to get the length of a string, representing the number of characters (code units) in the string. However, when dealing with complex Unicode characters or specific string manipulation requirements, you might need to use additional methods and techniques, such as codePointCount(), trim(), indexOf(), lastIndexOf(), and character counting loops.

By understanding these various string length operations and their use cases, you can write more robust and efficient code for handling strings in Java. Whether you're validating user input, processing text data, or implementing string manipulation algorithms, proper string length handling is crucial for ensuring the correctness and reliability of your

Share On