java.util.StringTokenizer

By / 27 May 2025 / 2 minutes of reading

StringTokenizer is a legacy class in the java.util package that allows you to break a string into tokens (words or parts) based on specified delimiters (e.g., comma, space, colon). It is often used for parsing text input.

Although newer classes like String.split() or Scanner are recommended for modern development, StringTokenizer is still useful for simple string parsing.

Commonly Used Constructors and Methods

Simple Program

import java.util.StringTokenizer;

public class SimpleTokenizerExample {
    public static void main(String[] args) {
        String input = "Java is fun to learn";
        StringTokenizer tokenizer = new StringTokenizer(input);

        System.out.println("Tokens:");
        while (tokenizer.hasMoreTokens()) {
            System.out.println(tokenizer.nextToken());
        }
    }
}

Output

Tokens:
Java
is
fun
to
learn

Problem Statement:

LotusJavaPrince and Mahesh are building a terminal-based banking application. They need a utility that parses user input commands. For example, "deposit:5000" or "withdraw:2500". The goal is to separate the command and the amount using StringTokenizer and take actions based on the command.

import java.util.StringTokenizer;

class CommandParser {
    public static void parseAndExecute(String commandInput) {
        StringTokenizer tokenizer = new StringTokenizer(commandInput, ":");
        
        if (tokenizer.countTokens() != 2) {
            System.out.println("Invalid command format. Use <command>:<amount>");
            return;
        }

        String command = tokenizer.nextToken().trim().toLowerCase();
        String amountStr = tokenizer.nextToken().trim();

        try {
            double amount = Double.parseDouble(amountStr);

            switch (command) {
                case "deposit":
                    System.out.println("Deposited: $" + amount);
                    break;
                case "withdraw":
                    System.out.println("Withdrew: $" + amount);
                    break;
                default:
                    System.out.println(" Unknown command: " + command);
            }
        } catch (NumberFormatException e) {
            System.out.println("Invalid amount format: " + amountStr);
        }
    }
}

public class CommandProcessor {
    public static void main(String[] args) {
        String[] inputs = {
            "deposit:5000",
            "withdraw:2000",
            "transfer:1000",
            "withdraw:abc",
            "deposit 3000"
        };

        for (String input : inputs) {
            System.out.println("Processing: " + input);
            CommandParser.parseAndExecute(input);
            System.out.println("-------------------------");
        }
    }
}

Output

Processing: deposit:5000
Deposited: $5000.0
-------------------------
Processing: withdraw:2000
Withdrew: $2000.0
-------------------------
Processing: transfer:1000
Unknown command: transfer
-------------------------
Processing: withdraw:abc
Invalid amount format: abc
-------------------------
Processing: deposit 3000
Invalid command format. Use <command>:<amount>
-------------------------
Code language: HTML, XML (xml)

StringTokenizer is a simple utility for breaking strings into tokens based on delimiters.

  • It is efficient but less flexible than modern classes like String.split() or Scanner.
  • Useful in legacy systems, command parsing, or small utility tools.
  • In modern Java development, consider using String.split() or Pattern.split() for more control and Unicode support.

Related Posts

Scroll to Top