Java Program: Lambda expression for checking uppercase, lowercase, or mixedcase strings

Last update on March 11 2025 14:01:58 (UTC/GMT +8 hours)

Check if List of Strings are All Uppercase/Lowercase or Mixed

Write a Java program to implement a lambda expression to check if a list of strings are all uppercase or all lowercase or mixedcase.

Sample Solution:

Java Code:

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.function.Function;

public class Main {
  public static void main(String[] args) {
    List < String > strings = Arrays.asList("Java", "JAVA", "java");
    System.out.println("Array elements: " + strings);
    // Check if the list is all uppercase using lambda expression
    boolean isAllUppercase = checkCase(strings, s -> s.equals(s.toUpperCase()), String::toUpperCase);
    System.out.println("Is all uppercase? " + isAllUppercase);

    // Check if the list is all lowercase using lambda expression
    boolean isAllLowercase = checkCase(strings, s -> s.equals(s.toLowerCase()), String::toLowerCase);
    System.out.println("Is all lowercase? " + isAllLowercase);

    // Check if the list is mixed case
    boolean isMixedCase = !isAllUppercase && !isAllLowercase;
    System.out.println("Is mixed case? " + isMixedCase);

    List < String > strings1 = Arrays.asList("JAVA", "PYTHON", "ABC");
    System.out.println("\nArray elements: " + strings1);
    // Check if the list is all uppercase using lambda expression
    isAllUppercase = checkCase(strings1, s -> s.equals(s.toUpperCase()), String::toUpperCase);
    System.out.println("Is all uppercase? " + isAllUppercase);

    // Check if the list is all lowercase using lambda expression
    isAllLowercase = checkCase(strings1, s -> s.equals(s.toLowerCase()), String::toLowerCase);
    System.out.println("Is all lowercase? " + isAllLowercase);

    // Check if the list is mixed case
    isMixedCase = !isAllUppercase && !isAllLowercase;
    System.out.println("Is mixed case? " + isMixedCase);

    List < String > strings2 = Arrays.asList("java");
    System.out.println("\nArray elements: " + strings2);
    // Check if the list is all uppercase using lambda expression
    isAllUppercase = checkCase(strings2, s -> s.equals(s.toUpperCase()), String::toUpperCase);
    System.out.println("Is all uppercase? " + isAllUppercase);

    // Check if the list is all lowercase using lambda expression
    isAllLowercase = checkCase(strings2, s -> s.equals(s.toLowerCase()), String::toLowerCase);
    System.out.println("Is all lowercase? " + isAllLowercase);

    // Check if the list is mixed case
    isMixedCase = !isAllUppercase && !isAllLowercase;
    System.out.println("Is mixed case? " + isMixedCase);

  }
  public static boolean checkCase(List < String > strings, Predicate < String > checkFunction, Function < String, String > convertFunction) {
    String firstString = strings.get(0);
    String convertedString = convertFunction.apply(firstString);

    return strings.stream()
      .allMatch(s -> checkFunction.test(s));
  }
}

Sample Output:

Array elements: [Java, JAVA, java]
Is all uppercase? false
Is all lowercase? false
Is mixed case? true

Array elements: [JAVA, PYTHON, ABC]
Is all uppercase? true
Is all lowercase? false
Is mixed case? false

Array elements: [java]
Is all uppercase? false
Is all lowercase? true
Is mixed case? false

Explanation:

In the above exercise -

The main() method:

Creates a list of strings named strings.
Calls the checkCase method to perform case checks and prints the results.

The checkCase() method:

Takes three parameters: the list of strings to check, a Predicate<String> to define the case check condition, and a Function<String, String> to convert the first string for comparison.
Retrieves the first string from the list using strings.get(0) and assigns it to firstString.
Apply the conversion function convertFunction to firstString and assign the result to convertedString.
Use the stream() method in the strings list to create a stream of strings.
Apply the allMatch intermediate operation on the stream and provide a lambda expression as the condition to check if all strings satisfy the given predicate checkFunction.
Returns the result of the allMatch operation, which indicates whether all strings in the list pass the case check.

Flowchart:

For more Practice: Solve these Related Problems:

Write a Java program to implement a lambda expression that checks if every string in a list is uppercase using allMatch().
Write a Java program to create a lambda that validates whether all strings in a list are lowercase and returns a boolean result.
Write a Java program to implement a lambda expression that determines if a list of strings is mixed-case by comparing counts of uppercase and lowercase letters.
Write a Java program to chain lambda expressions to group strings by their case type and then check for uniformity.

Live Demo:

Java Code Editor:

Improve this sample solution and post your code through Disqus

Java Lambda Exercises Previous: Calculate sum of prime numbers with lambda expression.
Java Lambda Exercises Next: Lambda expression to find average string length.