String

Введение в строки. Класс String

Последнее обновление: 31.10.2018

Строка представляет собой последовательность символов. Для работы со строками в Java определен класс String, который предоставляет ряд методов для манипуляции строками.
Физически объект String представляет собой ссылку на область в памяти, в которой размещены символы.

Для создания новой строки мы можем использовать один из конструкторов класса String, либо напрямую присвоить строку в двойных кавычках:

public static void main(String[] args) {
        
    String str1 = "Java";
    String str2 = new String(); // пустая строка
    String str3 = new String(new char[] {'h', 'e', 'l', 'l', 'o'});
    String str4 = new String(new char[]{'w', 'e', 'l', 'c', 'o', 'm', 'e'}, 3, 4);//3 -начальный индекс, 4 -кол-во символов
        
    System.out.println(str1); // Java
    System.out.println(str2); //
    System.out.println(str3); // hello
    System.out.println(str4); // come
}

При работе со строками важно понимать, что объект String является неизменяемым (immutable). То есть при любых операциях
над строкой, которые изменяют эту строку, фактически будет создаваться новая строка

Поскольку строка рассматривается как набор символов, то мы можем применить метод length() для нахождения длины строки или длины набора символов:

String str1 = "Java";
System.out.println(str1.length()); // 4

А с помощью метода toCharArray() можно обратно преобразовать строку в массив символов:

String str1 = new String(new char[] {'h', 'e', 'l', 'l', 'o'});
char[] helloArray = str1.toCharArray();

Строка может быть пустой. Для этого ей можно присвоить пустые кавычки или удалить из стоки все символы:

String s = "";   // строка не указывает на объект
if(s.length() == 0) System.out.println("String is empty");

В этом случае длина строки, возвращаемая методом length(), равна 0.

Класс String имеет специальный метод, который позволяет проверить строку на пустоту — isEmpty(). Если строка пуста, он возвращает true:

String s = "";   // строка не указывает на объект
if(s.isEmpty()) System.out.println("String is empty");

Переменная String может не указывать на какой-либо объект и иметь значение null:

String s = null;   // строка не указывает на объект
if(s == null) System.out.println("String is null");

Значение null не эквивалентно пустой строке. Например, в следующем случае мы столкнемся с ошибкой выполнения:

String s = null;   // строка не указывает на объект
if(s.length()==0) System.out.println("String is empty");	// ! Ошибка

Так как переменная не указывает ни на какой объект String, то соответственно мы не можем обращаться к методам объекта String.
Чтобы избежать подобных ошибок, можно предварительно проверять строку на null:

String s = null;   // строка не указывает на объект
if(s!=null && s.length()==0) System.out.println("String is empty");

Основные методы класса String

Основные операции со строками раскрывается через методы класса String, среди которых можно выделить следующие:

• concat(): объединяет строки

• valueOf(): преобразует объект в строковый вид

• join(): соединяет строки с учетом разделителя

• сompareTo(): сравнивает две строки

• charAt(): возвращает символ строки по индексу

• getChars(): возвращает группу символов

• equals(): сравнивает строки с учетом регистра

• equalsIgnoreCase(): сравнивает строки без учета регистра

• regionMatches(): сравнивает подстроки в строках

• indexOf(): находит индекс первого вхождения подстроки в строку

• lastIndexOf(): находит индекс последнего вхождения подстроки в строку

• startsWith(): определяет, начинается ли строка с подстроки

• endsWith(): определяет, заканчивается ли строка на определенную подстроку

• replace(): заменяет в строке одну подстроку на другую

• trim(): удаляет начальные и конечные пробелы

• substring(): возвращает подстроку, начиная с определенного индекса до конца или до определенного индекса

• toLowerCase(): переводит все символы строки в нижний регистр

• toUpperCase(): переводит все символы строки в верхний регистр

Разберем работу этих методов.

НазадВперед

Git Essentials

Ознакомьтесь с этим практическим руководством по изучению Git, содержащим лучшие практики и принятые в отрасли стандарты. Прекратите гуглить команды Git и на самом деле изучите это!

String myString = "there,,are,more,than,three,commas,,,";
String [] splitStrings = myString.split(",", -1);

for(String string : splitStrings){
    System.out.println(String.format(" \" %s \"", string));
}

будет разделена как можно больше раз, и конечные пустые строки будут добавлены в массив:

"there"
""
"are"
"more"
"than"
"three"
"commas"
""
""
""

Фактическое отрицательное значение, которое мы использовали, не принимается во внимание, мы получили бы тот же результат, если бы использовали. Если мы установим равным , строка снова будет разделена как можно больше раз, но результирующий массив не будет содержать завершающих пустых пробелов:

Если мы установим равным , строка снова будет разделена как можно больше раз, но результирующий массив не будет содержать завершающих пустых пробелов:

String myString = "there,,are,more,than,three,commas,,,";

// Equivalent to calling the split() method with only the regex parameter
String [] splitStrings = myString.split(",", 0);

for(String string : splitStrings){
    System.out.println(String.format(" \" %s \"", string));
}

Это дало бы нам:

"there"
""
"are"
"more"
"than"
"three"
"commas"

Примечание о специальных символах

Как мы упоминали ранее, параметр , передаваемый в качестве разделителя в методе , является регулярным выражением. Мы должны обязательно избегать специальных символов, если хотим использовать их буквальное значение в качестве разделителя. Например, символ означает “один или несколько экземпляров следующих символов”.

В регулярном выражении есть 12 таких символов. Это: , , , , , , , , , , , . Вы можете увидеть их значение в регулярном выражении .

Если мы хотим разделить на один из этих символов, необходимо соблюдать особую осторожность, чтобы избежать этих символов в параметрах метода. Один из способов, которым мы можем это использовать, – использовать обратную косую черту

Например:

string.split("\\|");

Разделяет переменную на символ /. Мы используем здесь две обратные косые черты, так как нам нужно сначала избежать Java-значения обратной косой черты, чтобы обратную косую черту можно было применить к символу |.

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

string.split("");

Еще один способ избежать специальных символов-использовать :

string.split(Pattern.quote("|"));

Вывод

Метод класса Java является очень полезным и часто используемым инструментом. Большинство данных, особенно полученных при чтении файлов, потребовали бы некоторой предварительной обработки, такой как разделение строки, для получения из нее значимой информации.

В этой статье мы рассмотрели, как разделять строки в Java.

Обрезка посредством trim()

Класс Java String содержит метод trim(), который может обрезать строковый объект. Предназначен для удаления в начале и конце строки пробелов, табуляцию и переход на новую строку:

String text    = "  And he ran across the field   ";
String trimmed = text.trim();

После выполнения этого кода усеченная переменная будет указывать на экземпляр String со значением

"And he ran across the field"

Пробельные символы в начале и конце объекта String были удалены. Символ пробела внутри строки не был затронут. Имеется в виду между первым и последним символом, не являющимся пробелом.

Метод trim() не изменяет экземпляр String. Вместо этого он возвращает новый объект Java String, который равен объекту String, из которого он был создан, но с удаленным пробелом в начале и конце строки.

Метод trim() может быть очень полезен для обрезки текста, введенного пользователем в поля ввода. Например, пользователь может ввести свое имя и случайно поставить дополнительный пробел после последнего слова или перед первым словом. Метод trim() — это простой способ удалить такие лишние пробелы.

Метод 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 String to int. На практике это выглядит так:

int переменная = Integer.parseInt(Объект_типа_String). Приведение в Java String to int может порождать и исключения. Например, когда в преобразуемой к числу строке,содержатся не только цифры, но и буквы. Естественно, что такое исключение нужно вовремя перехватить и обработать.

Существует и второй тип преобразования строки в число — Integer.valueOf(). Единственная разница между ними состоит в том, что parseInt возвращает примитивный int, а valueOf — объект типа Integer.

Массивы и перечисления очень активно используются при программировании в Java. String array — это совокупность данных, объединённых по общему признаку. Преобразовать строку массив символов очень просто — для этого используется метод toCharArray(). Он разбивает текстовые данные посимвольно и создаёт список с ними. Тип массива при этом будет char[].

Методы String Java могут выполнять и обратное преобразование. К примеру, когда нужно представить число или другой тип данных как строку. Выглядит применение так:

String.valueOf(значение_или_переменная одного из нескольких типов). Результатом выполнения будет строка.

Разделение

Класс 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.

Методы 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()	Возвращает примитивное значение объекта.

Concatenating Strings

The 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 method with string literals, as in:

"My name is ".concat("Rumplestiltskin");

Strings are more commonly concatenated with the operator, as in

"Hello," + " world" + "!"

which results in

"Hello, world!"

The operator is widely used in statements. For example:

String string1 = "saw I was ";
System.out.println("Dot " + string1 + "Tod");

which prints

Dot saw I was Tod

Such a concatenation can be a mixture of any objects. For each object that is not a , its method is called to convert it to a .

Note: The Java programming language does not permit literal strings to span lines in source files, so you must use the concatenation operator at the end of each line in a multi-line string. For example:

String quote = 
    "Now is the time for all good " +
    "men to come to the aid of their country.";

Breaking strings between lines using the concatenation operator is, once again, very common in statements.

Поиск с помощью indexOf()

Вы можете искать подстроки в Strings, используя метод indexOf():

String string1 = "Hello World";

int index = string1.indexOf("World");

Индексная переменная будет содержать значение 6 после выполнения этого кода. Метод indexOf() возвращает индекс, в котором находится первый символ в первой соответствующей подстроке. В этом случае W совпадающей подстроки World была найдена по индексу 6. Если подстрока не найдена в строке, метод возвращает -1.

Существует версия метода indexOf(), которая берет индекс, с которого начинается поиск. Таким образом, вы можете искать в строке, чтобы найти более одного вхождения подстроки:

String theString = "is this good or is this bad?";
String substring = "is";

int index = theString.indexOf(substring);
while(index != -1) {
    System.out.println(index);
    index = theString.indexOf(substring, index + 1);
}

Этот код просматривает строку «это хорошо или это плохо?» для вхождений подстроки «is». Для этого используется метод indexOf(substring, index). Параметр index указывает, с какого индекса символа в строке следует начать поиск. В этом примере поиск начинается с 1 символа после индекса, в котором было найдено предыдущее вхождение.

Вывод:

0
5
16
21

Подстрока «is» находится в четырех местах. Два раза в словах «есть» и два раза внутри слова «этот».

Класс Java String также имеет метод lastIndexOf(), который находит последнее вхождение подстроки:

String theString = "is this good or is this bad?";
String substring = "is";

int index = theString.lastIndexOf(substring);
System.out.println(index);

Выход — 21, который является индексом последнего вхождения подстроки «is».

StartWith() и EndWith()

Методы StartWith() и EndWith() проверяют, начинается ли String с определенной подстроки:

String one = "This is a good day to code";

System.out.println( one.startsWith("This")    );
System.out.println( one.startsWith("This", 5) );

System.out.println( one.endsWith("code")    );
System.out.println( one.endsWith("shower")  );

В этом примере создается строка и проверяется, начинается ли она и заканчивается ли она различными подстроками.

• Первая строка (после объявления String) проверяет, начинается ли String с подстроки «This». Поскольку это происходит, метод startWith() возвращает true.
• Вторая строка проверяет, начинается ли строка с подстроки «This» при запуске сравнения с символа с индексом 5. Результат равен false, поскольку символ с индексом 5 равен «i».
• Третья строка проверяет, заканчивается ли String подстрокой «code». Поскольку это происходит, метод endWith() возвращает true.
• Четвертая строка проверяет, заканчивается ли String подстрокой «shower». Так как это не так, метод endWith() возвращает false.

Присоединение, объединение или добавление строк в Java

Самый простой способ объединить строки в Java — это использовать +. Это работает так:

String text1 = "Hello";

String text2 = "Jim";

System.out.println(text1 + " " + text2);

Однако это не очень эффективно, потому что каждый раз, когда вы пишете +, вы создаете новый объект String. По этой причине вы можете использовать StringBuilder или более старую поточно-ориентированную версию StringBuffer.

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" to");
sb.append(" you");
System.out.println(sb.toString());

Более того, поскольку append() возвращает ссылку на сам объект StringBuilder, мы можем написать что-то вроде этого с тем же эффектом:

StringBuilder sb = new StringBuilder();
sb.append("Hello")
.append(" to")
.append(" you");
System.out.println(sb.toString());

Подстрока Java: выбор частей строк

Чтобы получить часть строки, используйте метод substring.

String substring(int beginIndex, int endIndex)

Длина выбранной подстроки равна endIndex — startIndex.

Вот несколько примеров.

String text = "The quick brown fox";
// Everything from index 4 onwards
System.out.println(text.substring(4));
// Index 0 up to but not including index 3.
System.out.println(text.substring(0, 3));

Java Array String: объединение массивов строк

Удивительно, но в ядре Java нет способа объединения массивов строк, хотя такие методы существуют в различных библиотеках.

Вы всегда можете создать свои собственные. Следующий класс объявляет именно такой метод и использует его для соединения массива строк. Вы можете легко адаптировать это для работы с ArrayList или Vector или чем-то еще.

package caveofprogramming.aquarium;
package caveofprogramming.aquarium;

import java.util.*;

public class Test {
    public static String join(String[] strings, String glue) {
    
        StringBuilder sb = new StringBuilder();
        
        for(int i=0; i < strings.length; i++) {
            sb.append(strings);
            
            if(i < strings.length - 1) {
                sb.append(glue);
            }
        }
        
        return sb.toString();
    }
    
    public static void main(String [] args) {

        String texts[] = {"Hello", "to", "you"};
        System.out.println(join(texts, " "));
    }
}

Java String Split: разделение строк

Вы можете разбить строку на массив токенов, используя метод split (REGEX).

Давайте посмотрим на некоторые примеры.

Чтобы разделить пробелом (это также работает для вкладок):

String text = "The quick brown fox";
String text = "The quick brown fox";
        
// Split on whitespace
String [] tokens = text.split("\s+");
        
for(int i=0; i < tokens.length; i++) {
    System.out.println(tokens);
}

Разделим электронный адрес на части

String text = "someone@nowhere.com";

// Split on @ and .
// The double backslashes make this regular
// expression look more confusing than it is.
// We are escaping once for the sake of the
// regex, and again for the sake of Java.
String [] tokens = text.split("+");

for(int i=0; i < tokens.length; i++) {
    System.out.println(tokens);
}