Write A Program To Check Whether A Character Is A Vowel Or Consonant In Java

In this article, you will learn how to write a Java program to determine whether a given character is a vowel or a consonant. We will explore several common approaches, from simple conditional statements to more advanced collection-based methods, ensuring you understand the logic behind each.

Problem Statement

The task is to classify an alphabetical character as either a vowel or a consonant. Vowels are typically 'a', 'e', 'i', 'o', 'u' (and their uppercase counterparts), while all other English alphabet letters are consonants. This distinction is fundamental in text processing, linguistic analysis, and various programming challenges.

Example

Consider the character 'A'. Input: 'A' Output: A is a Vowel.

Consider the character 'b'. Input: 'b' Output: b is a Consonant.

Background & Knowledge Prerequisites

To effectively follow this article, a basic understanding of Java programming concepts is beneficial, including:

• Variables and Data Types: Especially the char data type.
• Conditional Statements: if-else if-else and switch statements.
• String Manipulation: Basic understanding of strings and methods like indexOf().
• Boolean Logic: && (AND), || (OR) operators.
• Object-Oriented Programming (OOP) Basics: Understanding classes and methods.

No special imports or complex setups are required beyond the standard Java Development Kit (JDK).

Use Cases or Case Studies

Identifying vowels and consonants has various practical applications:

• Text Analysis: Counting vowels or consonants in a document for readability scores, language models, or basic sentiment analysis.
• Simple Games: Creating word puzzles like Hangman, where players guess letters, and the program needs to differentiate between types of letters.
• Data Validation: Ensuring user input adheres to certain patterns, e.g., requiring a password to contain at least one vowel.
• Linguistic Research: Automating tasks for phonetics, phonology, or morphology studies where character types are crucial.
• Educational Tools: Building interactive applications to teach children about letters and sounds.

Solution Approaches

We will explore four distinct approaches to solve this problem, each with its own advantages.

Approach 1: Using if-else if-else Statements

This approach uses a series of if-else if-else conditions to check if the character matches any of the predefined vowels (both lowercase and uppercase).

• Summary: Directly compares the input character with each vowel using || (OR) operators.

// CheckVowelConsonantIfElse
import java.util.Scanner;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Create a Scanner object to read input from the console
        Scanner scanner = new Scanner(System.in);

        // Step 2: Prompt the user to enter a character
        System.out.print("Enter a character: ");
        char ch = scanner.next().charAt(0); // Read the first character of the input

        // Step 3: Check if the character is an alphabet
        if (!Character.isLetter(ch)) {
            System.out.println(ch + " is not an alphabet.");
        } else {
            // Step 4: Check if the character is a vowel (case-insensitive)
            if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u' ||
                ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U') {
                System.out.println(ch + " is a Vowel.");
            } else {
                // Step 5: If it's an alphabet but not a vowel, it's a consonant
                System.out.println(ch + " is a Consonant.");
            }
        }

        // Step 6: Close the scanner
        scanner.close();
    }
}

Run

• Sample Output:

  Enter a character: p
  p is a Consonant.

Enter a character: E
    E is a Vowel.

Enter a character: 7
    7 is not an alphabet.

• Stepwise Explanation:

1. A Scanner is initialized to get user input.
2. The program prompts the user to enter a character and reads the first character entered.
3. Character.isLetter(ch) is used first to ensure the input is indeed an alphabet. If not, an appropriate message is printed.
4. If it's an alphabet, a long if condition checks if ch is equal to any of the lowercase or uppercase vowels using the logical OR (||) operator.
5. If the condition is true, it's a vowel; otherwise, it's a consonant.

Approach 2: Using a switch Statement

The switch statement provides a cleaner alternative to multiple if-else if conditions, especially when checking a character against a fixed set of values.

• Summary: Utilizes a switch statement with multiple case labels for vowels to determine the character type.

// CheckVowelConsonantSwitch
import java.util.Scanner;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Create a Scanner object to read input
        Scanner scanner = new Scanner(System.in);

        // Step 2: Prompt for character input
        System.out.print("Enter a character: ");
        char ch = scanner.next().charAt(0);

        // Step 3: Check if it's an alphabet
        if (!Character.isLetter(ch)) {
            System.out.println(ch + " is not an alphabet.");
            scanner.close();
            return; // Exit if not an alphabet
        }

        String result = "";
        // Step 4: Use a switch statement to check for vowels
        switch (Character.toLowerCase(ch)) { // Convert to lowercase for simpler cases
            case 'a':
            case 'e':
            case 'i':
            case 'o':
            case 'u':
                result = "Vowel";
                break;
            default:
                result = "Consonant";
        }

        // Step 5: Print the result
        System.out.println(ch + " is a " + result + ".");

        // Step 6: Close the scanner
        scanner.close();
    }
}

Run

• Sample Output:

  Enter a character: O
  O is a Vowel.

Enter a character: x
    x is a Consonant.

• Stepwise Explanation:

1. Input is read similar to Approach 1, and it's first checked if it's an alphabet.
2. Character.toLowerCase(ch) converts the input character to its lowercase equivalent. This simplifies the switch statement by only needing to check lowercase vowel cases.
3. The switch statement then checks ch against case 'a', case 'e', etc.
4. If a match is found, result is set to "Vowel". Due to "fall-through" behavior, if ch is 'a', it falls through to 'e', 'i', 'o', 'u' until a break is encountered.
5. If no case matches, the default block is executed, setting result to "Consonant".
6. The final result is printed.

Approach 3: Using String.indexOf() Method

This method leverages the indexOf() method of the String class to check if a character exists within a predefined string of vowels.

• Summary: Creates a string containing all vowels and uses indexOf() to check for the character's presence.

// CheckVowelConsonantStringIndexOf
import java.util.Scanner;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Create a Scanner object
        Scanner scanner = new Scanner(System.in);

        // Step 2: Prompt for character input
        System.out.print("Enter a character: ");
        char ch = scanner.next().charAt(0);

        // Step 3: Check if it's an alphabet
        if (!Character.isLetter(ch)) {
            System.out.println(ch + " is not an alphabet.");
            scanner.close();
            return;
        }

        // Step 4: Define a string containing all vowels (both cases)
        String vowels = "aeiouAEIOU";

        // Step 5: Check if the character exists in the vowels string
        // indexOf() returns the index of the character if found, -1 otherwise.
        if (vowels.indexOf(ch) != -1) {
            System.out.println(ch + " is a Vowel.");
        } else {
            System.out.println(ch + " is a Consonant.");
        }

        // Step 6: Close the scanner
        scanner.close();
    }
}

Run

• Sample Output:

  Enter a character: I
  I is a Vowel.

Enter a character: t
    t is a Consonant.

• Stepwise Explanation:

1. Input is read and validated as an alphabet.
2. A String variable vowels is declared and initialized with all lowercase and uppercase vowels.
3. vowels.indexOf(ch) attempts to find the input character ch within the vowels string.
4. If ch is found, indexOf() returns its position (0 or greater). If not found, it returns -1.
5. An if condition checks if the returned value is not equal to -1. If true, it's a vowel; otherwise, it's a consonant.

Approach 4: Using Set for Vowel Storage (More Robust/Scalable)

For a larger set of characters or improved performance in repeated checks, storing vowels in a Set (like HashSet) is an efficient approach.

• Summary: Stores vowels in a HashSet and uses its contains() method for efficient lookup.

// CheckVowelConsonantSet
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Create a Scanner object
        Scanner scanner = new Scanner(System.in);

        // Step 2: Prompt for character input
        System.out.print("Enter a character: ");
        char ch = scanner.next().charAt(0);

        // Step 3: Check if it's an alphabet
        if (!Character.isLetter(ch)) {
            System.out.println(ch + " is not an alphabet.");
            scanner.close();
            return;
        }

        // Step 4: Create a Set of vowels (case-insensitive for comparison)
        Set<Character> vowels = new HashSet<>();
        vowels.add('a');
        vowels.add('e');
        vowels.add('i');
        vowels.add('o');
        vowels.add('u');

        // Step 5: Convert the input character to lowercase for consistent checking
        char lowerCaseCh = Character.toLowerCase(ch);

        // Step 6: Check if the lowercase character is present in the set of vowels
        if (vowels.contains(lowerCaseCh)) {
            System.out.println(ch + " is a Vowel.");
        } else {
            System.out.println(ch + " is a Consonant.");
        }

        // Step 7: Close the scanner
        scanner.close();
    }
}

Run

• Sample Output:

  Enter a character: U
  U is a Vowel.

Enter a character: k
    k is a Consonant.

• Stepwise Explanation:

1. Input is read and validated as an alphabet.
2. A HashSet named vowels is created. This set will store all lowercase vowel characters.
3. Each lowercase vowel ('a', 'e', 'i', 'o', 'u') is added to the vowels set.
4. The input character ch is converted to lowercase using Character.toLowerCase(ch) to perform a case-insensitive check.
5. The vowels.contains(lowerCaseCh) method efficiently checks if the lowercase input character is present in the set. contains() on a HashSet has an average time complexity of O(1), making it very fast.
6. Based on the result of contains(), the character is identified as a vowel or consonant.

Conclusion

Distinguishing between vowels and consonants is a foundational task in character manipulation within programming. We've explored various Java approaches, from straightforward if-else and switch statements to more dynamic methods utilizing String.indexOf() and HashSet. Each method offers a valid solution, with choices often depending on clarity, performance requirements, or personal preference.

Summary

• Problem: Classify an input character as a vowel or consonant.
• Vowels: 'a', 'e', 'i', 'o', 'u' (and their uppercase forms).
• Approach 1 (if-else if-else): Direct comparison using logical OR (||). Good for few conditions, explicit.
• Approach 2 (switch statement): Cleaner for multiple fixed conditions, often combined with Character.toLowerCase().
• Approach 3 (String.indexOf()): Checks if character exists within a predefined string of vowels. Concise for simple lookups.
• Approach 4 (Set.contains()): Uses a HashSet for efficient, constant-time lookups, ideal for scalability or repeated checks.
• Robustness: Always ensure input is an actual letter using Character.isLetter() before classification.
• Case-Insensitivity: Convert input to lowercase (or handle both cases explicitly) for consistent results across all approaches.