Извлечение подстрок из строки

Методы 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
Метод Описание
Добавляет аргумент, преобразованный в строку, в конец  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
2
3
4
5
6

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 &plus; 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
Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Adblock
detector