Java Programming | Character Conversion | Lowercase

Introduction

In Java programming, the toLowerCase(char ch) method is used to convert the given character argument to lowercase. This method is part of the Character class in Java and uses case mapping information provided by the Unicode Data file. This functionality is particularly useful when processing text that requires case normalization.

In this lab, you will learn how to use the toLowerCase(char ch) method in Java programs. You will create a simple application that converts characters to lowercase and enhance it with user input and error handling capabilities.

Create Your First Character Conversion Program

In this step, you will create a Java program that demonstrates how to convert a character to lowercase using the toLowerCase(char ch) method from Java's Character class.

Understanding Character Case Conversion

In Java, characters are represented by the primitive data type char. The Character class provides various methods to manipulate and work with characters, including the ability to convert between uppercase and lowercase.

The toLowerCase(char ch) method takes a character as input and:

Returns the lowercase version of the character if it was uppercase
Returns the same character if it was already lowercase or is not a letter

Creating the Java File

First, let's create a new Java file in the project directory:

Open the WebIDE editor window
Navigate to the File menu and click "New File"
Name the file CharacterToLowerCase.java and save it in the /home/labex/project directory

Alternatively, you can use the terminal to create the file:

cd ~/project
touch CharacterToLowerCase.java

Writing Your First Program

Now, let's write the code in the CharacterToLowerCase.java file:

Open the file in the WebIDE editor
Copy and paste the following code into the file:

public class CharacterToLowerCase {
    public static void main(String[] args) {
        // Create character variables with different cases
        char upperCaseChar = 'A';
        char lowerCaseChar = 'b';
        char nonLetterChar = '5';

        // Convert each character to lowercase
        char result1 = Character.toLowerCase(upperCaseChar);
        char result2 = Character.toLowerCase(lowerCaseChar);
        char result3 = Character.toLowerCase(nonLetterChar);

        // Print the original and lowercase characters
        System.out.println("Original uppercase character: " + upperCaseChar);
        System.out.println("After toLowerCase(): " + result1);
        System.out.println();

        System.out.println("Original lowercase character: " + lowerCaseChar);
        System.out.println("After toLowerCase(): " + result2);
        System.out.println();

        System.out.println("Original non-letter character: " + nonLetterChar);
        System.out.println("After toLowerCase(): " + result3);
    }
}

This program demonstrates the toLowerCase(char ch) method with three different types of characters:

An uppercase letter ('A')
A lowercase letter ('b')
A non-letter character ('5')

Compiling and Running the Program

Now, let's compile and run the Java program:

Open the terminal in the WebIDE
Navigate to the project directory if you're not already there:
```
cd ~/project
```
Compile the Java file:
```
javac CharacterToLowerCase.java
```
Run the compiled program:
```
java CharacterToLowerCase
```

You should see the following output:

Original uppercase character: A
After toLowerCase(): a

Original lowercase character: b
After toLowerCase(): b

Original non-letter character: 5
After toLowerCase(): 5

As you can see, the uppercase 'A' was converted to lowercase 'a', while the already lowercase 'b' and the non-letter character '5' remained unchanged.

Enhancing the Program with User Input

In this step, you will enhance your program to accept user input. Instead of using predefined characters, the program will prompt the user to enter a character and then convert it to lowercase.

Understanding the Scanner Class

To accept user input in Java, we will use the Scanner class from the java.util package. The Scanner class provides methods to read different types of input data (like integers, doubles, strings, etc.) from various sources, including the standard input (keyboard).

Here's how we'll use the Scanner class:

Import the class with import java.util.Scanner;
Create a Scanner object with Scanner scanner = new Scanner(System.in);
Use methods like next(), nextInt(), etc. to read input

Modifying the Program

Let's modify our program to accept user input:

Open the CharacterToLowerCase.java file in the WebIDE editor
Replace the existing code with the following:

import java.util.Scanner;

public class CharacterToLowerCase {
    public static void main(String[] args) {
        // Create a Scanner object to read user input
        Scanner scanner = new Scanner(System.in);

        // Prompt the user to enter a character
        System.out.print("Enter a character: ");

        // Read the first character of the input
        String input = scanner.next();
        char userChar = input.charAt(0);

        // Convert the character to lowercase
        char lowerCaseChar = Character.toLowerCase(userChar);

        // Print the original and lowercase characters
        System.out.println("Original character: " + userChar);
        System.out.println("Lowercase character: " + lowerCaseChar);

        // Close the scanner
        scanner.close();
    }
}

The key changes in this code are:

We import the Scanner class
We create a Scanner object to read input from the console
We prompt the user to enter a character
We read the input as a string and then extract the first character
We convert the character to lowercase and display both the original and lowercase characters
We close the scanner to release resources

Compiling and Running the Modified Program

Let's compile and run the modified program:

Open the terminal in the WebIDE
Navigate to the project directory if you're not already there:
```
cd ~/project
```
Compile the Java file:
```
javac CharacterToLowerCase.java
```
Run the compiled program:
```
java CharacterToLowerCase
```
When prompted, enter a character (for example, 'Z') and press Enter.

You should see output similar to this (assuming you entered 'Z'):

Enter a character: Z
Original character: Z
Lowercase character: z

Try entering different characters to see how the program behaves with lowercase letters, uppercase letters, and non-letter characters.

Handling Errors and Invalid Input

In the previous step, our program worked well when the user entered a valid character. However, if the user entered an empty string or if there was any other issue with reading the input, the program might crash with an exception. In this step, we will enhance our program to handle potential errors and invalid inputs.

Understanding Exception Handling in Java

Exception handling in Java is done using try-catch blocks:

The code that might throw an exception is placed in the try block
The code to handle the exception is placed in the catch block
You can catch specific exceptions by specifying the exception type

Modifying the Program to Handle Errors

Let's modify our program to handle potential errors:

Open the CharacterToLowerCase.java file in the WebIDE editor
Replace the existing code with the following:

import java.util.Scanner;

public class CharacterToLowerCase {
    public static void main(String[] args) {
        // Create a Scanner object to read user input
        Scanner scanner = new Scanner(System.in);

        // Continue until valid input is received
        boolean validInput = false;

        while (!validInput) {
            try {
                // Prompt the user to enter a character
                System.out.print("Enter a character: ");

                // Read the first character of the input
                String input = scanner.next();
                if (input.isEmpty()) {
                    System.out.println("Error: Empty input. Please enter a character.");
                    continue;
                }

                char userChar = input.charAt(0);

                // Convert the character to lowercase
                char lowerCaseChar = Character.toLowerCase(userChar);

                // Print the original and lowercase characters
                System.out.println("Original character: " + userChar);
                System.out.println("Lowercase character: " + lowerCaseChar);

                // If a character is already lowercase or is not a letter, explain the result
                if (userChar == lowerCaseChar) {
                    if (Character.isLetter(userChar)) {
                        System.out.println("Note: The character was already lowercase.");
                    } else {
                        System.out.println("Note: The character is not a letter, so it remains unchanged.");
                    }
                }

                validInput = true;  // Exit the loop

            } catch (Exception e) {
                // Handle any exceptions that might occur
                System.out.println("Error: Invalid input. Please try again.");
                scanner.nextLine();  // Clear the input buffer
            }
        }

        // Close the scanner
        scanner.close();
    }
}

The key changes in this code are:

We added a loop to continue prompting for input until valid input is received
We added a try-catch block to handle potential exceptions
We check if the input is empty
We added additional information about why certain characters remain unchanged
We clear the input buffer in case of invalid input

Compiling and Running the Final Program

Let's compile and run the enhanced program:

Open the terminal in the WebIDE
Navigate to the project directory if you're not already there:
```
cd ~/project
```
Compile the Java file:
```
javac CharacterToLowerCase.java
```
Run the compiled program:
```
java CharacterToLowerCase
```

Let's test different scenarios:

Enter an uppercase letter (e.g., 'A'):

Enter a character: A
Original character: A
Lowercase character: a

Enter a lowercase letter (e.g., 'a'):

Enter a character: a
Original character: a
Lowercase character: a
Note: The character was already lowercase.

Enter a non-letter character (e.g., '5'):

Enter a character: 5
Original character: 5
Lowercase character: 5
Note: The character is not a letter, so it remains unchanged.

Try pressing Enter without typing a character, or enter an invalid input:

Enter a character:
Error: Invalid input. Please try again.
Enter a character:

The program now handles various input scenarios gracefully, providing helpful feedback to the user.

Summary

In this lab, you have learned how to use the toLowerCase(char ch) method in Java to convert characters to lowercase. Here's a recap of what you accomplished:

You created a basic Java program that demonstrates character case conversion using the toLowerCase(char ch) method.
You enhanced the program to accept user input using the Scanner class, allowing users to enter their own characters for conversion.
You improved the program's robustness by adding error handling with try-catch blocks to gracefully handle invalid inputs.
You added informative messages to explain why certain characters remain unchanged when passed to the toLowerCase(char ch) method.

These skills are fundamental in Java programming and can be applied to many real-world scenarios, such as:

Text processing and normalization
Form validation
Search functionality (case-insensitive search)
Data cleaning and preparation

As you continue your Java learning journey, remember that the Character class provides many other useful methods for working with characters, such as isLetter(), isDigit(), isUpperCase(), isLowerCase(), and more.

Convert Character to Lowercase in Java