Методы для работы со строками

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

Листинг 4.Методы для работы со строками

class getCharsDemo{

public static void main(String args[]){

// Текстовая строка:

String s="Пример текстовой строки – язык Java";

// Символьный массив:

char buf[]=new char[9];

s.getChars(s.length()-9,s.length(),buf,0);

System.out.println(buf);

// Символ:

char symbol;

symbol=s.charAt(21);

System.out.println(symbol);

// Разделитель:

System.out.println("--------------------------");

// Массив чисел:

byte nums[];

nums=s.getBytes();

for(int i=0;i<s.length();i++){

System.out.print(nums[i]+" ");

if((i+1)%6==0) System.out.println();}

// Разделитель:

System.out.println("\n--------------------------");

char chars[]=new char[s.length()];

chars =s.toCharArray();

for(int i=0;i<s.length();i++){

if(s.charAt(i)==' ') System.out.println("-->");

else System.out.print(chars[i]+" * ");}

}

}

В программе объявляется объектная переменная s с одновременной инициализацией текстовым значением. После этого объявляется символьный массив buf из 9 элементов. В этот массив посимвольно считывается подстрока строки s.

Используется для этого метод getChars() (команда s.getChars(s.length()-9,s.length(),buf,0)). Аргументами методу передаются: начальный индекс элемента считываемой подстроки, индекс первого не считываемого в подстроку символа, имя массива, в который посимвольно записывается считываемая подстрока, и индекс элемента в этом массиве, начиная с которого массив заполняется символами подстроки. В данном случае считывается подстрока из элементов с индексами от s.length()-9 до s.length()-1 включительно, подстрока посимвольно заносится в массив buf, начиная с первого элемента массива buf[0].

Элементы массива выводятся на экран командой System.out.println(buf) — для вывода символьного массива достаточно указать его имя аргументом метода println().

Для считывания символа с определенным индексом из текстовой строки используется метод charAt(). Аргументом метода указывается индекс символа в текстовой строке (индексация символов, как и в массиве, начинается с нуля).

Результатом является символ в соответствующей позиции текстовой строки. Исходная строка при этом не меняется.

В программе объявлена переменная массива nums (тип byte[]). С помощью метода getBytes() создается массив и заполняется кодами символов исходной текстовой строки, а результат присваивается переменной nums. Аргументы методу не передаются, а результатом метода является массив числовых кодов символов строки, из которой вызывается метод. Для удобства при выводе значений массива nums числа распечатываются в несколько строк. Размер числового массива nums равен количеству символов в текстовой строке s.

Аналогично дела обстоят с символьным массивом chars. Только в данном случае массив заполняется символами текстовой строки, а не числовыми кодами, и делается это методом toCharArray(). Метод не имеет аргументов и возвращает в качестве значения символьный массив из букв тестовой строки, из которой вызывается метод.

При выводе на экран содержимого массива chars в местах пробелов осуществляется переход на новую строку вывода, между буквами вставляются символы «звездочка», а строки вывода завершаются импровизированными стрелками.

Результат выполнения программы такой:

язык Java

к

--------------------------

-49 -16 -24 -20 -27 -16

32 -14 -27 -22 -15 -14

-18 -30 -18 -23 32 -15

-14 -16 -18 -22 -24 32

-106 32 -1 -25 -5 -22

32 74 97 118 97

--------------------------

П * р * и * м * е * р * -->

т * е * к * с * т * о * в * о * й * -->

с * т * р * о * к * и * -->

– * -->

я * з * ы * к * -->

J * a * v * a *

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

Сравнение строк

При работе с текстом нередко возникает необходимость сравнить разные текстовые строки на предмет совпадения. Используют в этом случае методы equals() и equalsIgnoreCase(). Разница между этими методами состоит в том, что первый метод сравнивает строки с учетом регистра, а второй состояние регистра игнорирует. Метод equals() возвращает в качестве значения true, если строки состоят из одинаковых символов, размещенных на одинаковых позициях в строке. При этом строчная и прописная буквы интерпретируются как разные символы. Если полного совпадения нет, в качестве результата методом возвращается значение false. Метод equalsIgnoreCase() при сравнении строк интерпретирует строчную и прописную буквы как один и тот же символ.

Каждый из упомянутых методов вызывается из объекта строки, аргументом методу также передается строка. Это именно те строки, которые сравниваются методами.

Причина, по которой для сравнения строк нельзя использовать операторы сравнения «равно» (==) и «не равно» (!=), думается очевидна, однако на ней стоит все же остановиться. Вообще говоря, эти операторы использовать можно, но результат может быть несколько неожиданным.

Предположим, необходимо сравнить текстовые строки strA и strB. Объектные переменные описаны как String strA и String strB, после чего им присвоены значения. Если для сравнения использовать команду strA==strB или strA!=strB, то в соответствии с этими командами сравниваются значения объектных переменных strA и strB, а не текстовое содержание объектов, на которые эти переменные ссылаются. Значениями переменных strA и strB являются ссылки (адреса) на соответствующие объекты. Например, результатом выражения strA==strB является значение true, если переменные strA и strB ссылаются на один и тот же объект. Если же переменные ссылаются на разные объекты, значение выражения равно false. При этом разные объекты могут иметь одинаковые текстовые значения.

В листинге 5 приведен пример программы, в которой выполняется сравнение текстовых объектов.

Листинг 5.Сравнение строк

class equalStringsDemo{

public static void main(String args[]){

String strA="Алексей Васильев";

String strB=new String("Алексей Васильев");

String strC="Васильев Алексей";

String strD="АЛЕКСЕЙ ВАСИЛЬЕВ";

System.out.println(strA+" то же самое, что "+strB+" --> "+strA.equals(strB));

System.out.println(strA+" то же самое, что "+strC+" --> "+strA.equals(strC));

System.out.println(strA+" то же самое, что "+strD+" --> "+strA.equals(strD));

System.out.println(strA+" то же самое, что "+strD+" --> "+strA.

equalsIgnoreCase(strD));

System.out.println(strA+" то же самое, что "+strB+" --> "+(strA==strB));

}}

Результат выполнения программы имеет вид:

Алексей Васильев то же самое, что Алексей Васильев --> true

Алексей Васильев то же самое, что Васильев Алексей --> false

Алексей Васильев то же самое, что АЛЕКСЕЙ ВАСИЛЬЕВ --> false

Алексей Васильев то же самое, что АЛЕКСЕЙ ВАСИЛЬЕВ --> true

Алексей Васильев то же самое, что Алексей Васильев --> false

В программе создаются четыре текстовые строки. Все четыре переменные strA, strB, strC и strD ссылаются на разные объекты. При этом текстовое значение объектов, на которые ссылаются переменные strA и strB, одинаково. Текстовое значение объекта, на который ссылается переменная strD, совпадает с первыми двумя с точностью до состояния регистра. Объект, на который ссылается переменная strC, имеет текстовое значение, отличное от значений прочих объектов.

Текстовые значения созданных объектов сравниваются с помощью методов equals(), equalsIgnoreCase() и оператора равенства ==. Результат сравнения выводится на экран.

При сравнении значений объектов переменных strA и strB с помощью метода equals() подтверждается равенство строк. Этот же метод при сравнении строк strA и strC дает значение false — строки не совпадают. То же происходит при сравнении строк strA и strD. Если строки strA и strD сравнивать с помощью метода equalsIgnoreCase(), результатом является совпадение строк. Разное состояние регистра букв сравниваемых строк при этом игнорируется. Наконец, если сравнивать переменные strA и strB с помощью оператора сравнения «равно» (командой strA==strB), получаем значение false, поскольку переменные ссылаются на разные объекты.

Отметим, что если вместо команды String strB=new String("Алексей Васильев") воспользоваться командой String strB="Алексей Васильев" (практически такой же, как и для переменной strA), результатом выражения strA==strB будет true. Причина проста: обеим переменным strA и strB в качестве значения присваивается ссылка на один и тот же литерал, то есть на один объект класса String. Поэтому значения переменных (адреса объекта ссылки) совпадают, что и подтверждает сравнение их с помощью оператора сравнения «равно».