Извлечение подстрок из строки
Содержание:
- Методы String
- Метод сравнения String equalsIgnoreCase()
- Поиск в строке в Java
- java.lang.StringBuilder
- Параллельные операции над массивами
- Concatenating Strings
- Классы StringBuilder и StringBuffer
- Methods of Java String
- Нахождение длины строки
- Введите строку с помощью пользовательских методов
- Creating strings using the new keyword
- Копирование
- Разделение
- Метод toString() Java: синтаксис
- Сравнение строк
Методы String
Метод | Описание |
---|---|
charAt() | Возвращает символ строки с указанным индексом (позицией). |
charCodeAt() | Возвращает числовое значение Unicode символа, индекс которого был передан методу в качестве аргумента. |
concat() | Возвращает строку, содержащую результат объединения двух и более предоставленных строк. |
fromCharCode() | Возвращает строку, созданную с помощью указанной последовательности значений символов Unicode. |
indexOf() | Возвращает позицию первого символа первого вхождения указанной подстроки в строке. |
lastIndexOf() | Возвращает позицию последнего найденного вхождения подстроки или -1, если подстрока не найдена. |
localeCompare() | Возвращает значение, указывающее, эквивалентны ли две строки в текущем языковом стандарте. |
match() | Ищет строку, используя предоставленный шаблон регулярного выражения, и возвращает результат в виде массива. Если совпадений не найдено, метод возвращает значение null. |
replace() | Ищет строку для указанного значения или регулярного выражения и возвращает новую строку, где указанные значения будут заменены. Метод не изменяет строку, для которой он вызывается. |
search() | Возвращает позицию первого соответствия указанной подстроки или регулярного выражения в строке. |
slice() | Позволяет извлечь подстроку из строки. Первый аргумент указывает индекс с которого нужно начать извлечение. Второй необязательный аргумент указывает позицию, на которой должно остановиться извлечение. Если второй аргумент не указан, то извлечено будет все с той позиции, которую указывает первый аргумент, и до конца строки. |
split() | Разбивает строку на подстроки, возвращая массив подстрок. В качестве аргумента можно передать символ разделитель (например запятую), используемый для разбора строки на подстроки. |
substr() | Позволяет извлечь подстроку из строки. Первый аргумент указывает индекс с которого нужно начать извлечение. Второй аргумент указывает количество символов, которое нужно извлечь. |
substring() | Извлекает символы из строки между двух указанных индексов, если указан только один аргумент, то извлекаются символы от первого индекса и до конца строки. |
toLocaleLowerCase() | Преобразует символы строки в нижний регистр с учетом текущего языкового стандарта. |
toLocaleUpperCase() | Преобразует символы строки в верхний регистр с учетом текущего языкового стандарта. |
toLowerCase() | Конвертирует все символы строки в нижний регистр и возвращает измененную строку. |
toString() | Возвращает строковое представление объекта. |
toUpperCase() | Конвертирует все символы строки в верхний регистр и возвращает измененную строку. |
trim() | Удаляет пробелы в начале и конце строки и возвращает измененную строку. |
valueOf() | Возвращает примитивное значение объекта. |
Метод сравнения String equalsIgnoreCase()
С помощью метода equalsIgnoreCase() вы выполните сравнение строк, что называется, лексикографически, причём различия регистра будут игнорированы. Здесь значение true возвращается в том случае, если аргумент является объектом String и представляет такую же последовательность символов, что и у объекта. Прекрасное решение, если надо осуществить проверку строки на равенство, не учитывая при этом регистр.
class TestClass{ public static void main (String[] args){ String str1 = "Java"; String str2 = "JAVA"; // возвращается true, ведь обе строки равны без учёта регистра if(str1.equalsIgnoreCase(str2)){ System.out.println("Statement is true"); }else{ System.out.println("Statement is false"); } // возвращается false, т. к. учитывается регистр символов if(str1.equals(str2)){ System.out.println("Statement is true"); }else{ System.out.println("Statement is false"); } } }
Результат
Statement is true Statement is false
Поиск в строке в Java
Чтобы найти индекс первого вхождения подстроки в строку, используют метод indexOf(), последнего — метод lastIndexOf(). Если подстрока не найдена, оба метода вернут -1:
String str = "Hello world"; int index1 = str.indexOf('l'); // 2 int index2 = str.indexOf("wo"); //6 int index3 = str.lastIndexOf('l'); //9
Чтобы определить, начинается строка с определённой подстроки, применяют метод startsWith(). Что касается метода endsWith(), то он даёт возможность определить оканчивается ли строка на определенную подстроку:
String str = "myfile.exe"; boolean start = str.startsWith("my"); //true boolean end = str.endsWith("exe"); //true
java.lang.StringBuilder
В отличие от String класс StringBuilder позволяет менять содержимое своих экземпляров. В большинстве случаев нужно использовать
String, использование же
StringBuilder целесообразно в случаях, когда вам нужно соединить большое количество строковых переменных, например перебирая элементы массива или коллекции в цикле.
Так же как и у
String у
StringBuilder есть метод
length(), позволяющий узнать его длину в
char-ах.
В отличие от
String у
StringBuilder кроме длины есть ещё вместимость/ёмкость (capacity). Вместительность можно узнать с помощью метода
capacity(), она всегда больше или равна длине.
Конструктор | Описание |
---|---|
Создаёт пустой StringBuilder вместительностью 16 (16 пустых элементов). |
|
Создаёт StringBuilder , содержащий символы из последовательности и 16 дополнительных пустых элементов. |
|
Создаёт пустой StringBuilder с начальной вместительностью в initCapacity элементов. |
|
Создаёт StringBuilder , который содержит указанную строку и 16 дополнительных пустых элементов. |
StringBuilder содержит пару дополнительных методов, связанных с длиной, которых нет в
String:
Метод | Описание |
---|---|
Устанавливает длину последовательности символов. Если newLength меньше length(), то последние символы обрезаются. Если newLength больше length(), то в конец последовательности добавляются нулевые символы. |
|
Обеспечивает, что вместительность будет как минимум равной minCapacity. |
Некоторые методы могут увеличить длину последовательности символов в
StringBuilder. Если после выполнения подобного метода длина результирующей последовательности окажется больше вместительности, то вместительность автоматически увеличится.
Метод | Описание |
---|---|
Добавляет аргумент, преобразованный в строку, в конец StringBuilder-а. | |
Первый метод удаляет подпоследовательность с start до end-1 включительно. Второй метод удаляет символ по индексу. |
|
Вставляет второй аргумент, конвертированный в строку, в позицию index. |
|
Заменяет указанный символ/ы. | |
Меняет порядок символов в StringBuilder на обратный. Первый символ становится последним и так далее. |
|
Возвращает строку, содержащую последовательность символов из StringBuilder. |
Пример использования StringBuilder:
Java
String andStr = » and Petya»;
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(«Vasya»);
stringBuilder.append(andStr);
stringBuilder.append(» go to school.»);
System.out.println(stringBuilder);
1 |
StringandStr=» and Petya»; StringBuilder stringBuilder=newStringBuilder(); stringBuilder.append(«Vasya»); stringBuilder.append(andStr); stringBuilder.append(» go to school.»); System.out.println(stringBuilder); |
Цикл статей «Учебник Java 8».
Следующая статья — «Java 8 автоупаковка и распаковка».Предыдущая статья — «Java 8 числа».
Параллельные операции над массивами
Последнее обновление: 30.04.2018
В JDK 8 к классу Arrays было добавлено ряд методов, которые позволяют в параллельном режиме совершать обработку элементов массива.
И хотя данные методы формально не входят в Stream API, но реализуют схожую функциональность, что и параллельные потоки:
-
parallelPrefix(): вычисляет некоторое значение для элементов массива (например, сумму элементов)
-
parallelSetAll(): устанавливает элементы массива с помощью лямбда-выражения
-
parallelSort(): сортирует массив
Используем метод для установки элементов массива:
import java.util.Arrays; public class Program { public static void main(String[] args) { int[] numbers = initializeArray(6); for(int i: numbers) System.out.println(i); } public static int[] initializeArray(int size) { int[] values = new int; Arrays.parallelSetAll(values, i -> i*10); return values; } }
В метод передается два параметра: изменяемый массив и функция, которая устанавливает элементы массива. Эта
функция перебирает все элементы и в качестве параметра получает индекс текущего перебираемого элемента. Выражение означает,
что по каждому индексу в массиве будет хранится число, равное i * 10. В итоге мы получим следующий вывод:
0 10 20 30 40 50
Рассмотрим более сложный пример. Пусть у нас есть следующий класс Phone:
class Phone{ private String name; private int price; public Phone(String name, int price){ this.name=name; this.price = price; } public String getName() { return name; } public void setName(String val) { this.name=val; } public int getPrice() { return price; } public void setPrice(int val) { this.price=val; } }
Теперь произведем манипуляции с массивом объектов Phone:
Phone[] phones = new Phone[]{new Phone("iPhone 8", 54000), new Phone("Pixel 2", 45000), new Phone("Samsung Galaxy S9", 40000), new Phone("Nokia 9", 32000)}; Arrays.parallelSetAll(phones, i -> { phones.setPrice(phones.getPrice()-10000); return phones; }); for(Phone p: phones) System.out.printf("%s - %d \n", p.getName(), p.getPrice());
Теперь лямбда-выражение в методе представляет блок кода. И так как лямбда-выражение должно возвращать объект, то нам надо явным образом использовать
оператор return. В этом лямбда-выражении опять же функция получает индексы перебираемых элементов, и по этим индексам мы можем обратиться
к элементам массива и их изменить. Конкретно в данном случае происходит уменьшение цены смартфонов на 10000 единиц. В итоге мы получим следующий
консольный вывод:
iPhone 8 - 44000 Pixel 2 - 35000 Samsung Galaxy S9 - 30000 Nokia 9 - 22000
Сортировка
Отсортируем массив чисел в параллельном режиме:
int[] nums = {30, -4, 5, 29, 7, -8}; Arrays.parallelSort(nums); for(int i: nums) System.out.println(i);
Метод в качестве параметра принимает массив и сортирует его по возрастанию:
-8 -4 5 7 29 30
Если же нам надо как-то по-другому отсортировать объекты, например, по модулю числа, или у нас более сложные объекты, то мы можем создать свой компаратор и передать его в качестве второго параметра в
. Например, возьмем выше определенный класс Phone и создадим для него компаратор:
import java.util.Arrays; import java.util.Comparator; public class Program { public static void main(String[] args) { Phone[] phones = new Phone[]{new Phone("iPhone 8", 54000), new Phone("Pixel 2", 45000), new Phone("Samsung Galaxy S9", 40000), new Phone("Nokia 9", 32000)}; Arrays.parallelSort(phones,new PhoneComparator()); for(Phone p: phones) System.out.println(p.getName()); } } class PhoneComparator implements Comparator<Phone>{ public int compare(Phone a, Phone b){ return a.getName().toUpperCase().compareTo(b.getName().toUpperCase()); } }
Метод parallelPrefix
Метод походит для тех случаев, когда надо получить элемент массива или объект того же типа, что и элементы массива, который обладает некоторыми признаками.
Например, в массиве чисел это может быть максимальное, минимальное значения и т.д. Например, найдем произведение чисел:
int[] numbers = {1, 2, 3, 4, 5, 6}; Arrays.parallelPrefix(numbers, (x, y) -> x * y); for(int i: numbers) System.out.println(i);
Мы получим следующий результат:
1 2 6 24 120 720
То есть, как мы видим из консольного вывода, лямбда-выражение из , которое представляет бинарную функцию, получает два элемента и
выполняет над ними операцию. Результат операции сохраняется и передается в следующий вызов бинарной функции.
НазадВперед
Concatenating Strings
The String class includes a method for concatenating two strings −
string1.concat(string2);
This returns a new string that is string1 with string2 added to it at the end. You can also use the concat() method with string literals, as in −
"My name is ".concat("Zara");
Strings are more commonly concatenated with the + operator, as in −
"Hello," + " world" + "!"
which results in −
"Hello, world!"
Let us look at the following example −
Example
public class StringDemo { public static void main(String args[]) { String string1 = "saw I was "; System.out.println("Dot " + string1 + "Tod"); } }
This will produce the following result −
Классы StringBuilder и StringBuffer
Давайте теперь разберемся со StringBuilder и StringBuffer классами. По сути дела, это почти одинаковые классы. Единственное различие между ними: StringBuffer работает медленнее, но он потокобезопасный. Его использование целесообразно при написании программ на многопоточность.
Если Вы посмотрите на код выше, то последний метод, который я написал была конкатенация строк. То есть простое объединение строк в одну. Когда Вы работаете с классом String, результатом такой операции будет новый объект. Если программа конкатенирует много строк это может существенно потребить ресурсы памяти. В отличие от String классы StringBuilder, StringBuffer конкатенируют строки не создавая новый объект. У них есть метод append().
|
StringBuilder string = new StringBuilder(«Hello world»); String str = «!!!»; System.out.println(string.append(str));//Hello world!!!
Все остальные методы которые есть у класса String есть у данных классов.
Теперь Вы знаете больше о строках в Java. Предлагаю закрепить наши знания и написать небольшую программу для проверки логина и пароля. Пользователь вводит логин и пароль; если пароль совпадает, то вывести в консоль приветствие.
Вот что у меня получилось:
|
package com.string;import java.util.Scanner;public class StringVariables { private final static String PASSWORD = «pass43_4L»; private final static String LOGIN = «user»; public static void main(String args) { System.out.println(«Введите логин»); Scanner in = new Scanner(System.in); String login = in.nextLine(); System.out.println(«Введите пароль»); String password = in.nextLine(); if (LOGIN.equalsIgnoreCase(login)){ if (PASSWORD.equals(password)){ System.out.println(«Приветствую » + login); } else { System.out.println(«Неверный пароль»); } } else System.out.println(«Неверный логин»); } }
Methods of Java String
Besides those mentioned above, there are various string methods present in Java. Here are some of those methods:
Methods | Description |
---|---|
contains() | checks whether the string contains a substring |
substring() | returns the substring of the string |
join() | join the given strings using the delimiter |
replace() | replaces the specified old character with the specified new character |
replaceAll() | replaces all substrings matching the regex pattern |
replaceFirst() | replace the first matching substring |
charAt() | returns the character present in the specified location |
getBytes() | converts the string to an array of bytes |
indexOf() | returns the position of the specified character in the string |
compareTo() | compares two strings in the dictionary order |
compareToIgnoreCase() | compares two strings ignoring case differences |
trim() | removes any leading and trailing whitespaces |
format() | returns a formatted string |
split() | breaks the string into an array of strings |
toLowerCase() | converts the string to lowercase |
toUpperCase() | converts the string to uppercase |
valueOf() | returns the string representation of the specified argument |
toCharArray() | converts the string to a array |
matches() | checks whether the string matches the given regex |
startsWith() | checks if the string begins with the given string |
endsWith() | checks if the string ends with the given string |
isEmpty() | checks whether a string is empty of not |
intern() | returns the canonical representation of the string |
contentEquals() | checks whether the string is equal to charSequence |
hashCode() | returns a hash code for the string |
subSequence() | returns a subsequence from the string |
Нахождение длины строки
java string length() возвращает общее количество символов в строке. Длина строки Java такая же, как в коде Unicode.
Пример:
public class LengthExample{ public static void main(String args[]){ String s1="javatpoint"; String s2="python"; System.out.println("string length is: "+s1.length());//10 is the length of javatpoint string System.out.println("string length is: "+s2.length());//6 is the length of python string }}
Еще один способ:
public class LengthExample2 { public static void main(String[] args) { String str = "Javatpoint"; if(str.length()>0) { System.out.println("String is not empty and length is: "+str.length()); } str = ""; if(str.length()==0) { System.out.println("String is empty now: "+str.length()); } } }
Введите строку с помощью пользовательских методов
Класс String в Java не предоставляет удобного метода для заполнения, поэтому давайте создадим несколько методов самостоятельно. Однако сначала давайте определимся с некоторыми ожиданиями:
assertEquals(" 123456", padLeftZeros("123456", 10)); assertEquals("0000123456", padLeftZeros("123456", 10));
2.1. Использование StringBuilder
Мы можем достичь этого с помощью StringBuilder и некоторой процедурной логики:
public String padLeftZeros(String inputString, int length) { if (inputString.length() >= length) { return inputString; } StringBuilder sb = new StringBuilder(); while (sb.length() < length - inputString.length()) { sb.append('0'); } sb.append(inputString); return sb.toString(); }
Здесь мы видим, что если длина исходного текста равна или больше желаемой длины, мы возвращаем его неизмененную версию. В противном случае мы создадим новую строку , , начинающуюся с пробелов, и добавим исходную.
Конечно, если бы мы хотели pad с другим символом, мы могли бы просто использовать его вместо .
Аналогично, если мы хотим править страницу, нам просто нужно сделать new | StringBuilder(входная строка) вместо этого, а затем добавить пробелы в конце.
2.2. Использование подстроки
Другой способ сделать левое заполнение – создать Строку нужной длины, содержащую только символы заполнения, а затем использовать метод substring () :
StringBuilder sb = new StringBuilder(); for (int i = 0; i < length; i++) { sb.append(' '); } return sb.substring(inputString.length()) + inputString;
2.3. Использование String.format
И, наконец, начиная с Java 5, мы можем использовать String .format() :
return String.format("%1$" + length + "s", inputString).replace(' ', '0');
Следует отметить, что по умолчанию операция заполнения будет выполняться с использованием пробелов. Вот почему нам нужно использовать заменять() метод, если мы хотим заполнить нули или любой другой символ.
Для правильной площадки нам просто нужно использовать другой флаг: %1$-
Creating strings using the new keyword
So far we have created strings like primitive types in Java.
Since strings in Java are objects, we can create strings using the keyword as well. For example,
In the above example, we have created a string name using the keyword.
Here, when we create a string object, the constructor is invoked. To learn more about constructor, visit Java Constructor.
Note: The class provides various other constructors to create strings. To learn more, visit Java String (official Java documentation).
Create String using literals vs new keyword
Now that we know how strings are created using string literals and the keyword, let’s see what is the major difference between them.
In Java, the JVM maintains a string pool to store all of its strings inside the memory. The string pool helps in reusing the strings.
1. While creating strings using string literals,
Here, we are directly providing the value of the string (). Hence, the compiler first checks the string pool to see if the string already exists.
- If the string already exists, the new string is not created. Instead, the new reference, example points to the already existed string ().
- If the string doesn’t exist, the new string ( is created.
2. While creating strings using the new keyword,
Here, the value of the string is not directly provided. Hence, a new string is created even though is already present inside the memory pool.
Копирование
Возможно несколькими способами.
Копирование массива путем итерации массива
Первый способ – это перебрать массив и скопировать каждое значение исходного массива в целевой массив. Вот как выглядит копирование массива с использованием этого метода:
int[] source = new int; int[] dest = new int; for(int i=0; i < source.length; i++) { source = i; } for(int i=0; i < source.length; i++) { dest = source; }
Первые два массива int созданы. Во-вторых, исходный массив инициализируется значениями от 0 до 9 (от 0 до длины массива минус 1). В-третьих, каждый элемент в исходном массиве копируется в целевой массив.
Копирование с помощью Arrays.copyOf()
Вот как выглядит копирование массива:
int[] source = new int; for(int i=0; i < source.length; i++) { source = i; } int[] dest = Arrays.copyOf(source, source.length);
Метод Arrays.copyOf() принимает 2 параметра. Первый – это массив для копирования. Второй – это длина нового массива – можно использовать для указания количества копируемых элементов из исходного массива.
Копирование с использованием Arrays.copyOfRange()
Метод Arrays.copyOfRange() копирует диапазон массива, не обязательно полный массив. Процесс копирования с ним:
int[] source = new int; for(int i=0; i < source.length; i++) { source = i; } int[] dest = Arrays.copyOfRange(source, 0, source.length);
Метод Arrays.copyOfRange() принимает 3 параметра. Первый – это массив для копирования. Второй – это первый индекс в исходном массиве, который нужно включить в копию. Третий – это последний индекс в исходном массиве, который будет включен в копию (исключено – поэтому передача 10 будет копировать до и включая индекс 9).
Разделение
Класс Java String содержит метод split(), который можно использовать для разделения String на массив объектов String:
String source = "A man drove with a car."; String[] occurrences = source.split("a");
После выполнения этого кода Java массив вхождений будет содержать экземпляры String:
"A m" "n drove with " " c" "r."
Исходная строка была разделена на символы a. Возвращенные строки не содержат символов a. Символы a считаются разделителями для деления строки, а разделители не возвращаются в результирующий массив строк.
Параметр, передаваемый методу split(), на самом деле является регулярным выражением Java, которые могут быть довольно сложными. Приведенное выше соответствует всем символам, даже буквам нижнего регистра.
Метод String split() существует в версии, которая принимает ограничение в качестве второго параметра – limit:
String source = "A man drove with a car."; int limit = 2; String[] occurrences = source.split("a", limit);
Параметр limit устанавливает максимальное количество элементов, которое может быть в возвращаемом массиве. Если в строке больше совпадений с регулярным выражением, чем заданный лимит, то массив будет содержать совпадения с лимитом – 1, а последним элементом будет остаток строки из последнего среза – 1 совпадением. Итак, в приведенном выше примере возвращаемый массив будет содержать эти две строки:
"A m" "n drove with a car."
Первая строка соответствует регулярному выражению. Вторая – это остальная часть строки после первого куска.
Выполнение примера с ограничением 3 вместо 2 приведет к тому, что эти строки будут возвращены в результирующий массив String:
"A m" "n drove with " " car."
Обратите внимание, что последняя строка по-прежнему содержит символ в середине. Это потому, что эта строка представляет остаток строки после последнего совпадения (a после ‘n водил с’)
Выполнение приведенного выше примера с пределом 4 или выше приведет к тому, что будут возвращены только строки Split, поскольку в String есть только 4 совпадения с регулярным выражением a.
Метод toString() Java: синтаксис
public String toString() { return getClass().getName()+"@"+Integer.toHexString(hashCode()); } // программа Java для демонстрации // работы метода toString() class Best_Friend { String name; int age; String college; String course; String address; Best_Friend (String name, int age, String college, String course, String address) { this.name = name; this.age = age; this.college = college; this.course = course; this.address = address; } public static void main(String[] args) { Best_Friend b = new Best_Friend("Gulpreet Kaur", 21, "BIT MESRA", "M.TECH", "Kiriburu"); System.out.println(b); System.out.println(b.toString()); } }
Результат:
Best_Friend@232204a1 Best_Friend@232204a1
Пояснение: В приведенной выше программе мы создаем объект класса Best_Friend и предоставляем всю информацию о друге. Но когда мы пытаемся вывести Object, мы отображаем данные из classname@HashCode_in_Hexadeciaml_form. Если нужна соответствующая информация об объекте Best_friend, тогда нужно переопределить метод toString Java класса Object в классе Best_Friend.
// программа Java для демонстрации // работы метода toString() class Best_Friend { String name; int age; String college; String course; String address; Best_Friend (String name, int age, String college, String course, String address) { this.name = name; this.age = age; this.college = college; this.course = course; this.address = address; } public String toString() { return name + " " + age + " " + college + " " + course + " " + address; } public static void main(String[] args) { Best_Friend b = new Best_Friend("Gulpreet Kaur", 21, "BIT MESRA", "M.TECH", "Kiriburu"); System.out.println(b); System.out.println(b.toString()); } }
Вывод:
Gulpreet Kaur 21 BIT MESRA M.TECH Kiriburu Gulpreet Kaur 21 BIT MESRA M.TECH Kiriburu
Примечание. Во всех классах контейнерах, коллекциях, классах String, StringBuffer, StringBuilder метод toString Java переопределяется для значимого представления String. Поэтому настоятельно рекомендуется также переопределить метод toString() и в нашем классе.
// программа Java для демонстрации // работы метода toString() import java.util.*; class Best_Friend { String name; int age; String college; String course; String address; Best_Friend (String name, int age, String college, String course, String address) { this.name = name; this.age = age; this.college = college; this.course = course; this.address = address; } public static void main(String[] args) { Best_Friend b = new Best_Friend("Gulpreet Kaur", 21, "BIT MESRA", "M.TECH", "Kiriburu"); System.out.println(b); String s = new String("Gulpreet Kaur"); System.out.println(s); Integer i = new Integer(21); System.out.println(i); ArrayList l = new ArrayList(); l.add("BIT"); l.add("M.TECH"); System.out.println(l); } }
Вывод:
Best_Friend@232204a1 Gulpreet Kaur 21
Пожалуйста, оставляйте свои комментарии, если найдете ошибку в примерах использования метода toString или захотите поделиться дополнительной информацией по теме статьи.
Пожалуйста, опубликуйте ваши отзывы по текущей теме статьи. За комментарии, подписки, отклики, лайки, дизлайки низкий вам поклон!
Пожалуйста, опубликуйте ваши мнения по текущей теме материала. За комментарии, дизлайки, отклики, подписки, лайки низкий вам поклон!
Вадим Дворниковавтор-переводчик статьи «Java_lang_Object toString() Method in Java»
Сравнение строк
Для простого сравнения
строк используются методы equals() (с учетом регистра) и equalsIgnoreCase()
(без учета регистра). Оба метода в качестве параметра принимают строку, с
которой сравниваются:
String str1 = "Hello"; String str2 = "hello"; System.out.println(str1.equals(str2)); // false System.out.println(str1.equalsIgnoreCase(str2)); // true
Обратите
внимание, что в отличие сравнения числовых и других данных примитивных типов
для сравнения строк не рекомендуется использовать оператор ==. То есть,
записывать вот такое сравнение лучше не использовать:
if(str1 == str2) System.out.println("Сроки равны");
(хотя, оно тоже
будет работать). Вместо этого следует использовать метод equals() класса String.
Другая пара методов:
int compareTo(String str) и int compareToIgnoreCase(String str)
также сравнивают
строки между собой, но в отличие от equals() они еще
позволяют узнать больше ли одна строка другой или нет. Если возвращаемое
значение этих методов больше 0, то первая строка больше второй, если меньше
нуля, то, наоборот, вторая больше первой. Если строки равны, то возвращается 0.
Для определения
больше или меньше одна строка, чем другая, используется лексикографический
порядок. То есть, например, строка «A» меньше, чем строка
«B», так как символ ‘A’ в алфавите стоит перед символом ‘B’. Если
первые символы строк равны, то в расчет берутся следующие символы. Например:
String str1 = "hello"; String str2 = "world"; String str3 = "hell"; System.out.println(str1.compareTo(str2)); // -15 - str1 меньше чем str2 System.out.println(str1.compareTo(str3)); // 1 - str1 больше чем str3 System.out.println(str1.compareTo(str1)); // 0 - str1 равна str1
Еще один
специальный метод
regionMatches()
сравнивает
отдельные подстроки в пределах двух строк. Он имеет такие реализации:
boolean
regionMatches(int toffset, String other, int oofset, int len)
boolean
regionMatches(boolean ignoreCase, int toffset, String other, int oofset, int
len)
-
ignoreCase:
надо ли игнорировать регистр символов при сравнении (если значение true, то регистр
игнорируется); -
toffset:
начальный индекс в вызывающей строке, с которого начнется сравнение; -
other:
строка, с которой сравнивается вызывающая; -
oofset: начальный
индекс в сравниваемой строке, с которого начнется сравнение; -
len: количество
сравниваемых символов в обеих строках.
Например, ниже в
строке str1 сравнивается
подстрока wor с подстрокой wor строки str2:
String str1 = "Hello world"; String str2 = "I work"; boolean result = str1.regionMatches(6, str2, 2, 3); System.out.println(result); // true