Строки и текстовый ввод-вывод в языке программирования

Размещено на http://www.allbest.ru/

1. Строки и текстовый ввод-вывод

Строка - это последовательность символов. Символы в строках хранятся в кодировке Unicode, в которой каждый символ занимает два байта. Тип каждого символа char.

Во многих языках программирования строки представляют собой массивы символов, но в Java строки являются объектами. Они могут быть экземплярами класса String или классов StringBuffer и StringBuilder.

В объектах класса String хранятся строки-константы неизменной длины и содержания. Это значительно ускоряет обработку строк и позволяет экономить память, разделяя строку между объектами, использующими ее. Когда говорят, что строки в объектах класса String неизменяемы, имеют в виду, что содержимое экземпляра строки не может быть изменено после ее создания. Однако переменная, объявленная как String, в любой момент может быть переопределена так, чтобы указывать на другой объект класса String.

Длину строк, хранящихся в объектах класса StringBuffer и StringBuilder, можно менять, вставляя и добавляя строки и символы, удаляя подстроки или сцепляя несколько строк в одну строку.

Классы String, StringBuffer и StringBuilder определены в пакете java.lang и доступны автоматически.

1.1 Класс String

1.1.1 Конструкторы класса String

Класс String имеет 13 конструкторов и более чем 40 методов для манипулирования строками.

Строку можно создать из строкового литерала или массива символов. Чтобы создать строку из строкового литерала следует использовать следующий синтаксис:

String newString = new String(stringLiteral);

Аргумент stringLiteral - это последовательность символов, заключенная в двойные кавычки. Следующий оператор создает строку message из строкового литерала "Welcome to Java":

String message = new String("Welcome to Java");

Java преобразует строковый литерал в объект типа String. Создать строку можно и следующим образом:

String message = "Welcome to Java";

Создать строку можно из массива символов. Следующая инструкция создает строку "Good Day":

char[] charArray = {'G', 'o', 'o', 'd', ' ', 'D', 'a', 'y'};

String message = new String(charArray);

Некоторые другие часто используемые конструкторы класса String приведены в примере 7.1.

Пример.1 Конструкторы класса String.

Объяснение: Первая строка в примере создается конструктором класса String без параметров и назначает своей ссылкой переменную s1. Созданный при этом новый объект не содержит символов (это пустая строка, которая записывается в виде "" и имеет длину 0). Объект с ссылкой s2 создается конструктором класса String, принимающим в качестве аргумента другой строковый объект. Новый объект будет содержать ту же последовательность символов, что и строковый объект, переданный в конструктор в качестве аргумента. Объект s3 создается из массива символов charArray. А объект s4, создается конструктором, который принимает в качестве аргументов массив символов charArray и два целых числа. Второй аргумент определяет начальную позицию (offset), начиная с которой будут выбираться символы из массива в создаваемую строку. Третий аргумент указывает количество символов (count). В случае если аргументы offset и count имеют недопустимые значения, выходящие за пределы массива, будет брошено исключение StringIndexOutOfBoundsException.

public class StringConstructors

{

public static void main( String[] args )

{

char[] charArray = {'b','i','r','t','h','','d','a','y'};

String s = new String( "hello" );

// use String constructors

String s1 = new String();

String s2 = new String(s);

String s3 = new String(charArray);

String s4 = new String(charArray, 6, 3);

System.out.printf("s1 = %s\ns2 = %s\ns3 = %s\ns4 = %s\n",

s1, s2, s3, s4 );

}

}

Результат:

s1 =

s2 = hello

s3 = birth day

s4 = day

Будьте внимательны! Переменная типа String содержит ссылку на объект-строку, которая хранит значение строки. Строго говоря, переменная String, объект String, и строковое значение - разные. Большую часть времени различия между ними будем игнорировать. Для простоты термин строка будет часто использоваться для обозначения переменной String, объекта String, и самого значения строки.

1.1.2 Интернирование строк

Объект String является неизменным, его содержание не может быть изменено. Изменит ли следующий код содержимое строки?

String s = "Java";

s = "HTML";

Ответ: нет. Первый оператор создает объект String с содержанием "Java" и ссылкой s. Второй оператор создает новый объект String с содержанием "HTML" и присвоит его ссылке s. Первый объект String все еще существует после присваивания, но к нему больше нельзя получить доступ, потому что переменная s теперь указывает на новый объект, как показано на рисунке 7.1.

Рисунок 1 - Строки String являются неизменными, однажды создав их содержимое нельзя изменить

Поскольку строки являются неизменными и часто применяются в программировании, JVM использует уникальный экземпляр для строковых литералов с одинаковой последовательностью символов в целях повышения эффективности и экономии памяти. Если строки идентичны, две ссылки могут указывать на один объект, что позволяет более экономно использовать память и быстрее сравнивать строки - этот механизм называется интернированием строк. Например, следующие операторы:

String s1 = "Welcome to Java";

String s2 = new String("Welcome to Java");

String s3 = "Welcome to Java";

System.out.println("s1==s2 is" + (s1==s2));

System.out.println("s1==s3 is" + (s1==s3));

напечатают:

s1==s2 is false

s1==s3 is true

Ссылки s1 и s3 указывают на один и тот же объект - интернированную строку "Welcome to Java", поэтому сравнение s1 == s3 - это истина. Тем не менее, операция сравнения s1 == s2 является ложной, так как s1 и s2 два различных объекта String, не смотря на то, что у них одинаковое содержимое (рис.7.2).

Рисунок 7.2 - Пример интернирования строк

1.1.3 Нахождение длины строки и выбор символов из строки

Методы класса String: length(), charAt() и getChars() возвращают длину строки, символ строки из указанной позиции и набор символов из строки в виде массива символов, соответственно.

Пример .2 Применение методов length(), charAt() и getChars() класса String.

public class StringExample

{

public static void main( String[] args )

{

String s1 = "hello there";

char[] charArray = new char[5];

System.out.printf( "s1: %s",s1);

// тестируем метод length()

System.out.printf( "\nLength of s1: %d", s1.length());

// перебор символов строки s1 с помощью

// метода charAt() в обратном порядке

System.out.print( "\nThe string reversed is: " );

for ( int count = s1.length() - 1; count >= 0; count-- )

System.out.printf("%c",s1.charAt(count));

// копируем символы из строки в массив charArray

s1.getChars( 0, 5, charArray, 0 );

System.out.print( "\nThe character array is: " );

for ( char character : charArray )

System.out.print( character );

System.out.println();

}}

Результат:

s1: hello there

Length of s1: 11

The string reversed is: ereht olleh

The character array is: helloВ коде примера 7.2 метод length() используется для определения количества символов в строке s1. Как и массивы, строки знать свою длину. Однако, в отличие от массивов, доступ к длине строки можно получить только через метод length() класса String.

Метод charAt() возвращает из строки символ, расположенный в заданной позиции. Метод charAt() принимает целочисленный аргумент, который используется в качестве индекса и возвращает символ из этой позиции. Как и в массивах, первый элемент строки имеет нулевой индекс. Если индекс, переданный в качестве аргумента в метод, отрицателен или больше чем длина строки, возникает исключительная ситуация. В программе с помощью метода charAt() организован вывод символов строки s1 в обратном порядке.

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

Задача.1. Определите, является ли введенная строка палиндромом.

Объяснение: строка является палиндромом, если она одинаково читается в обе стороны. Слова "топот", "шалаш" и "ротор", например, являются палиндромами.

Одно из решений задачи состоит в проверке, является ли первый символ в строке таким же, как последний символ. Если это так, проверяется второй и предпоследний символ. Далее этот процесс продолжается до тех пор, пока не будет найдено несоответствие или все символы в строке будут сравнены, за исключением среднего символа, если строка имеет нечетное количество символов.

Для реализации этой идеи, в программе используются две переменные low и high, равные индексам двух символов в начале и в конце строки s соответственно. Изначально переменная low равна 0, и high равна s.length ()-1. Если символы с указанными индексами равны, то low увеличивается на 1, а high соответственно уменьшается на 1. Этот процесс продолжается до тех пор, пока (low<high) или до момента, когда не будет найдено соответствие.

import java.util.Scanner;

public class CheckPalindrome {

public static void main(String[] args) {

Scanner input = new Scanner(System.in, "UTF-8");

System.out.print("Введите строку: ");

String s = input.nextLine();

if (isPalindrome(s))

System.out.println(s + " является палиндромом");

else

System.out.println(s + " не является палиндромом");

}

public static boolean isPalindrome(String s) {

int low = 0;

int high = s.length() - 1;

while (low < high) {

if(s.charAt(low) != s.charAt(high))

return false; // не палиндром

low++;

high--;

}

return true; // строка является палиндромом

}

}

Результат:

Введите строку: мама

мама не является палиндромом

Введите строку: шалаш

шалаш является палиндромом

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

Класс String предоставляет методы для сравнения строк, которые приведены в табл.7.1.

Таблица 7.1 - Методы класса String для сравнения строк

Метод	Описание
boolean equals(Object s1)	Возвращает true если строка равна строке s1
boolean equalsIgnoreCase(String s1)	Возвращает true если данная строка равна строке s1 без учета регистра букв
int compareTo(String s1)	Возвращает целое число больше 0, равное 0 или меньше 0 в зависимости от того является ли данная строка больше, равной или меньше чем s1.
int compareToIgnoreCase(String s1)	То же, что и метод compareTo() за исключением того, что при сравнении не учитываются регистры букв
boolean regionMatches(int index, String s1, int s1Index, int len)	Возвращает true если указанная подстрока точно соответствует указанной подстроке строки s1
boolean regionMatches(boolean ignoreCase, int index, String s1, int s1Index, int len)	То же, что в предыдущем методе исключением того, что можно указать параметр true - игнорировать регистр букв
boolean startsWith(String prefix)	Возвращает true если строка начинается с указанного префикса
boolean endsWith(String suffix)	Возвращает true если строка заканчивается указанным суффиксом

Как сравнить содержимое двух строк? Можно попытаться использовать оператор сравнения ==, а именно:

if (string1==string2)

System.out.println("string1 и string2 - один и тот же объект");

else

System.out.println("string1 и string2 - разные объекты");

Операция сравнения == сопоставляет только ссылки на строки. Она выясняет, указывают ли ссылки на одну и ту же строку. Например, для строк

String s1 = "Какая-то строка";

String s2 = "Другая строка";

сравнение s1 == s2 дает в результате false.

Значение true получится, только если обе ссылки указывают на одну и ту же строку, например, после присваивания s1 = s2.

Интересно, что если мы определим s2 так:

String s2 = "Какая-то строка";

то сравнение s1 == s2 даст в результате true, потому что компилятор создаст только один интернированный экземпляр константы "Какая-то строка" и направит на него все ссылки.

Если нужно сравнивать не ссылки, а содержимое строк, то для этого есть несколько методов.

Логический метод equals (Object obj), переопределенный из класса Object, возвращает true, если аргумент obj не равен null, является объектом класса String, и строка, содержащаяся в нем, полностью идентична данной строке вплоть до совпадения регистра букв. В остальных случаях возвращается значение false. Для сравнения содержимого двух строк следовало бы использовать следующий код:

if (string1.equals(string2))

System.out.println("string1 и string2 имеют одинаковое содержимое");

else

System.out.println("string1 и string2 не равны");

Пример сравнения строк с помощью метода equals() приведен ниже:

String s1 = new String("Welcome to Java");

String s2 = "Welcome to Java";

String s3 = "Welcome to C++";

System.out.println(s1.equals(s2)); // true

System.out.println(s1.equals(s3)); // false

Метод compareTo() также может быть использован для сравнения двух строк. Например, так: s1.compareTo (s2);

Метод возвращает значение 0, если s1 равно s2, значение меньше 0, если s1 лексикографически (то есть, с точки зрения упорядочения Unicode) меньше, чем s2, а значение больше 0, если s1 лексикографически больше s2.

Фактическое значение, возвращаемое методом compareTo() зависит от смещения первых двух различимых символов s1 и s2 слева направо. Например, предположим, s1 равно abc, а s2 равно abg, то s1.compareTo (s2) вернет -4. Сначала будут сравниваться первые два символа (a и a) у s1 и s2. Так как они равны, сравнивается вторая пара символов (b и b). Они также равны, далее сравниваются третьи два символа (c и g). Поскольку символ c на 4 меньше, чем g, то метод сравнения вернет -4.

Запомните! Метод equas() возвращает true, если две строки равны и false, если они не равны. Метод сompareTo() возвращает 0, целое положительное число или целое отрицательное число, в зависимости от того равна, больше или меньше сравниваемая строка, по сравнению со второй строкой.

Класс String также имеет методы equalsIgnoreCase(), compareToIgnoreCase() и regionMatches() для сравнения строк.

Методы equalsIgnoreCase() и compareToIgnoreCase() игнорируют регистр букв при сравнении двух строк.

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

regionMatches(int index, String s1, int s1Index, int len)

здесь index - индекс начала подстроки данной строки, s1Index - индекс начала подстроки строки s1. Метод различает символы, записанные в разных регистрах. Если надо сравнивать подстроки без учета регистров букв, то используйте логический метод:

regionMatches(boolean ignoreCase, int index, String s1,int s1Index, int len)

Если первый параметр ignoreCase равен true, то регистр букв при сравнении подстрок не учитывается, если false - учитывается.

Способы применения методов сравнения строк приведены в коде примера .3.

Пример 3 Применение методов сравнения строк.

public class StringCompare

{

public static void main( String[] args )

{

String s1 = new String( "hello" );

String s2 = "goodbye";

String s3 = "Happy Birthday";

String s4 = "happy birthday";

System.out.printf("s1 = %s\n s2 = %s\n s3 = %s\n s4 =

%s\n\n", s1, s2, s3, s4 );

//тест для метода equals

if(s1.equals("hello"))

System.out.println( "s1 равна \"hello\"" );

else

System.out.println( "s1 не равна \"hello\"" );

// тест для операции сравнения ==

if (s1=="hello")

System.out.println( "s1 один и тот же объект,

что и \"hello\"" );

else

System.out.println( "s1 не один и тот же объект,

что и \"hello\"" );

// тест для метода equals (ignore case)

if(s3.equalsIgnoreCase(s4))

System.out.printf( "%s равна %s без учета регистра

букв\n", s3, s4 );

else

System.out.println( "s3 не равна s4" );

// тест compareTo

System.out.printf("\ns1.compareTo(s2)=%d",

s1.compareTo(s2));

System.out.printf("\ns2.compareTo(s1)=%d",

s2.compareTo(s1));

System.out.printf("\ns1.compareTo(s1)=%d",

s1.compareTo(s1));

System.out.printf("\ns3.compareTo(s4)=%d",

s3.compareTo(s4));

System.out.printf("\ns4.compareTo(s3)=%d\n\n",

s4.compareTo(s3));

// тест regionMatches

if(s3.regionMatches(0, s4, 0, 5))

System.out.println( "Первые 5 символов s3 и s4 равны");

else

System.out.println("Первые 5 символов s3 и s4 не равны");

// тест regionMatches (ignore case)

if(s3.regionMatches(true, 0, s4, 0, 5))

System.out.println("Первые 5 символов s3 и s4 равны

без учета регистра");

else

System.out.println("Первые 5 символов s3 и s4

не равны");

}}

Результат:

s1 = hello

s2 = goodbye

s3 = Happy Birthday

s4 = happy birthday

s1 равна "hello"

s1 не один и тот же объект, что и "hello"

Happy Birthday равна happy birthday без учета регистра букв

s1.compareTo(s2) = 1

s2.compareTo(s1) = -1

s1.compareTo(s1) = 0

s3.compareTo(s4) = -32

s4.compareTo(s3) = 32

Первые 5 символов s3 и s4 не равны

Первые 5 символов s3 и s4 равны без учета регистра

Для того чтобы проверить, не начинается ли данная строка с подстроки-префикса prefix, используйте логический метод startsWith(String prefix), возвращающий true, если строка начинается с данного префикса, или совпадает с ней, или префикс пуст.

Можно проверить и появление подстроки sub в данной строке, начиная с некоторого индекса ind логическим методом startsWith(String sub, int ind). Если индекс ind отрицателен или больше длины строки, возвращается false.

Для того чтобы проверить, не заканчивается ли данная строка суффиксом suffix, используйте логический метод endsWith(String suffix). Учтите, что он возвращает true, если суффикс suffix совпадает со всей строкой или суффикс suffix пуст.

Например, таким образом, if (fileName.endsWith(". java")), можно отследит имена файлов с исходными текстами Java. Другие варианты применения методов строк startsWith() и endsWith() приведены в коде примера 4.

Пример 4 Применение методов для сравнения строк startsWith() и endsWith().

public class StringStartEnd

{

public static void main( String[] args )

{

String[] strings = {"started","starting","ended","ending"};

// тест startsWith

for (String string : strings)

{

if(string.startsWith("st"))

System.out.printf("\"%s\" начинается с \"st\"\n", string);

}

System.out.println();

// тест startsWith с позиции 2

for (String string : strings)

{

if(string.startsWith("art", 2))

System.out.printf("\"%s\" начинается с \"art\" в позиции

2\n", string);

}

System.out.println();

// тест endsWith

for (String string : strings)

{

if(string.endsWith("ed"))

System.out.printf("\"%s\" заканчивается на \"ed\"\n",

string);

}

}}

Результат:

"started" начинается с "st"

"starting" начинается с "st"

"started" начинается с "art" в позиции 2

"starting" начинается с "art" в позиции 2

"started" заканчивается на "ed"

"ended" заканчивается на "ed"

1.1.4 Поиск символов и подстроки в строке

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

Таблица 7.2 - Методы класса String для поиска символов и подстроки в строке

Метод	Описание
int indexOf (char ch)	Возвращает индекс первого вхождения символа ch в строку или -1, если символ не найден
int indexOf (char ch, int fromIndex)	Возвращает индекс первого вхождения символа ch после индекса fromIndex в строку или -1, если символ не найден
int indexOf (String s)	Возвращает индекс первого вхождения подстроки s в строку или -1, если подстрока не найдена
int indexOf (String s, int fromIndex)	Возвращает индекс первого вхождения подстроки s в строку после индекса fromIndex или -1, если подстрока не найдена
int lastIndexOf (char ch)	Возвращает индекс последнего вхождения символа ch в строку или -1, если символ не найден
int lastIndexOf (char ch, int fromIndex)	Возвращает индекс последнего вхождения символа ch до индекса fromIndex в строку или -1, если символ не найден
int lastIndexOf (String s)	Возвращает индекс последнего вхождения подстроки s в строку или -1, если подстрока не найдена
int lastIndexOf (String s, int fromIndex)	Возвращает индекс последнего вхождения подстроки s в строку до индекса fromIndex или -1, если подстрока не найдена

Ниже приведены варианты применения методов из табл.7.2,

"Welcome to Java".indexOf('W') returns 0.

"Welcome to Java".indexOf('o') returns 4.

"Welcome to Java".indexOf('o', 5) returns 9.

"Welcome to Java".indexOf("come") returns 3.

"Welcome to Java".indexOf("Java", 5) returns 11.

"Welcome to Java".indexOf("java", 5) returns -1.

"Welcome to Java".lastIndexOf('W') returns 0.

"Welcome to Java".lastIndexOf('o') returns 9.

"Welcome to Java".lastIndexOf('o', 5) returns 4.

"Welcome to Java".lastIndexOf("come") returns 3.

"Welcome to Java".lastIndexOf("Java", 5) returns -1.

"Welcome to Java".lastIndexOf("Java") returns 11.

Другие варианты применения методов поиска символов и подстроки в строке представлены в коде примера.5.

Пример 5 Применение методов для поиска символов и подстроки в строке indexOf() и lastIndexOf().

public class StringIndexMethods

{

public static void main( String[] args )

{

String letters = "abcdefghijklmabcdefghijklm";

// тестирование indexOf для поиска симвoлов в строке

System.out.printf("'c' найден с индексом %d\n",

letters.indexOf('c'));

System.out.printf("'a' найден с индексом %d\n",

letters.indexOf('a',1));

System.out.printf("'$' найден с индексом %d\n\n",

letters.indexOf('$'));

// тестирование lastIndexOf для поиска символов в строке

System.out.printf("Последний 'c' найден с индексом %d\n",

letters.lastIndexOf('c'));

System.out.printf("Последний 'a' найден с индексом %d\n",

letters.lastIndexOf('a',25));

System.out.printf("Последний '$' найден с индексом

%d\n\n",letters.lastIndexOf('$'));

// тестирование indexOf для поиска подстроки в строке

System.out.printf("Подстрока \"def\" найдена с индекса

%d\n",letters.indexOf("def"));

System.out.printf("Подстрока \"def\" найдена с индекса

%d\n",letters.indexOf("def",7));

System.out.printf("Подстрока \"hello\" найдена с индекса

%d\n\n",letters.indexOf("hello"));

// тестирование lastIndexOf для поиска подстроки в строке

System.out.printf("Последняя подстрока \"def\" найдена с

индекса %d\n",letters.lastIndexOf("def"));

System.out.printf("Последняя подстрока \"def\" найдена с

индекса %d\n",letters.lastIndexOf("def",25));

System.out.printf("Последняя подстрока \"hello\" найдена с

индекса %d\n",letters.lastIndexOf("hello"));

}}

Результат:

'c' найден с индексом 2

'a' найден с индексом 13

'$' найден с индексом -1

Последний 'c' найден с индексом 15

Последний 'a' найден с индексом 13

Последний '$' найден с индексом -1

Подстрока "def" найдена с индекса 3

Подстрока "def" найдена с индекса 16

Подстрока "hello" найдена с индекса -1

Последняя подстрока "def" найдена с индекса 16

Последняя подстрока "def" найдена с индекса 16

Последняя подстрока "hello" найдена с индекса -1

Помните! Поиск всегда ведется с учетом регистра букв.

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

Для извлечения подстроки из строки в классе String имеются методы substring(), подробно описанные в табл.7.3.

Таблица 7.3 - Методы класса String для извлечения подстроки из строки

Метод	Описание
String substring (int beginIndex)	Возвращает подстроку из строки от индекса beginIndex включительно и до конца строки, как показано на рис. 7.3. Если индекс beginIndex отрицательный или больше длины строки, то возникает исключительная ситуация.
String substring (int beginIndex, int endIndex)	Возвращает подстроку из строки от символа с индексом beginIndex включительно до символа с индексом endIndex иключительно как показано на рис. 7.3. Длина подстроки будет равна endIndex - beginIndex. Если индексы отрицательны, индекс endIndex больше длины строки или beginIndex больше чем endIndex , то возникает исключительная ситуация.

Рассмотрим следующий пример:

String message = "Welcome to Java".substring(0, 11) + "HTML";

В результате message = "Welcome to HTML".

Рисунок 7.2 - Метод substring() выделяет подстроку из строки

Запомните! Если beginIndex = endIndex, то метод substring(beginIndex, endIndex) вернет пустую строку с длиной 0. Если beginIndex > endIndex, то это вызовет ошибки времени выполнения (runtime error).

Пример .6 Применение методов для извлечения подстроки из строки.

public class SubString

{

public static void main( String[] args )

{

String letters = "abcdefghijklmabcdefghijklm";

System.out.printf( "Подстрока от индекса 20 и до конца

строки \"%s\"\n", letters.substring(20));

System.out.printf( "%s \"%s\"\n", "Подстрока от индекса 3

включительно до индекса 6 исключительно",

letters.substring(3,6));

}}

Результат:

Подстрока от индекса 20 и до конца строки "hijklm"

Подстрока от индекса 3 включительно до индекса 6 исключительно "def"

1.1.6 Модификация, замена и разбиение строк

Методы класса String обеспечивающие модификацию, замену и разбиение строк приведены в табл.7.4.

Таблица 7.4 - Методы класса String для модификации, замены и разбиения строк

Метод	Описание
String toLowerCase ()	Возвращает новую строку, в которой все символы переведены в нижний регистр, т. е. сделаны строчными.
String toUpperCase ()	Возвращает новую строку, в которой все символы переведены в верхний регистр, т. е. сделаны прописными.
String trim()	Возвращает новую строку, в которой удалены все начальные и конечные символы с кодами, не превышающими '\u0020' (пробелы, управляющие символы…).
String replace (char oldChar, char newChar)	Возвращает новую строку, в которой все вхождения символа oldChar заменены символом newChar. Если символа oldChar в строке нет, то возвращается ссылка на исходную строку.
String replaceFirst (String oldString, String newString)	Возвращает новую строку, в которой первое вхождение подстроки oldString заменено подстрокой newString.
String replaceAll (String oldString, String newString)	Возвращает новую строку, в которой все вхождения подстроки oldString заменены подстрокой newString. Если подстроки oldString в строке нет, то возвращается ссылка на исходную строку
String[] split (String delimiter)	Возвращает массив строк, состоящий из лексем, полученных из исходной строки с учетом разделителя delimiter.

После того, как строка String создана, его содержание не может быть изменено. Методы toLowerCase(), toUpperCase(), trim(), replace(), replaceFirst() и replaceAll() возвращают новую строку, полученную из исходной строки (без изменения исходной строки!). Методы toLowerCase() и toUpperCase() возвращают новую строку путем преобразования всех символов в строке в строчные или прописные. Метод trim() возвращает новую строку путем устранения начальных и конечных символов пробела в исходной строке. Несколько вариантов методов replace() обеспечивают различные способы замены символа или подстроки в строке на новый символ или новую подстроку.

Результаты выполнения некоторых методов приведен в табл. 7.5.

Таблица 7.5 - Результат выполнения методов преобразования и замены строк

Метод	Возвращаемое значение
"Welcome". toLowerCase()	welcome
"Welcome". toUpperCase()	WELCOME
"\t Good Night \n". trim()	Good Night
"Welcome". replace('e', 'A')	WAlcomA
"Welcome". replaceFirst("e", "AB")	WABlcome
"Welcome". replace("e", "AB")	WABlcomAB
"Welcome". replace("el", "AB")	WABcome

Метод split() может быть использован для извлечения лексем из строки с учетом указанных разделителей. Как, например, в следующем коде:

String[] tokens = "Java#HTML#Perl".split("#");

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

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

На экране получим результат:

Java HTML Perl

1.1.7 Преобразование между строками и массивами

Строки - это не массивы, но строка может быть преобразована в массив, и наоборот. Чтобы преобразовать строку в массив символов, используют метод toCharArray(). Например, в следующем объявлении преобразуется строка "Java" в массив:

char[] chars = "Java".toCharArray();

Таким образом, символ chars[0] равен J, chars[1] равен a, chars[2] равен v, а chars[3] - это a.

Можно также использовать метод getChars (int srcBegin, int srcEnd, char[] dst, int dstBegin), чтобы скопировать из строки подстроку с индекса srcBegin до индекса srcEnd-1 в массив символов dst, начиная с индекса dstBegin. Например, следующий код копирует подстроку "3720" в "CS3720" с индекса 2 до индекса 6-1 в символьный массив dst, начиная с индекса 4.

char[] dst = {'J', 'A', 'V', 'A', '1', '3', '0', '1'};

"CS3720".getChars(2, 6, dst, 4);

В результате массив dst станет равным {'J', 'A', 'V', 'A', '3', '7', '2', '0'}

Для преобразования массива символов в строку, можно также использовать конструктор String(char []) или метод valueOf(сhar[]). Например, как в следующих примерах:

String str= new String(new char[]{'J', 'a', 'v', 'a'});

String str= String.valueOf(new char[]{'J', 'a', 'v', 'a'});

1.1.8 Преобразование символов и чисел в строки

Статический метод valueOf() может быть использован для преобразования массива символов в строку. Имеется несколько перегруженных вариантов метода valueOf() с параметрами различных типов: char, double, long, int и float, которые могут быть использованы для преобразования символов и числовых значений в строки, как это показано в табл.7.6.

Таблица 7.6 - Перегруженные варианты метода valueOf()

Метод	Описание
String valueOf (char c)	Возвращает строку, состоящую из символа с.
String valueOf (char[] data)	Возвращает строку, состоящую из символов массива data.
String valueOf (double d)	Преобразует значение типа double в строку Stgring.
String valueOf (float f)	Преобразует значение типа float в строку Stgring.
String valueOf (int i)	Преобразует значение типа int в строку Stgring.
String valueOf (long l)	Преобразует значение типа long в строку Stgring.
String valueOf (boolean b)	Преобразует значение типа boolean в строку Stgring.

На заметку! Вы можете использовать методы Double.parseDouble(str) или Integer.parseInt(str), чтобы преобразовать строку в значения типа double или int. Dоuble и Integer - это два класса, расположенные в пакете java.lang.

Пример 7.7 Применение методов для преобразования символов и чисел в строки.

ublic class StringValueOf

{

public static void main( String[] args )

{

char[] charArray = { 'a', 'b', 'c', 'd', 'e', 'f' };

boolean booleanValue = true;

char characterValue = 'Z';

int integerValue = 7;

long longValue = 10_000_000_000L;

float floatValue = 2.5f;

double doubleValue = 33.333;

Object objectRef = "hello";

System.out.printf("char array=%s\n",

String.valueOf(charArray));

System.out.printf( "part of char array = %s\n",

String.valueOf(charArray,3,3) );

System.out.printf("boolean=%s\n",

String.valueOf(booleanValue));

System.out.printf("char=%s\n",

String.valueOf(characterValue));

System.out.printf("int=%s\n",

String.valueOf(integerValue));

System.out.printf("long=%s\n",

String.valueOf(longValue));

System.out.printf("float=%s\n",

String.valueOf(floatValue));

System.out.printf("double=%s\n",

String.valueOf(doubleValue));

System.out.printf("Object=%s",

String.valueOf(objectRef));

}}

Результат:

char array=abcdef

part of char array = def

boolean=true

char=Z

int=7

long=10000000000

float=2.5

double=33.333

Object=hello

1.2 Классы StringBuilder и StringBuffer

Классы StringBuilder и StringBuffer аналогичны классу String за исключением того, что класс String представляет неизменяемые последовательности символов постоянной длины, а классы StringBuilder и StringBuffer представляют расширяемые и доступные для изменений последовательности символов. Классы StringBuilder и StringBuffer являются более гибкими, чем String. Они позволяют добавлять, вставлять символы и подстроки в средину либо добавлять их в конец строки, в то время как длина объекта String фиксируется при создании.

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

1.2.1 Конструкторы класса StringBuilder

Класс StringBuilder имеет три конструктора и более 30 методов для создания и изменения строк. Конструкторы класса StringBuilder приведены в табл. 7.7.

Создать объект класса StringBuilder можно только конструкторами. Первоначально созданный объект имеет буфер определенной емкости (capacity), по умолчанию достаточной для хранения 16 символов. Емкость можно задать в конструкторе объекта.

Как только буфер начинает переполняться, его емкость автоматически увеличивается, чтобы вместить новые символы.

В любое время емкость буфера можно увеличить, обратившись к методу ensureCapacity(int minCapacity).

Этот метод изменит емкость, только если minCapacity будет больше длины хранящейся в объекте строки. Емкость будет увеличена по следующему правилу. Пусть емкость буфера равна N. Тогда новая емкость будет равна Мах(2 * N + 2, minCapacity).

Таким образом, емкость буфера нельзя увеличить менее чем вдвое.

Количество символов в строке можно узнать, как и для объекта класса String, методом length(), а емкость -- методом capacity().

Таблица 7.7 - Конструкторы класса java.lang.StringBuilder

Конструктор	Описание
StringBuilder()	Создает пустую строку емкостью, равной 16 символов
StringBuilder(int capacity)	Создает строку с указанной емкостью capacity.
StringBuilder(String s)	Создает строку емкостью s.length () + 16, содержащую строку s.

Методом setLength (int newLength) можно установить любую длину строки.

Если она окажется больше текущей длины, то дополнительные символы будут равны '\u0000' . Если она будет меньше текущей длины, то строка будет обрезана, последние символы потеряются, точнее, будут заменены символом '\u0000' . Емкость при этом не изменится.

Если число newLength окажется отрицательным, возникнет исключительная ситуация.

Дополнительные методы класса StringBuilder для изменения и получения свойств строки приведены в табл.7.8.

Таблица 7.8 - Методы класса java.lang.StringBuilder для изменения и получения свойств строки

Метод	Описание
String toString ()	Возвращает строку, представляющую данные в этой последовательности
int capacity ()	Возвращает емкость строки
char charAt (int index)	Возвращает символ с указанным индексом
int length ()	Возвращает количество символов в строке
void setLength (int newLength)	Устанавливает новую длину строки
void ensureCapacity(int minCapacity)	Устанавливает емкость и при этом гарантирует, что емкость, по крайней мере, равна указанному минимуму
String substring(int startIndex)	Возвращает подстроку, начиная с индекса startIndex
String substring (int startIndex, int endIndex)	Возвращает подстроку с индекса startIndex до индекса endIndex-1
void setCharAt (int index, char ch)	Символ c указанным индексом index, устанавливается в ch.
void trimToSize()	Уменьшает емкость до фактического размера строки

В коде примера 7.8 демонстрируется применение отдельных методов из табл. 7.8.

Пример 7.8 Применение методов length(), capacity(), setLength() и ensureCapacity()

Объяснение: начальная емкость строки "Hello, how are you?" равна 35, а длина равна 19. Емкость строки получена в результате сложения длины строки +16. Далее в программе емкость строки увеличена до 75. Помните, что динамическое расширение емкости StringBuilder может занять довольно длительное время. Выполнение большого количества этих операций может привести к снижению производительности приложения. В программе также используется метод setLength(), который усекает длину StringBuilder до 10. Если заданная длина меньше, чем текущее количество символов в StringBuilder, то буфер усекается до заданной длины (например, лишние символы отбрасываются). Если указанная длина больше, чем текущее число символов, то добавляются нулевые символы (символы с числовым представлением 0) до тех пор, пока общее количество символов в StringBuilder не станет равна указанной длине.

public class StringBuilderCapLen

{

public static void main( String[] args )

{

StringBuilder buffer =

new StringBuilder("Hello, how are you?");

System.out.printf("buffer=%s\nlength=%d\ncapacity=%d\n\n",

buffer.toString(), buffer.length(),buffer.capacity());

buffer.ensureCapacity(75);

System.out.printf("New capacity=%d\n\n",

buffer.capacity());

buffer.setLength(10);

System.out.printf( "New length = %d\nbuffer = %s\n",

buffer.length(), buffer.toString() );

}

}

Результат:

buffer = Hello, how are you?

length = 19

capacity = 35

New capacity = 75

New length = 10

buffer = Hello,

1.2.2 Добавление, удаление и замена подстроки

В классе StringBuilder есть десять методов append(), добавляющих подстроку в конец строки (см. табл. 7.9). Они не создают новый экземпляр строки, а возвращают ссылку на ту же самую, но измененную строку.

Основной метод append (String s) присоединяет строку s в конец данной строки. Если ссылка s == null, то добавляется строка "null".

Шесть методов append (aPrimitiveType value) добавляют примитивные типы boolean, char, int, long, float, double, преобразованные в строку.

Два метода присоединяют к строке массив и подмассив символов data, преобразованные в строку: append (char [] data) и append (char [] data, int offset, int len). ввод конструктор строка текстовый

Десятый метод добавляет просто объект append (Object obj). Перед этим объект obj преобразуется в строку своим методом toString().

На самом деле, компилятор может использовать методы добавления класса StringBuilder (или StringBuffer) выполняя + и += операторы конкатенации строк. Так, например, в следующем коде

String string1 = "hello";

String string2 = "BC";

int value = 22;

String s = string1 + string2 + value; конкатенируются "hello", "BC" и 22. Компилятор выполнит компиляцию следующим образом:

String s = new StringBuilder().append( "hello" ).append( "BC" ).append( 22 ).toString();

Будет создана пустая строка StringBuilder, затем к ней будут добавлены строки "hello", "BC" и 22. Затем с помощью метода toString() класса StringBuilder строка будет преобразована в объект String и связана с ссылкой String s.

Соответственно оператор s+="!"; может быть выполнен следующим образом:

s=new StringBuilder().append(s).append("!").toString();

Таблица 7.9 - Методы класса java.lang.StringBuilder для изменения содержания строки

Метод	Описание
StringBuilder append(char[] data)	Добавляет массив символов data в конец строки
StringBuilder append(char[] data, int offset, int len)	Добавляет подмассив data в конец строки
StringBuilder append(aPrimitiveType value)	Добавляет значение примитивного типа value, преобразованное в строку
StringBuilder append(String s)	Добавляет строку s в конец текущей строки.
StringBuilder insert(int index, char[] data, int offset, int len)	Вставляет подмассив data в строку перед указанным индексом index
StringBuilder insert(int offset, char[] data)	Вставляет массив символов data в строку перед указанным индексом index
StringBuilder insert(int offset, aPrimitiveType value)	Вставляет в строку перед указанным индексом offset значение примитивного типа, преобразованное в строку
StringBuilder insert(int offset, String s)	Вставляет строку s в текущую строку перед указанным индексом offset
StringBuilder delete (int startIndex, int endIndex)	Удаляет символы с индекса startIndex включительно до endIndex исключительно
StringBuilder deleteCharAt(int index)	Удаляет символ с указанным индексом index.
StringBuilder replace (int startIndex, int endIndex, String s)	Заменяет символы в строке с индекса startIndex до индекса endIndex-1 на указанную строку s.
StringBuilder reverse()	Меняет порядок расположения символов в строке на обратный

Десять методов insert() предназначены для вставки строки, указанной параметром метода, в данную строку. Место вставки задается первым параметром offset. Это индекс элемента строки, перед которым будет сделана вставка. Он должен быть неотрицательным и меньше длины строки, иначе возникнет исключительная ситуация. Строка раздвигается, емкость буфера при необходимости увеличивается. Методы возвращают ссылку на ту же преобразованную строку.

Основной метод insert (int offset, String s) вставляет строку s в данную строку перед ее символом с индексом offset. Если ссылка s == null вставляется строка "null".

Например, после выполнения

String s = new StringBuffer("Это большая строка"). insert(4, "не").toString();

получим: s = "Это небольшая строка".

Шесть методов insert(int offset, aPrimitiveType value) вставляют примитивные типы boolean, char, int, long, float, double, преобразованные в строку.

Два метода вставляют массив и подмассив символов data, преобразованные в строку:

insert(int offset, char[] data)

insert(int index, char[] data, int offset, int len)

Десятый метод вставляет просто объект:

insert(int offset, Object obj)

Объект obj перед добавлением преобразуется в строку своим методом

toString().

Метод delete (int startIndex, int endIndex) удаляет из строки символы, начиная с индекса startIndex включительно до индекса endIndex исключительно, если endIndex больше длины строки, то до конца строки.

Например, после выполнения

String s = new StringBuffer("Это небольшая строка"). delete(4, 6).toString();

получим s = "Это большая строка".

Если startIndex отрицательный, больше длины строки или больше endIndex, возникает исключительная ситуация. Если startIndex == endIndex , удаление не происходит.

Метод deleteCharAt (int index) удаляет символ с указанным индексом index. Длина строки уменьшается на единицу. Если индекс index отрицателен или больше длины строки, возникает исключительная ситуация.

Метод replace(int startIndex, int endIndex, String s) удаляет символы из строки, начиная с индекса startIndex включительно до индекса endIndex исключительно, если endIndex больше длины строки, то до конца строки, и вставляет вместо них строку s.

Если startIndex отрицательный, больше длины строки или больше endIndex, возникает исключительная ситуация. Метод replace()- это последовательное выполнение методов delete() и insert().

Метод reverse() меняет порядок расположения символов в строке на обратный.

Например, после выполнения

String s = new StringBuffer("Это небольшая строка"), reverse().toString();

получим s = "акортс яашьлобен отЭ".

1.3 Класс Character

Как вам уже известно, из предыдущих глав, в Java имеются восемь примитивных типов: boolean, byte, short, int, long, char, float и double. Эти типы данных не являются частью объектной иерархии и используются из соображений производительности. Они передаются по значению в методы и не могут быть переданы по ссылке. Рано или поздно возникнет необходимость в объектном представлении одного из примитивных типов.

Чтобы сохранить примитивный тип в одном из этих классов, необходимо поместить его в оболочку класса. Чтобы удовлетворить эту потребность, язык Java предлагает классы, которые соответствуют каждому примитивному типу: Boolean, Character, Double, Float, Byte, Short, Integer и Long. По сути, эти классы инкапсулируют примитивные типы в классы (или, что то же самое, помещают примитивные типы в оболочки классов). Все эти классы-оболочки находятся в пакете java.lang, и содержат полезные методы обработки примитивных значений. В данном разделе рассмотрим класс Character.

Класс Character - это простая оболочка для типа char. Класс имеет один конструктор и несколько методов, описанных в табл. 7.10. Объект Character можно создать из символа, например:

Character character = new Character('a');

Здесь символ 'a' будет помещен в оболочку создаваемого объекта класса Character.

Таблица 7.10 - Конструктор и методы класса java.lang.Character

Метод	Описание
Character (char value)	Конструктор объекта Character с параметром - символьным значением
char charValue()	Возвращает символ, содержащийся в объекте класса Character
int compareTo(Character anotherCharacter)	Возвращает нуль, если вызывающий объект и anotherCharacter эквивалентны, и отрицательное значение - если вызывающий объект содержит меньшее значение. В противном случае возвращает положительное значение.
boolean equals(Character anotherCharacter)	Возвращает true, если вызывающий объект и anotherCharacter эквивалентны, и false в противном случае.
boolean isDefined(char сh)	Возвращает значение true, если символ сh определен в Unicode. В противном случае возвращает значение false
boolean isDigit(char ch)	Возвращает значение true, если символ ch является десятичной цифрой. В противном случае возвращает значение false
boolean isJavaIdentifierPart(char ch )	Возвращает значение true, если символ ch может быть частью идентификатора Java. В противном случае возвращает значение false
boolean isJavaIdentifierStart(char ch )	Возвращает значение true, если символ ch может быть первым символом идентификатора Java. В противном случае возвращает значение false
boolean isLetter(char ch)	Возвращает значение true, если символ ch - буква. В противном случае возвращает значение false
boolean isLetterOrDigit(char ch)	Возвращает значение true, если символ ch - буква или цифра. В противном случае воз­ вращает значение false
boolean isLowerCase(char ch)	Возвращает значение true, если символ ch - буква в нижнем регистре. В противном слу­ чае возвращает значение false
boolean isUpperCase(char ch)	Возвращает значение true, если символ ch - символ верхнего регистра. В противном случае возвращает значение false
char toLowerCase(char ch)	Возвращает эквивалент символа ch в нижнем регистре
char toUpperCase(char ch)	Возвращает эквивалент символа ch в верхнем регистре

Задача 1.2. Напишите программу, которая предлагает пользователю ввести строку и подсчитывает количество вхождений каждой буквы независимо от регистра.

Объяснение: запишем алгоритм решения задачи:

1. Конвертировать все прописные буквы в строке в строчные помощью метода toLowerCase() класса String.

2. Создадим массив counts[] состоящий из 33 целых значений, каждое из которых будет соответствовать количеству вхождений букв алфавита. То есть, counts[0] - количество вхождений буквы 'а', counts[1] - количество вхождений буквы 'б' и так далее.

3. Для каждого символа в строке, проверяем, является ли он строчной буквой. Если да, то увеличиваем на единицу соответствующее количество в массиве counts[].

В главном методе вводится строка и подсчитывается количество вхождений каждой буквы путем вызова метода countLetters(). Поскольку регистр букв по условию задачи игнорируется, в программе используется метод toLowerCase() для преобразования строки в нижний регистр. Далее уже эта новая строка передается в метод countLetters(), который возвращает массив из 33 элементов. Каждый элемент - это количество вхождений буквы в строку s. Метод проверяет каждый символ строке. Если символ является буквой, то соответствующий счетчик увеличивается на 1. Например, если символ s.charAt(i) является символом 'а', то соответствующий ему элемент массива counts['а' - 'а'] (т.е. counts[0]). Для символа 'б' - counts['б' - 'а'] (т.е. counts[1]), так как в кодировке Unicode код символа 'б' на 1 больше, чем 'а'. Для символа 'я', соответствующий ему элемент массива counts['я' - 'а'] (т.е. counts [32]), так как в Unicode 'я' на 32 больше, чем 'а'.

import java.util.Scanner;

public class CountEachLetter {

public static void main(String[] args) {

Scanner input = new Scanner(System.in, "UTF-8");

System.out.print("Введите строку: ");

String s = input.nextLine();

int[] counts = countLetters(s.toLowerCase());

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

if (counts[i] != 0)

System.out.println((char)('а' + i) + " встречается " + counts[i] + " раз");

}

}

public static int[] countLetters(String s) {

int[] counts = new int[33];

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

if(Character.isLetter(s.charAt(i)))

counts[s.charAt(i) - 'а']++;

}

return counts;

}

}

Результат:

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

а встречается 2 раз

в встречается 1 раз

г встречается 1 раз

е встречается 2 раз

з встречается 1 раз

и встречается 1 раз

л встречается 2 раз

м встречается 2 раз

н встречается 2 раз

о встречается 2 раз

п встречается 2 раз

р встречается 3 раз

т встречается 2 раз

у встречается 1 раз

ы встречается 2 раз

ь встречается 1 раз

я встречается 1 раз

1.3 Аргументы командной строки

Главный метод main() может принимать строковые аргументы из командной строки. Конечно, вы уже заметили в заголовке главного метода параметр args типа String[], являющийся массивом строк. Метод main() похож на обычный метод с параметром, при вызове которого вы можете передать аргументы из командной строки и использовать их как обычный массив в теле метода. Например, так как в следующем коде:

public class TestMain {

public static void main (String[] args)

{

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

System.out.println(args[i]);

}

}

Передать строки в главный метод можно из командной строки при запуске программы. Например, следующая командная строка запускает программу TestMain с тремя строками: arg0, arg1 и arg2:

Java TestMain arg0 arg1 arg2

arg0, arg1 и arg2 являются строками, но они могут не заключаться в двойные кавычки, однако должны быть разделены пробелом. Если строка содержит пробелы, то ее следует обязательно заключить в двойные кавычки. Рассмотрим следующую команду:

Java TestMain "First num" alpha 53

Программа запускается с тремя аргументами-строками: First num, alpha и 53. Строка First num заключена в двойные кавычки. Обратите внимание, что на самом деле 53 обрабатывается как строка. Вы можете записывать "53" вместо 53 в командной строке.

Если вы работаете в IDE BlueJ, то аргументы командной строки передаются при вызове главного метода в окне, вид которого изображен на рис.7.3. Причем аргументы должны быть заключены в двойные кавычки и разделены запятыми.

Когда главный метод вызывается, интерпретатор Java создает массив для хранения аргументов командной строки и передает ссылку на массив args.

Рисунок 7.3 - Передача аргументов командной строки в IDE BlueJ

Если вы запускаете программу без каких-либо аргументов, создается пустой массив строк args[] с нулевой длиной.

1.4 Синтаксический разбор строки

Задача разбора введенного текста - парсинг (parsing) - вечная задача программирования, наряду с сортировкой и поиском. Написана масса программ-парсеров (parser), разбирающих текст по различным признакам. Есть даже программы, генерирующие парсеры по заданным правилам разбора: YACC, LEX и др. Но задача остается актуальной. Рассмотрим, какие средства предоставляет программистам Java для разбора строк на отдельные лексемы.

1.4.1 Метод split() класса String

В разделе 7.1.6 текущей главы был рассмотрен метод split(String delimiter) класса String, который возвращает массив строк, состоящий из лексем, полученных из исходной строки с учетом разделителя delimiter. Рассмотрим пример использования данного метода для разбора строки.