Как добавить строку в массив java

Добавление новых элементов в массив в Java

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

String[] words; words.append("Hello"); words.append("World");

В этом примере разработчик пытается добавить два новых элемента «Hello» и «World» в массив строк words . Однако, этот код не будет скомпилирован, потому что массивы в Java имеют фиксированный размер и не предоставляют метода append .

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

Приведем пример использования ArrayList для решения проблемы добавления новых элементов:

ArrayList<String> words = new ArrayList<String>(); words.add("Hello"); words.add("World");

Теперь код будет успешно скомпилирован и выполнен. В результате, в список words будут добавлены два новых элемента «Hello» и «World».

Важно отметить, что ArrayList предоставляет множество других удобных методов для работы со списком, таких как remove , get , set и другие, что делает его более предпочтительным выбором для многих задач, чем обычные массивы.

Как добавить строку в массив java

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

Посмотрим на это в коде (рекомендую, для наглядности, сразу вводить построчно код в jshell ):

// объявим массив размером 10, который умеет хранить строки String[] arrayWithStrings = new String[10]; // запишем в самую начальную ячейку некую строку arrayWithStrings[0] = "Some very important string."; 

Последнюю строку можно расшифровать так: в ячейку №0 массива arrayWithStrings присвоить (записать) результат вычисления выражения справа от = . Поскольку справа от = у нас уже готовый объект класса String , то в ячейку записывается не сам объект, а ссылка на него. Сам объект находиться в памяти JVM.

Если в jshell ввести имя ссылки на массив arrayWithStrings и нажать Enter, то мы увидим следующее: arrayWithStrings ==> String[10] < "Some very important string.", null, null, null, null, null, null, null, null, null >.

По аналогии можно заполнить все оставшиеся 9 ячеек массива.

И помните: размер массива считается от 1 до n, а нумерация ячеек считается от 0 до n-1!

Кофе-брейк #241. Как преобразовать строки в массивы — подробное руководство

Источник: FreeCodeCamp Благодаря этому руководству вы узнаете, как преобразовать строку в массив. Владение этим навыком пригодится вам при разработке приложений для обработки текста или работе с данными. Строка в Java — это группа символов, тогда как массив — это набор элементов одного типа. Вы можете разбить строку на части, используя процесс преобразования, а затем сохранить эти части в массиве для дальнейшей обработки или анализа. Существуют различные методы Java для преобразования строк в массивы. Их знание позволит вам выбрать тот, который лучше всего соответствует вашим требованиям к программированию.

Как преобразовать строку в массив с помощью метода toCharArray()

Метод toCharArray() представляет собой встроенную функцию Java, которая позволяет преобразовать строку в массив символов, и каждый символ строки в элемент массива. Этот метод доступен в классе String .

Синтаксис и использование метода toCharArray():

 public class StringToArrayExample < public static void main(String[] args) < String str = "Hello, World!"; // Преобразовать строку в массив символов char[] charArray = str.toCharArray(); // Распечатать элементы массива for (char c : charArray) < System.out.println(c); >> > 

Объяснение порядка действий:

1. Объявите строковую переменную str и присвойте ей нужную строку.
2. Используйте метод toCharArray() для строки str , чтобы преобразовать ее в массив символов. Этот метод разбивает строку на отдельные символы и возвращает массив, содержащий эти символы.
3. Сохраните полученный массив символов в переменной charArray .
4. Выполните итерацию charArray , используя цикл for-each для печати каждого символа по отдельности.

H e l l o , W o r l d !

Плюсы использования toCharArray():

• Простота: Метод toCharArray() обеспечивает простой способ преобразования строки в массив символов всего одним вызовом метода.
• Удобочитаемость: результирующий массив символов можно легко изменять, обрабатывать или повторять с помощью циклов.
• Неизменяемые строки: Поскольку строки в Java неизменяемы, преобразование их в массив символов может быть полезно, когда вам нужно изменить отдельные символы.

Минусы использования toCharArray():

• Увеличенная нагрузка на память: Метод toCharArray() создает новый массив символов, который требует дополнительной памяти. Это может стать проблемой, если вы работаете с большими строками.
• Производительность: Создание нового массива символов и копирование символов может привести к некоторому снижению производительности по сравнению с другими методами, особенно для длинных строк.

Как разделить строку с помощью метода split()

Метод split() в Java — это удобный способ разделить строку на массив подстрок на основе заданного разделителя. Этот метод доступен в классе String .

Синтаксис и использование метода split():

 String[] split(String delimiter) 

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

 string = "Hello,World,How,Are,You?" delimiter = "," split_string = string.split(delimiter) print(split_string) 

Объяснение порядка действий:

1. Мы определяем строковую переменную с именем string . Она содержит текст, который мы хотим разделить: “Hello, World, How, Are, You?”.
2. Мы указываем разделитель в виде запятой ( , ), который мы хотим использовать для разделения строки, и присваиваем его переменной delimiter .
3. Затем мы используем метод split() для переменной string , передавая в качестве аргумента delimiter . Это разбивает строку на подстроки везде, где находится delimiter .
4. Метод split() возвращает список подстрок, которые мы присваиваем переменной split_string .
5. Наконец, мы печатаем список split_string , чтобы увидеть результат.

[‘Hello’, ‘World’, ‘How’, ‘Are’, ‘You?’]

Плюсы использования split():

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

Минусы использования split():

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

Как преобразовать строку в массив с помощью StringTokenizer

Класс StringTokenizer в Java — это устаревший класс, предоставляющий удобный способ разметки или разделения строки на отдельные токены. Он обычно используется для преобразования строки в массив путем ее разделения на основе указанного разделителя.

Синтаксис и использование StringTokenizer:

Чтобы использовать StringTokenizer , вам сначала необходимо создать экземпляр класса StringTokenizer , передав строку и разделитель в качестве параметров:

 StringTokenizer tokenizer = new StringTokenizer(inputString, delimiter); 

Пример кода:

 import java.util.StringTokenizer; public class StringToArrayExample < public static void main(String[] args) < String inputString = "Hello,World,How,Are,You?"; // Создание объекта StringTokenizer с разделителем "," StringTokenizer tokenizer = new StringTokenizer(inputString, ","); int tokenCount = tokenizer.countTokens(); String[] stringArray = new String[tokenCount]; // Преобразование каждого токена в элементы массива for (int i = 0; i < tokenCount; i++) < stringArray[i] = tokenizer.nextToken(); >// Печать выходного массива for (String element : stringArray) < System.out.println(element); >> > 

Объяснение порядка действий:

1. Код начинается с создания объекта StringTokenizer под именем tokenizer из входной строки и разделителем «,» .
2. Метод countTokens() используется для получения общего количества токенов, присутствующих во входной строке. Это значение хранится в переменной tokenCount .
3. Вызываемый массив stringArray создается с размером, равным tokenCount .
4. Метод nextToken() используется в цикле для перебора каждого токена и присвоения ему соответствующего индекса в stringArray .
5. Наконец, цикл for используется для печати каждого элемента в файле stringArray .

Hello World How Are You?

Приложения StringTokenizer

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

Плюсы использования StringTokenizer:

• Простота: синтаксис StringTokenizer прост и понятен, что делает его доступным для начинающих.
• Эффективность: StringTokenizer эффективен с точки зрения памяти и производительности по сравнению с регулярными выражениями или ручным разделением на основе символов.
• Гибкие разделители: вы можете указать несколько разделителей или использовать предопределенный набор разделителей, что обеспечивает универсальную токенизацию.
• Итеративная обработка: StringTokenizer позволяет итеративно обрабатывать токены, что делает его удобным для обработки больших строк без загрузки всего сразу в память.

Минусы использования StringTokenizer:

• Ограниченная функциональность: в StringTokenizer отсутствуют некоторые расширенные функции, имеющиеся в современных альтернативах, такие как регулярные выражения, которые обеспечивают большую гибкость при токенизации сложных шаблонов.
• Нет поддержки регулярных выражений: в отличие от других методов, таких как метод split() , StringTokenizer не может использовать регулярные выражения в качестве разделителей, что ограничивает его возможности токенизации.
• Нет поддержки пустых токенов: StringTokenizer по умолчанию не обрабатывает пустые токены. Если у вас есть последовательные разделители, они обрабатываются как один разделитель, что может привести к неожиданным результатам.
• Устаревший класс: StringTokenizer является частью устаревшей платформы коллекций Java и не реализует интерфейс Iterable , что означает, что его нельзя использовать в расширенных циклах for .

Как вручную преобразовать каждый символ строки в элемент массива

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

 string = "Hello, World!" array = [] for char in string: array.append(char) print(array) 

Объяснение порядка действий:

1. Мы определяем строковую переменную string со значением «Hello, World!» .
2. Мы инициализируем пустой список с именем array .
3. Мы используем цикл for для перебора каждого символа char в string .
4. Внутри цикла мы используем метод append() для добавления каждого символа char в array .
5. После завершения цикла мы печатаем array , чтобы увидеть результат.

[‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ‘,’, ‘ ‘, ‘W’, ‘o’, ‘r’, ‘l’, ‘d’, ‘!’]

Плюсы ручного преобразования:

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

Минусы ручного преобразования:

• Требует больше кода и ручной обработки по сравнению со встроенными методами, такими как toCharArray() или split() .
• Может быть менее эффективным для больших строк из-за ручного процесса итерации.
• Увеличивает риск ошибок при неправильной реализации.

Сравнение различных методов

toCharArray():

• Простой и понятный метод.
• Возвращает массив символов, представляющий строку.
• Подходит для общих преобразований без особых требований.

split():

• Разбивает строку на массив на основе указанного разделителя.
• Полезен, если нужно разделить строку на подстроки.
• Обеспечивает гибкость в выборе шаблона разделителя.

StringTokenizer:

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

Ручное преобразование:

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

Зачем вам знать, как преобразовать строку в массив в Java?

• Манипуляции с данными. Массивы обеспечивают структурированный способ хранения данных и управления ими в Java. Преобразовывая строку в массив, вы можете получить доступ к отдельным символам или подстрокам, изменить данные и выполнить различные операции, такие как сортировка, поиск или фильтрацию.
• Алгоритмические операции. Многие алгоритмы и структуры данных в Java требуют ввода данных в виде массивов. Преобразовывая строку в массив, вы можете легко применять эти алгоритмы и выполнять такие операции, как сортировка, реверсирование или извлечение определенных элементов.
• Разбор и анализ текста. Строки часто содержат структурированные данные или данные с разделителями, такие как CSV (значения, разделенные запятыми) или JSON (нотация объектов JavaScript). Преобразование строки в массив позволяет разбивать и анализировать данные, обеспечивая дальнейший анализ, обработку или извлечение определенной информации.
• Манипуляции со строками. В то время как строки имеют собственный набор методов для манипуляций, массивы предлагают дополнительную гибкость. Преобразование строки в массив позволяет использовать специфичные для массива операции, такие как индексирование, нарезка или объединение, для более эффективного управления данными или выполнения определенных требований к форматированию.
• Совместимость: в некоторых сценариях вам может потребоваться преобразовать строку в массив для взаимодействия с библиотеками или API, которые ожидают ввода на основе массива. Выполняя преобразование, вы можете легко интегрировать свои строковые данные с внешними компонентами, обеспечивая совместимость и обеспечивая беспрепятственный обмен данными.

Заключение

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

Работа со строками

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

Внимание

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

Конструкторы

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

String s = new String():

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

char chars[] = < 'а', 'b', 'с' >: String s = new String(chars); System.out.println(s):

Этот фрагмент кода выводит строку . Итак, у этого конструктора — 3 параметра:

String(char chars[], int начальныйИндекс, int числоСимволов);

Используем такой способ инициализации в нашем очередном примере:

char chars[] = < 'a', 'b', 'с', 'd', 'e', 'f' >: String s = new String(chars,2,3); System.out.println(s);

Этот фрагмент выведет: cde.

Специальный синтаксис для работы со строками

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

Создание строк

Java включает в себя стандартное сокращение для этой опера-ции — запись в виде литерала, в которой содержимое строки заключа-ется в пару двойных кавычек. Приводимый ниже фрагмент кода экви-валентен одному из предыдущих, в котором строка инициализировалась массивом типа char.

String s = "abc"; System.out.println(s);

Один из общих методов, используемых с объектами String — метод length, возвращающий число символов в строке. Очередной фрагмент вы-водит число 3, поскольку в используемой в нем строке — 3 символа.

String s = "abc"; System.out.println(s.length);

В Java интересно то, что для каждой строки-литерала создается свой представитель класса String, так что вы можете вызывать методы этого класса непосредственно со строками-литералами, а не только со ссылоч-ными переменными. Очередной пример также выводит число 3.

System.out.println("abc".Length());

Слияние строк

Строку String s = + age + » years old.»; в которой с помощью оператора + три строки объединяются в одну, про-честь и понять безусловно легче, чем ее эквивалент, записанный с яв-ными вызовами тех самых методов, которые неявно были использованы в первом примере:

String s = new StringBuffer("He is ").append(age); s.append(" years old.").toString();

По определению каждый объект класса String не может изменять-ся. Нельзя ни вставить новые символы в уже существующую строку, ни поменять в ней одни символы на другие. И добавить одну строку в конец другой тоже нельзя. Поэтому транслятор Java преобразует опера-ции, выглядящие, как модификация объектов String, в операции с род-ственным классом StringBuffer.

Замечание

Все это может показаться вам необоснованно сложным. А почему нельзя обойтись одним классом String, позволив ему вести себя при-мерно так же, как StringBuffer? Все дело в производительности. Тот факт, что объекты типа String в Java неизменны, позволяет транслято-ру применять к операциям с ними различные способы оптимизации.

Последовательность выполнения операторов

Давайте еще раз обратимся к нашему последнему примеру:

String s = "Не is " + age + " years old.";

В том случае, когда age — не String, а переменная, скажем, типа int, в этой строке кода заключено еще больше магии транслятора. Целое значение переменной int передается совмещенному методу append класса StringBuffer, который преобразует его в текстовый вид и добавляет в конец содержащейся в объекте строки. Вам нужно быть вниматель-ным при совместном использовании целых выражений и слияния строк, в противном случае результат может получиться совсем не тот, который вы ждали. Взгляните на следующую строку:

String s = "four: " + 2 + 2;

Быть может, вы надеетесь, что в s будет записана строка ? Не угадали — с вами сыграла злую шутку последовательность выпол-нения операторов. Так что в результате получа-ется «four: 22».

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

String s = "four: " + (2 + 2);

Преобразование строк

В каждом классе String есть метод toString — либо своя собственная реализация, либо вариант по умолчанию, наследуемый от класса Object. Класс в нашем очередном примере замещает наследуемый метод toStrring своим собственным, что позволяет ему выводить значения переменных объекта.

class Point < int х, у; Point(int x, int у) < this.x = х; this.у = у; >public String toString() < return "Point[" + x + ", " + у + "]"; >> class toStringDemo < public static void main(String args[]) < Point p = new Point(10, 20); System.out.println("p This is a demo of the getChars method."; int start = 10; int end = 14; char buf[] = new char[end - start]; s.getChars(start, end, buf, 0); System.out.println(buf); >>

Обратите внимание — метод getChars не включает в выходной буфер символ с индексом end. Это хорошо видно из вывода нашего примера — выводимая строка состоит из 4 символов.

С:\> java getCharsDemo demo

Для удобства работы в String есть еще одна функция — toCharArray, которая возвращает в выходном массиве типа char всю строку. Альтернативная форма того же самого механизма позволяет записать содержимое строки в массив типа byte, при этом значения старших бай-тов в 16-битных символах отбрасываются. Соответствующий метод на-зывается getBytes, и его параметры имеют тот же смысл, что и пара-метры getChars, но с единственной разницей — в качестве третьего параметра надо использовать массив типа byte.

Сравнение

Если вы хотите узнать, одинаковы ли две строки, вам следует воспользоваться методом equals класса String. Альтернативная форма этого метода называется equalsIgnoreCase, при ее использовании различие ре-гистров букв в сравнении не учитывается. Ниже приведен пример, иллюстрирующий использование обоих методов:

class equalDemo < public static void main(String args[]) < String s1="Hello"; String s2="Hello"; String s3="Good-bye"; String s4="HELLO"; System.out.println(s1+"equals"+s2+"->"+s1.equals(s2)); System.out.println(s1+"equals"+s3+"->"+s1.equals(s3)); System.out.println(s1+"equals"+s4+"->"+s1.equals(s4)); System.out.println(s1+"equalsIgnoreCase"+s4+"->"+ s1.equalsIgnoreCase(s4)); > >

Результат запуска этого примера :

С:\> java equalsDemo Hello equals Hello -> true Hello equals Good-bye -> false Hello equals HELLO -> false Hello equalsIgnoreCase HELLO -> true

В классе String реализована группа сервисных методов, являющихся специализированными версиями метода equals. Метод regionMatches используется для сравнения подстроки в исходной строке с подстрокой в строке-параметре. Метод startsWith проверяет, начинается ли данная подстрока фрагментом, переданным методу в качестве параметра. Метод endsWith проверяет совпадает ли с параметром конец строки.

Равенство

Метод equals и оператор == выполняют две совершенно различных проверки. Если метод equal сравнивает символы внутри строк, то опе-ратор == сравнивает две переменные-ссылки на объекты и проверяет, указывают ли они на разные объекты или на один и тот же. В очеред-ном нашем примере это хорошо видно — содержимое двух строк оди-наково, но, тем не менее, это — различные объекты, так что equals и == дают разные результаты.

class EqualsNotEqualTo < public static void main(String args[]) < String s1="Hello"; String s2=new String(s1); System.out.println(s1+"equals"+s2+"->"+s1.equals(s2)); System.out.println(s1+"=="+s2+",->"+(s1==s2)); > >

Вот результат запуска этого примера:

C:\> java EqualsNotEqualTo Hello equals Hello -> true Hello == Hello -> false

Упорядочение

Зачастую бывает недостаточно просто знать, являются ли две строки идентичными. Для приложений, в которых требуется сортировка, нужно знать, какая из двух строк меньше другой. Для ответа на этот вопрос нужно воспользоваться методом compareTo класса String. Если целое значение, возвращенное методом, отрицательно, то строка, с которой был вызван метод, меньше строки-параметра, если положительно — больше. Если же метод compareTo вернул значение 0, строки идентичны. Ниже приведена программа, в которой выполняется пузырьковая сорти-ровка массива строк, а для сравнения строк используется метод compareTo. Эта программа выдает отсортированный в алфавитном порядке список строк.

class SortString < static String arr[] = ; public static void main(String args[]) < for (int j = 0; i 
indexOf и lastIndexOf
 
В класс String включена поддержка поиска определенного символа или подстроки, для этого в нем имеются два метода - indexOf и lastIndexOf. Каждый из этих методов возвращает индекс того символа, который вы хотели найти, либо индекс начала ис-комой подстроки. В любом случае, если поиск оказался неудачным ме-тоды возвращают значение -1. В очередном примере показано, как пользоваться различными вариантами этих методов поиска.
 
class indexOfDemo < public static void main(String args[]) < String s = "Now is the time for all good men " + "to come to the aid of their country " + "and pay their due taxes."; System.out.println(s); System.out.println("indexOf(t) = " + s.indexOf('f')); System.out.println("lastlndexOf(t) = " + s.lastlndexOf('f')); System.out.println("indexOf(the) = " + s.indexOf("the")); System.out.println("lastlndexOf(the) = " + s.lastlndexOf("the")); System.out.println("indexOf(t, 10) = " + s.indexOf('f' , 10)); System.out.println("lastlndexOf(t, 50) = " + s.lastlndexOf('f' , 50)); System.out.println("indexOf(the, 10) = " + s.indexOf("the", 10)); System.out.println("lastlndexOf(the, 50) = " + s.lastlndexOf("the", 50)); >>
Ниже приведен результат работы этой программы. Обратите внимание на то, что индексы в строках начинаются с нуля.






С:> java indexOfDemo Now is the time for all good men to come to the aid of their country and pay their due taxes. indexOf(t) = 7 lastlndexOf(t) = 87 indexOf(the) = 7 lastlndexOf(the) = 77 index0f(t, 10) = 11 lastlndex0f(t, 50) = 44 index0f(the, 10) = 44 lastlndex0f(the, 50) = 44
Модификация строк при копировании
Поскольку объекты класса String нельзя изменять, всякий раз, когда вам захочется модифицировать строку, придется либо копировать ее в объект типа StringBuffer, либо использовать один из описываемых ниже методов класса String, которые создают новую копию строки, внося в нее ваши изменения.
substring
Вы можете извлечь подстроку из объекта String, используя метод sub-string. Этот метод создает новую копию символов из того диапазона ин-дексов оригинальной строки, который вы указали при вызове. Можно указать только индекс первого символа нужной подстроки - тогда будут скопированы все символы, начиная с указанного и до конца строки. Также можно указать и начальный, и конечный индексы - при этом в новую строку будут скопированы все символы, начиная с первого ука-занного, и до (но не включая его) символа, заданного конечным индек-сом.
"Hello World".substring(6) -> "World" "Hello World".substring(3,8) -> "lo Wo"
concat
Слияние, или конкатенация строк выполняется с помощью метода concat. Этот метод создает новый объект String, копируя в него содер-жимое исходной строки и добавляя в ее конец строку, указанную в параметре метода.
"Hello".concat(" World") -> "Hello World"
replace
Методу replace в качестве параметров задаются два символа. Все сим-волы, совпадающие с первым, заменяются в новой копии строки на вто-рой символ.
"Hello".replace('l' , 'w') -> "Hewwo"
toLowerCase и toUpperCase
Эта пара методов преобразует все символы исходной строки в нижний и верхний регистр, соответственно.
"Hello".toLowerCase() -> "hello" "Hello".toUpperCase() -> "HELLO"
trim
И, наконец, метод trim убирает из исходной строки все ведущие и замыкающие пробелы.
"Hello World ".trim() -> "Hello World"
valueOf
Если вы имеете дело с каким-либо типом данных и хотите вывести значение этого типа в удобочитаемом виде, сначала придется преобразо-вать это значение в текстовую строку. Для этого существует метод val-ueOf. Такой статический метод определен для любого существующего в Java типа данных (все эти методы совмещены, то есть используют одно и то же имя). Благодаря этому не составляет труда преобразовать в стро-ку значение любого типа.
StringBuffer
StringBuffer - близнец класса String, предоставляющий многое из того, что обычно требуется при работе со строками. Объекты класса String представляют собой строки фиксированной длины, которые нельзя изме-нять. Объекты типа StringBuffer представляют собой последовательности символов, которые могут расширяться и модифицироваться. Java активно ис-пользует оба класса, но многие программисты предпочитают работать только с объектами типа String, используя оператор +. При этом Java вы-полняет всю необходимую работу со StringBuffer за сценой.
Конструкторы
Объект StringBuffer можно создать без параметров, при этом в нем будет зарезервировано место для размещения 16 символов без возмож-ности изменения длины строки. Вы также можете передать конструкто-ру целое число, для того чтобы явно задать требуемый размер буфера. И, наконец, вы можете передать конструктору строку, при этом она будет скопирована в объект и дополнительно к этому в нем будет заре-зервировано место еще для 16 символов. Текущую длину StringBuffer можно определить, вызвав метод length, а для определения всего места, зарезервированного под строку в объекте StringBuffer нужно воспользоваться методом capacity. Ниже приведен пример, поясняющий это:
class StringBufferDemo < public static void main(String args[]) < StringBuffer sb = new StringBuffer("Hello"); System.out.println("buffer = " + sb); System.out.println("length = " + sb.length()); System.out. println("capacity Hello"); System.out.println("buffer before = " + sb); System.out.println("charAt(1) before = " + sb.charAt(1)); sb.setCharAt(1, 'i'); sb.setLength(2); System.out.println("buffer after = " + sb); System.out.println("charAt(1) after a = ").append(a).append("!").toString(); System.out.println(s); >>
Вот вывод этого примера:
С:\> Java appendDemo а = 42!
insert
Метод insert идентичен методу append в том смысле, что для каждого возможного типа данных существует своя совмещенная версия этого ме-тода. Правда, в отличие от append, он не добавляет символы, возвра-щаемые методом String.valueOf, в конец объекта StringBuffer, а встав-ляет их в определенное место в буфере, задаваемое первым его параметром. В очередном нашем примере строка "there" вставляется между "hello" и "world!".
class insertDemo < public static void main(String args[]) < StringBuffer sb = new StringBuffer("hello world !"); sb.insert(6,"there "); System.out.println(sb); >>
При запуске эта программа выводит следующую строку:
С:\> java insertDemo hello there world!
Без строк не обойдешься
Почти любой аспект программирования в Java на каком либо этапе подразумевает использование классов String и StringBuffer. Они понадо-бятся и при отладке, и при работе с текстом, и при указании имен фай-лов и адресов URL в качестве параметров методам. Каждый второй байт большинства строк в Java - нулевой (Unicode пока используется редко). То, что строки в Java требуют вдвое больше памяти, чем обыч-ные ASCII, не очень пугает, пока вам для эффективной работы с текстом в редакторах и других подобных приложениях не придется напрямую работать с огромным массивом типа char.


Похожие публикации:

Empty standby list что это
Где можно расплачиваться киви кошельком
Как написать приложение на iphone
Как прозвонить usb порт мультиметром