Scanner + Regex Based Input Processing

Java provides the Scanner class for taking user input and Regular Expressions (Regex) for validating and processing that input. Combining both helps create secure, reliable, and user-friendly applications.

This approach is widely used in:

Registration and login forms
Console-based Java applications
Input validation systems
Banking and payment applications
Data entry and processing systems

Scanner handles user input, while Regex ensures the entered data follows the required format.

What is Scanner Class?

The Scanner class is used in Java to read input from users or other input sources such as files and streams. It is one of the most commonly used classes for handling user interaction in console-based Java applications.

Using Scanner, a program can easily accept different types of input like:

Text (String)
Numbers (int, double)
Single words
Full lines of text

It belongs to:

java.util.Scanner

In simple words: Scanner helps Java programs take input from users through the keyboard or other sources.

Basic Scanner Example

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.print("Enter your name: ");

        String name = sc.nextLine();

        System.out.println("Hello " + name);

        sc.close();
    }
}

Output

Enter your name: Rahul
Hello Rahul

Why Combine Scanner with Regex in Java?

The Scanner class is useful for taking user input, but by default it accepts almost any value entered by the user. In real-world applications, accepting unchecked input can lead to invalid data, security issues, and application errors.

Problem with Normal Input

Users may enter:

Invalid email addresses
Weak passwords
Incorrect phone numbers
Unexpected or harmful input data

Without validation, such input can create problems in databases, forms, and business logic.

Solution: Regex Validation

Regex validation checks whether the entered input follows the required format before processing it.

Benefits of combining Scanner with Regex:

Improves application security
Prevents invalid or incorrect data
Reduces runtime and validation errors
Ensures proper input formatting
Makes applications more reliable and user-friendly

👉 This combination is commonly used in login systems, registration forms, banking applications, and console-based Java projects.

How Scanner + Regex Works

When a user enters data, the Scanner class reads the input and Regex checks whether the input follows the required format. If the validation is successful, the application processes the data; otherwise, it can reject the input or ask the user to enter valid data again.

Flow

User Input → Scanner → Regex Validation → Process Data

Example 1: Email Validation

This example takes an email address from the user using Scanner and validates it using a Regex pattern. If the entered email follows the correct format, the program prints "Valid Email"; otherwise, it prints "Invalid Email".

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.print("Enter Email: ");

        String email = sc.nextLine();

        String regex =
                "^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$";

        if (email.matches(regex)) {
            System.out.println("Valid Email");
        } else {
            System.out.println("Invalid Email");
        }

        sc.close();
    }
}

Example 2: Phone Number Validation

This example takes a phone number from the user using Scanner and validates whether it contains exactly 10 digits using Regex. If the number follows the correct format, the program prints "Valid Number"; otherwise, it prints "Invalid Number".

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.print("Enter Phone Number: ");

        String phone = sc.nextLine();

        if (phone.matches("^[0-9]{10}$")) {
            System.out.println("Valid Number");
        } else {
            System.out.println("Invalid Number");
        }

        sc.close();
    }
}

Example 3: Password Validation

This example takes a password from the user and validates it using Regex based on security rules. The password must contain at least one uppercase letter, one lowercase letter, one digit, and a minimum length of 8 characters.

Rules

Minimum 8 characters
At least one uppercase letter
At least one lowercase letter
At least one digit

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.print("Enter Password: ");

        String password = sc.nextLine();

        String regex =
                "^(?=.*[A-Z])(?=.*[a-z])(?=.*\\\\d).{8,}$";

        if (password.matches(regex)) {
            System.out.println("Strong Password");
        } else {
            System.out.println("Weak Password");
        }

        sc.close();
    }
}

Using Pattern and Matcher with Scanner

This example uses Scanner to take input from the user and then uses Pattern and Matcher classes to search for numbers inside the entered text.

The program:

Reads user input
Compiles a regex pattern
Finds matching values in the text
Prints all matched results

import java.util.Scanner;
import java.util.regex.*;

public class Test {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.print("Enter text: ");

        String input = sc.nextLine();

        Pattern pattern = Pattern.compile("\\\\d+");

        Matcher matcher = pattern.matcher(input);

        while (matcher.find()) {
            System.out.println("Found: " + matcher.group());
        }

        sc.close();
    }
}

Output

Enter text: Java 21 version
Found: 21

Scanner Class with Regex Delimiters

The Scanner class can use Regular Expressions (Regex) as delimiters to split input into smaller parts called tokens.

By default, Scanner separates input using whitespace, but with useDelimiter() we can define custom separators such as commas, colons, hyphens, pipes, or even complex regex patterns.

This feature is extremely useful when working with structured or formatted data.

Common use cases include:

Parsing CSV files
Reading formatted records
Processing log files
Splitting API or text data
Handling custom input formats

Example: Using useDelimiter()

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {

        String data = "Java,Python,C++";

        Scanner sc = new Scanner(data);

        // Using comma as delimiter
        sc.useDelimiter(",");

        while (sc.hasNext()) {
            System.out.println(sc.next());
        }

        sc.close();
    }
}

Output

Java
Python
C++

Structured Input Parsing

Structured input parsing means reading and processing data that follows a predefined or fixed format.

Using Scanner with Regex delimiters makes it easier to separate and extract individual values from structured input data efficiently.

This approach is commonly used in:

Student management systems
Employee record systems
Banking applications
Report and data processing systems
CSV and formatted file parsing

Example: Parsing Student Data

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {

        String input = "101-Rahul-85";

        Scanner sc = new Scanner(input);

        // Using hyphen as delimiter
        sc.useDelimiter("-");

        int id = sc.nextInt();
        String name = sc.next();
        int marks = sc.nextInt();

        System.out.println("ID: " + id);
        System.out.println("Name: " + name);
        System.out.println("Marks: " + marks);

        sc.close();
    }
}

Output

ID: 101
Name: Rahul
Marks: 85

CSV-Style Input Handling

CSV (Comma-Separated Values) is a popular format used to store and exchange tabular data in many real-world applications.

Many systems use CSV files for:

Data import and export
Report generation
Database backups
Spreadsheet processing
Student and employee records

Using Scanner with delimiters makes CSV parsing simple, fast, and efficient in Java.

Example: CSV Data Processing

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {

        String csv = "Amit,25,Delhi";

        Scanner sc = new Scanner(csv);

        // Comma delimiter
        sc.useDelimiter(",");

        while (sc.hasNext()) {
            System.out.println(sc.next());
        }

        sc.close();
    }
}

Output

Amit
25
Delhi

Key Benefits of Delimiter-Based Parsing

Delimiter-based parsing provides a simple and efficient way to process structured input data in Java applications.

Key benefits include:

Makes structured and formatted data easier to process
Simplifies CSV and record-based data handling
Reduces the need for manual string splitting logic
Improves code readability and maintainability
Helps process large amounts of formatted data efficiently
Widely useful in real-world data processing applications

Real-World Use Cases

Scanner and Regex together are widely used in Java applications for taking and validating user input efficiently.

Common real-world use cases include:

Login and authentication systems
Registration and signup forms
Banking and financial applications
Input validation systems
Command-line and console tools
Student and employee management systems
Online examination and data entry systems

Advantages

Using Scanner with Regex provides a simple and efficient way to handle and validate user input in Java applications.

Key advantages include:

Easy and interactive user input handling
Strong validation support using regex patterns
Reduces invalid or incorrect data entry
Improves application security and reliability
Simplifies input processing logic

This combination helps build secure, accurate, and user-friendly Java applications.

Limitations

Although Scanner and Regex are very useful, they also have some limitations in real-world applications.

Some common limitations include:

Complex regex patterns can become difficult to read and maintain
Scanner may be slower when handling very large input data
Poorly designed validation rules may still allow invalid data
Debugging complex regex expressions can be challenging

Proper regex design and validation logic are important for building efficient and reliable applications.

Conclusion

Using Scanner with Regex is a powerful and practical approach for processing and validating user input in Java applications.

Scanner handles user input collection
Regex validates the input format
Together they improve security, accuracy, and data quality
Helps prevent invalid or incorrectly formatted input

👉 This combination is essential for building secure, reliable, and real-world Java applications