Java 8 – Check if the String Contains Only Digits

Introduction

Validating whether a string contains only digits is a common requirement in many applications, particularly when dealing with user input, form validation, or data processing. While Java 8 provides a more functional approach to this task, it’s also helpful to understand the traditional methods used before Java 8. In this guide, we will explore how to check if a string contains only digits using both the traditional approach and Java 8 Streams.

Problem Statement

The task is to create a Java program that:

• Accepts a string as input.
• Checks if the string contains only digits.
• Outputs whether the string is numeric or not.

Example 1:

• Input: "123456"
• Output: "The string contains only digits."

Example 2:

• Input: "123a56"
• Output: "The string does not contain only digits."

Solution Steps

1. Input String: Start with a string that can either be hardcoded or provided by the user.
2. Check for Digits (Traditional Approach): Use the charAt() method and Character.isDigit() to validate each character.
3. Check for Digits (Java 8 Streams): Use the Stream API to check if all characters in the string are digits.
4. Display the Result: Print whether the string contains only digits or not.

Java Program

Traditional Approach: Check if the String Contains Only Digits

/**
 * Traditional Approach: Check if the String Contains Only Digits
 * Author: https://www.rameshfadatare.com/
 */
public class CheckDigitsTraditional {

    public static void main(String[] args) {
        // Step 1: Take input string
        String input = "123456";

        // Step 2: Check if the string contains only digits using traditional approach
        boolean isNumeric = isNumericTraditional(input);

        // Step 3: Display the result
        if (isNumeric) {
            System.out.println("The string contains only digits.");
        } else {
            System.out.println("The string does not contain only digits.");
        }
    }

    // Method to check if a string contains only digits (traditional approach)
    public static boolean isNumericTraditional(String str) {
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }
}

Java 8 Approach: Check if the String Contains Only Digits

import java.util.stream.IntStream;

/**
 * Java 8: Check if the String Contains Only Digits
 * Author: https://www.rameshfadatare.com/
 */
public class CheckDigitsJava8 {

    public static void main(String[] args) {
        // Step 1: Take input string
        String input = "123456";

        // Step 2: Check if the string contains only digits using Java 8 Streams
        boolean isNumeric = isNumericJava8(input);

        // Step 3: Display the result
        if (isNumeric) {
            System.out.println("The string contains only digits.");
        } else {
            System.out.println("The string does not contain only digits.");
        }
    }

    // Method to check if a string contains only digits (Java 8 Streams approach)
    public static boolean isNumericJava8(String str) {
        return str.chars().allMatch(Character::isDigit);
    }
}

Explanation of the Programs

• Traditional Approach: The first program uses a for loop combined with Character.isDigit() to check each character in the string. If any character is not a digit, the method returns false; otherwise, it returns true.

• Java 8 Approach: The second program uses the Stream API. The chars() method converts the string into an IntStream, and allMatch(Character::isDigit) checks if all characters in the stream are digits.

Output Example

For both methods, the output will be:

Example 1:

Input: 123456
Output: The string contains only digits.

Example 2:

Input: 123a56
Output: The string does not contain only digits.

Advanced Considerations

1. Performance Considerations: Both methods are efficient for typical string lengths. The traditional method is straightforward and easy to understand, while the Java 8 approach is more concise and leverages modern Java features.

2. Handling Edge Cases: Both methods correctly handle empty strings by returning true since there are no non-digit characters. You might want to modify this behavior based on your specific requirements.

3. Use in Larger Applications: Checking if a string contains only digits is often a small part of larger applications, such as validating user input in forms, processing numerical data, or parsing text files. The choice between the traditional and Java 8 approach may depend on the context and the overall coding style of your application.

Conclusion

This guide provides two methods for checking if a string contains only digits: the traditional approach using a for loop and Character.isDigit(), and a more modern approach using Java 8 Streams. Both methods are effective, but the Java 8 approach offers a more functional and concise solution. Depending on your needs and the style of your codebase, either method can be used to achieve the desired result.