Как проверить, состоит ли строка только из строчных букв в Java

Введение

В этом практическом занятии (лабораторной работе) вы научитесь проверять, состоит ли строка только из строчных букв на Java. Мы рассмотрим различные методы для достижения этой цели, начиная с сравнения строк с игнорированием регистра с использованием методов toLowerCase() и equalsIgnoreCase().

Затем вы узнаете, как пройти по каждому символу в строке и использовать метод Character.isLowerCase() для проверки каждого символа отдельно. Наконец, мы рассмотрим, как обрабатывать небуквенные символы при выполнении такой проверки.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/SystemandDataProcessingGroup(["System and Data Processing"]) java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java(("Java")) -.-> java/StringManipulationGroup(["String Manipulation"]) java/BasicSyntaxGroup -.-> java/for_loop("For Loop") java/StringManipulationGroup -.-> java/strings("Strings") java/SystemandDataProcessingGroup -.-> java/string_methods("String Methods") subgraph Lab Skills java/for_loop -.-> lab-559986{{"Как проверить, состоит ли строка только из строчных букв в Java"}} java/strings -.-> lab-559986{{"Как проверить, состоит ли строка только из строчных букв в Java"}} java/string_methods -.-> lab-559986{{"Как проверить, состоит ли строка только из строчных букв в Java"}} end

Сравнение строк с использованием toLowerCase()

На этом этапе мы научимся сравнивать строки на Java, игнорируя регистр букв. Это распространенная задача, когда вам нужно проверить, совпадают ли две строки, независимо от того, используют ли они заглавные или строчные буквы.

Создадим новый Java-файл, чтобы потренироваться в этом.

Откройте WebIDE, если он еще не открыт.
В проводнике файлов слева убедитесь, что вы находитесь в директории ~/project.
Щелкните правой кнопкой мыши в пустом пространстве проводника файлов, выберите "Новый файл" и назовите его CaseInsensitiveCompare.java.
Откройте файл CaseInsensitiveCompare.java в редакторе.

Скопируйте и вставьте следующий код в редактор:

public class CaseInsensitiveCompare {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "hello";
        String str3 = "World";

        // Comparing strings directly (case-sensitive)
        boolean areEqualCaseSensitive = str1.equals(str2);
        System.out.println("Case-sensitive comparison of \"" + str1 + "\" and \"" + str2 + "\": " + areEqualCaseSensitive);

        // Comparing strings ignoring case
        boolean areEqualCaseInsensitive = str1.equalsIgnoreCase(str2);
        System.out.println("Case-insensitive comparison of \"" + str1 + "\" and \"" + str2 + "\": " + areEqualCaseInsensitive);

        // Comparing str1 and str3 ignoring case
        boolean areEqualStr1Str3 = str1.equalsIgnoreCase(str3);
        System.out.println("Case-insensitive comparison of \"" + str1 + "\" and \"" + str3 + "\": " + areEqualStr1Str3);
    }
}

В этом коде:

Мы объявляем три переменные типа String: str1, str2 и str3.
str1.equals(str2) выполняет сравнение с учетом регистра. Он вернет false, потому что "Hello" и "hello" различаются из-за заглавной буквы 'H'.
str1.equalsIgnoreCase(str2) выполняет сравнение без учета регистра. Он вернет true, потому что "Hello" и "hello" совпадают, когда игнорируется регистр.
Мы также сравниваем str1 и str3 без учета регистра, чтобы показать, что разные слова все еще считаются разными.

Сохраните файл (Ctrl+S или Cmd+S).
Откройте терминал внизу WebIDE. Убедитесь, что вы находитесь в директории ~/project.
Скомпилируйте Java-программу с использованием команды javac:
```
javac CaseInsensitiveCompare.java
```
Если нет ошибок, вы не увидите никакого вывода. В директории ~/project будет создан файл CaseInsensitiveCompare.class.
Запустите скомпилированную Java-программу с использованием команды java:
```
java CaseInsensitiveCompare
```
Вы должны увидеть следующий вывод:
```
Case-sensitive comparison of "Hello" and "hello": false
Case-insensitive comparison of "Hello" and "hello": true
Case-insensitive comparison of "Hello" and "World": false
```
Этот вывод подтверждает, что метод equals() чувствителен к регистру, в то время как метод equalsIgnoreCase() игнорирует регистр.

Использование метода equalsIgnoreCase() - удобный способ сравнивать строки без забот о том, являются ли буквы заглавными или строчными.

Использование Character.isLowerCase() в цикле

На предыдущем этапе мы научились сравнивать целые строки, игнорируя регистр букв. Иногда вам может понадобиться проверить каждый символ в строке и определить, является ли он строчной или заглавной буквой. В Java для этого в классе Character есть полезные методы.

На этом этапе мы будем использовать метод Character.isLowerCase() в цикле для подсчета количества строчных букв в строке.

Откройте WebIDE, если он еще не открыт.
В проводнике файлов слева убедитесь, что вы находитесь в директории ~/project.
Создайте новый файл с именем CountLowercase.java в директории ~/project.
Откройте файл CountLowercase.java в редакторе.
Скопируйте и вставьте следующий код в редактор:
```
public class CountLowercase {
    public static void main(String[] args) {
        String text = "Hello World 123!";
        int lowercaseCount = 0;

        // Loop through each character in the string
        for (int i = 0; i < text.length(); i++) {
            char character = text.charAt(i); // Get the character at the current index

            // Check if the character is a lowercase letter
            if (Character.isLowerCase(character)) {
                lowercaseCount++; // Increment the counter if it's lowercase
            }
        }

        System.out.println("The string is: \"" + text + "\"");
        System.out.println("Number of lowercase letters: " + lowercaseCount);
    }
}
```
Разберем этот код:
- У нас есть переменная типа String с именем text, которая содержит смесь заглавных и строчных букв, цифр и символов.
- Мы инициализируем целочисленную переменную lowercaseCount со значением 0. Эта переменная будет хранить количество строчных букв.
- Мы используем цикл for для перебора каждого символа в строке. Цикл выполняется от индекса 0 до (но не включая) длины строки.
- text.charAt(i) возвращает символ по текущему индексу i.
- Character.isLowerCase(character) - это метод, который возвращает true, если заданный character является строчной буквой, и false в противном случае.
- Если Character.isLowerCase() возвращает true, мы увеличиваем значение lowercaseCount.
- В конце мы выводим исходную строку и общее количество строчных букв.
Сохраните файл (Ctrl+S или Cmd+S).
Откройте терминал внизу WebIDE. Убедитесь, что вы находитесь в директории ~/project.
Скомпилируйте Java-программу:
```
javac CountLowercase.java
```
Если компиляция прошла успешно, будет создан файл CountLowercase.class.
Запустите скомпилированную Java-программу:
```
java CountLowercase
```
Вы должны увидеть следующий вывод:
```
The string is: "Hello World 123!"
Number of lowercase letters: 8
```
Вывод показывает, что в строке "Hello World 123!" есть 8 строчных букв ('e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd').

Использование Character.isLowerCase() в цикле позволяет выполнять по-символьный анализ строки, что полезно для различных задач обработки текста.

Игнорирование небуквенных символов

На предыдущем этапе мы подсчитывали строчные буквы. Однако строки могут содержать различные символы, такие как цифры, пробелы и знаки препинания. При сравнении строк или анализе их содержимого часто нужно игнорировать эти небуквенные символы.

На этом этапе мы модифицируем нашу программу так, чтобы она обрабатывала только буквенные символы и игнорировала все остальное. Для этого мы будем использовать метод Character.isLetter().

Откройте WebIDE, если он еще не открыт.
Откройте файл CountLowercase.java, который вы создали на предыдущем этапе.
Измените код, добавив проверку, является ли символ буквой, перед проверкой, является ли он строчной. Замените существующий код следующим:
```
public class CountLowercase {
    public static void main(String[] args) {
        String text = "Hello World 123!";
        int lowercaseCount = 0;
        StringBuilder lettersOnly = new StringBuilder(); // To store only letter characters

        // Loop through each character in the string
        for (int i = 0; i < text.length(); i++) {
            char character = text.charAt(i); // Get the character at the current index

            // Check if the character is a letter
            if (Character.isLetter(character)) {
                lettersOnly.append(character); // Add the letter to our new string

                // Check if the letter is lowercase
                if (Character.isLowerCase(character)) {
                    lowercaseCount++; // Increment the counter if it's lowercase
                }
            }
        }

        System.out.println("The original string is: \"" + text + "\"");
        System.out.println("Letters only string: \"" + lettersOnly.toString() + "\"");
        System.out.println("Number of lowercase letters (ignoring non-letters): " + lowercaseCount);
    }
}
```
Вот что мы добавили и изменили:
- Мы ввели объект StringBuilder с именем lettersOnly. StringBuilder используется для эффективного построения строк, особенно когда вы добавляете символы в цикле.
- Внутри цикла мы добавили условие if (Character.isLetter(character)). Это проверяет, является ли текущий character буквой (как заглавной, так и строчной).
- Если символ является буквой, мы добавляем его в StringBuilder lettersOnly с помощью lettersOnly.append(character).
- Проверка Character.isLowerCase(character) теперь вложена в проверку Character.isLetter(), чтобы мы подсчитывали только строчные буквы среди символов, которые действительно являются буквами.
- В конце мы выводим исходную строку, строку, содержащую только буквы, и количество строчных букв среди этих букв.
Сохраните файл (Ctrl+S или Cmd+S).
Откройте терминал внизу WebIDE. Убедитесь, что вы находитесь в директории ~/project.
Скомпилируйте модифицированную Java-программу:
```
javac CountLowercase.java
```
Убедитесь, что нет ошибок компиляции.
Запустите скомпилированную Java-программу:
```
java CountLowercase
```
Вы должны увидеть следующий вывод:
```
The original string is: "Hello World 123!"
Letters only string: "HelloWorld"
Number of lowercase letters (ignoring non-letters): 8
```
Обратите внимание, что строка "Letters only string" теперь содержит только "HelloWorld", и количество строчных букв по-прежнему равно 8, так как мы подсчитываем только строчные буквы среди реальных букв.

Использование Character.isLetter() очень полезно, когда вам нужно отфильтровать неалфавитные символы из строки перед ее дальнейшей обработкой.

Резюме

В этом практическом занятии (лабораторной работе) мы научились проверять, состоит ли строка только из строчных букв в Java. Мы рассмотрели два основных метода. Во - первых, мы сравнивали строки с использованием метода equalsIgnoreCase(), чтобы выполнить сравнение без учета регистра букв, показав, как проверить, совпадают ли две строки, независимо от регистра букв.

Во - вторых, хотя полные детали не были предоставлены, этапы работы показывают, что мы научились перебирать символы в строке с помощью цикла и использовать метод Character.isLowerCase() для проверки, являются ли отдельные символы строчными, а также рассмотрели, как игнорировать небуквенные символы в этом процессе.