Заменить в строке все вхождения word на letter java

Обновлено: 08.01.2025

Используя метод replace(CharSequence target, CharSequence replacement) в String, как я могу сделать цель нечувствительной к регистру?

Например, как это работает сейчас:

Как я могу сделать так, чтобы замена (или, если есть более подходящий метод), не учитывала регистр, чтобы оба примера возвращали "Bar"?

Стоит отметить, что replaceAll обрабатывает первый аргумент как шаблон регулярного выражения, что может привести к неожиданным результатам. Чтобы решить эту проблему, также используйте Pattern.quote как предложено в комментариях.

Возможно, не так элегантно, как другие подходы, но он довольно надежен и прост в использовании, особенно. для новичков в Java. Одна вещь, которая мне нравится в классе String, заключается в следующем: он существует уже очень давно, и хотя он поддерживает глобальную замену с помощью регулярного выражения и глобальную замену с помощью строк (через CharSequences), последний не имеет простого логического параметра : 'isCaseInsensitive'. На самом деле, вы могли подумать, что, просто добавив этот маленький переключатель, можно было бы избежать всех проблем, которые вызывает его отсутствие, особенно для новичков. Теперь в JDK 7 String все еще не поддерживает это небольшое дополнение!

Ну, в любом случае, хватит хвататься. Для всех, особенно новичков в Java, вот ваш deus ex machina . Как я уже сказал, он не такой элегантный и не принесет вам никаких призов за программирование, но он работает и надежен. Любые комментарии, не стесняйтесь вносить свой вклад. (Да, я знаю, StringBuffer, вероятно, лучший выбор для управления строками мутации двух символьных строк, но это достаточно просто, чтобы поменять методы.)

Если вас не волнует case, то, возможно, не имеет значения, возвращает ли он все upcase:

Регулярными выражениями довольно сложно управлять из-за того, что некоторые символы зарезервированы: например, "foo.bar".replaceAll(".") создает пустую строку, потому что точка означает "что угодно". Если вы хотите заменить только точку, следует указать параметр "\\." .

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

Сравнение — одна из самых частых вещей, которая делается со строками. У класса String более десяти различных методов, которые используются для сравнения строк со строками. Ниже мы рассмотрим 8 основных.

Методы	Описание
Строки считаются равными, если все их символы совпадают.
Сравнивает строки, игнорируя регистр (размер) букв
Сравнивает строки, возвращает количество одинаковых символов от начала строки.
Возвращает количество одинаковых символов от начала строки, игнорирует регистр
Сравнивает части строк
Проверяет, что текущая строка начинается со строки prefix
Проверят, что текущая строка заканчивается на строку suffix

Допустим, вы хотите написать программу, которая просит пользователя ввести путь к файлу и проверяет, что это за файл по его расширению. Тогда код такой программы мог бы выглядеть примерно так:

Закомментируй ненужные строки кода, чтобы на экран вывелась цифра 5. Примечание: нужно закомментировать только две строки.

5.2 Поиск подстрок

Вторая по популярности операция после сравнения строк — это поиск одной строки в другой. Для этого у класса String тоже есть немного методов:

Методы	Описание
Ищет строку str в текущей строке. Возвращает индекс первого символа встретившейся строки.
Ищет строку str в текущей строке, пропустив index первых символов. Возвращает индекс найденного вхождения.
Ищет строку str в текущей строке с конца. Возвращает индекс первого вхождения.
Ищет строку str в текущей строке с конца, пропустив index первых символов.
Проверяет, что текущая строка совпадает с шаблоном, заданным регулярным выражением.

Методы indexOf(String) и indexOf(String, index) часто используются в паре. Первый позволяет найти первое вхождение переданной подстроки в текущей строке. А второй метод позволяет найти второе, третье и т.д. вхождения за счет того, что пропускает первые index символов.

Перед именем домена идут два слеша «//»
После имени домена идет одинарный слеш /

Вот как бы выглядел код такой программы:

Получаем индекс первого вхождения строки //
Получаем индекс первого вхождения строки / , но ищем только после символов // .
Получаем строку от начала и заканчивая символами //
Получаем строку от / и до конца.

Методы lastIndexOf(String) и lastIndexOf(String, index) работают точно так же, только поиск ведется с конца строки к началу.

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

Представление

Строка Java (до Java 9) представлена внутри Java VM с использованием байтов, закодированных как UTF-16. UTF-16 использует 2 байта для представления одного символа. Таким образом, символы строки представляются с использованием массива char.

Компактные строки

Начиная с Java 9 и выше, Java VM может оптимизировать строки с помощью новой функции, называемой компактными строками. Она позволяет виртуальной машине определять, содержит ли строка только символы ISO-8859-1 / Latin-1. Если это так, она будет использовать только 1 байт на символ внутри. Таким образом, символы компактной строки могут быть представлены байтовым массивом вместо массива char.

Может ли String быть представлена в виде компактной строки или нет, определяется при создании строки. Однажды созданная строка является неизменной, поэтому это безопасно.

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

Строки являются объектами. Поэтому нужно использовать оператор new для создания нового объекта Java String:

Строковые литералы

Есть более короткий способ создания новой строки:

Вместо того, чтобы передавать текст «Hello World» в качестве параметра конструктору String, вы можете просто написать сам текст внутри символов двойной кавычки. Это называется строковым литералом. При компиляции Java кода самостоятельно определяется, как будет создана новая строка, представляющая данный текст.

Escape-символы

Литералы Java Strings принимают набор из которых переводятся в специальные символы в созданной строке. Пример создания с использованием escape-символов:

Этот строковый литерал приведет к строке, которая начинается с символа табуляции и заканчивается переводом каретки и символом новой строки.

Константы

Если вы используете ту же строку (например, «Hello World») в других объявлениях переменных String, виртуальная машина Java может создать в памяти только один экземпляр String. Таким образом, строковый литерал становится де-факто константой или синглтоном. Различные переменные, инициализированные одной и той же константной строкой, будут указывать на один и тот же экземпляр String в памяти.

В этом случае виртуальная машина заставит myString1 и myString2 указывать на один и тот же объект String.

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

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

Даже если значение (текст) двух созданных строк Java одинаково, виртуальная машина Java создаст в памяти два разных объекта для их представления.

Конкатенация строк

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

Содержимое строки, на которую ссылается переменная три, будет Hello World. Два других объекта Strings нетронуты.

Производительность конкатенации

При объединении строк вам следует остерегаться возможных проблем с производительностью. Конкатенация двух строк будет преобразована компилятором Java в нечто вроде этого:

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

Вот цикл, содержащий вышеуказанный тип конкатенации строк:

Этот код будет скомпилирован в нечто похожее на это:

Теперь для каждой итерации в этом цикле создается новый StringBuilder. Кроме того, объект String создается методом toString(). Это приводит к небольшим расходам на создание экземпляров за одну итерацию: один объект StringBuilder и один объект String. Само по себе не является настоящим убийцей производительности, хотя.

Каждый раз, когда выполняется новый код StringBuilder(result), конструктор StringBuilder копирует все символы из результирующего String в StringBuilder. Чем больше итераций цикла, тем больше будет результат String. Чем больше растет результат String, тем больше времени требуется для копирования символов из него в новый StringBuilder и повторного копирования символов из StringBuilder во временную строку, созданную методом toString(). Другими словами, чем больше итераций, тем медленнее становится каждая итерация.

Этот код избегает как экземпляров объектов StringBuilder и String внутри цикла, так и, следовательно, позволяет избежать двухкратного копирования символов, сначала в StringBuilder, а затем снова в String.

Длина строки

Подстроки

После выполнения этого кода переменная substring будет содержать строку Hello.

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

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

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

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

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

Сопоставление строки с регулярным выражением с помощью match()

Метод Java String match() принимает регулярное выражение в качестве параметра и возвращает true, если регулярное выражение соответствует строке, и false, если нет:

Сравнение

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

equals();
equalsIgnoreCase();
StartWith();
EndsWith();
compareTo().

equals()

Метод equals() проверяет, точно ли две строки равны друг другу. Если они есть, возвращается true. Если нет, false:

Две строки одна и три равны, но одна не равна двум или четырем. Регистр символов также должен совпадать, поэтому строчные буквы не равны прописным.

Вывод, напечатанный из кода выше, будет:

equalsIgnoreCase()

Класс String также имеет метод equalsIgnoreCase(), который сравнивает две строки, но игнорирует регистр символов. Таким образом, заглавные буквы считаются равными их строчным эквивалентам.

StartWith() и EndWith()

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

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

compareTo()

Метод compareTo() сравнивает строку с другой и возвращает int, сообщающий, меньше ли эта строка, равна или больше другой.

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

В этом примере сравнивается одна строка с двумя другими. Вывод:

Числа отрицательны, потому что одна строка находится в порядке сортировки раньше, чем две другие.

Метод compareTo() фактически принадлежит интерфейсу Comparable.

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

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

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

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

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

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

Замена символов replace()

Класс Java String содержит метод replace(), который может заменять символы в строке. Он фактически не заменяет символы в существующей строке. Скорее, возвращает новый экземпляр String. Он равен экземпляру String, из которого он был создан, но с заменой указанных символов. Пример:

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

Метод replace() заменит все символы, соответствующие символу, переданному методу в качестве первого параметра, вторым символом, переданным в качестве параметра.

replaceFirst()

Метод Java String replaceFirst() возвращает новую строку с первым совпадением регулярного выражения, переданного в качестве первого параметра, со строковым значением второго параметра:

Возвращается строка «один пять три два один».

replaceAll()

Метод Java String replaceAll() возвращает новую строку со всеми совпадениями регулярного выражения, переданного в качестве первого параметра, со строковым значением второго параметра:

Возвращается строка «один пять три пять один».

Разделение

Класс Java String содержит метод split(), который можно использовать для разделения String на массив объектов String:

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

Исходная строка была разделена на символы a. Возвращенные строки не содержат символов a. Символы a считаются разделителями для деления строки, а разделители не возвращаются в результирующий массив строк.

Параметр, передаваемый методу split(), на самом деле является регулярным выражением Java, которые могут быть довольно сложными. Приведенное выше соответствует всем символам, даже буквам нижнего регистра.

Выполнение примера с ограничением 3 вместо 2 приведет к тому, что эти строки будут возвращены в результирующий массив String:

Выполнение приведенного выше примера с пределом 4 или выше приведет к тому, что будут возвращены только строки Split, поскольку в String есть только 4 совпадения с регулярным выражением a.

Преобразование чисел в строку с помощью valueOf()

Класс содержит набор перегруженных статических методов с именем valueOf(), которые можно использовать для преобразования числа в строку:

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

Класс Object содержит метод с именем toString(). Поскольку все классы Java расширяют (наследуют) класс Object, все объекты имеют метод toString(). Он может использоваться для создания строкового представления данного объекта:

Примечание. Чтобы метод toString() возвращал нормальное String представление заданного объекта, класс объекта должен переопределить метод toString(). Если нет, то будет вызван метод toString() по умолчанию (унаследованный от класса Object), которые не предоставляет столько полезной информации.

Получение символов и байтов

Можно получить символ по определенному индексу в строке, используя метод charAt():

Этот код распечатает:

Так как это символы, расположенные в индексах 0 и 3 в строке.

Вы также можете получить байтовое представление метода String, используя метод getBytes():

Первый вызов getBytes() возвращает байтовое представление строки, используя кодировку набора символов по умолчанию на машине. Набор символов по умолчанию зависит от компьютера, на котором выполняется код. Поэтому обычно лучше явно указать набор символов, который будет использоваться для создания представления байтов (как в следующей строке).

Преобразование в верхний и нижний регистр

Вы можете конвертировать строки в верхний и нижний регистр, используя методы toUpperCase() и toLowerCase():

Метод replace() заменяет указанный символ (или подстроку) в строке на новый.

Синтаксис метода:

Вызов:

String newString = oldString . replace ( char oldChar , char newChar ) ; String newString = oldString . replace ( String sub1 , String sub2 ) ;

Пример 1:

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

Комментарии к коду:

У нас есть переменная oldString, которая хранит строку "ABC". Представим, что нам надо заменить 'A' на 'B'. Для этого мы используем метод replace(). Первым параметром мы указываем, что заменить (символ 'A'), а вторым - чем заменить (символ 'B'). Итого, получаем в консоли новую строку - "BBC".

Обратите внимание - первая строка (oldString) не изменилась после применения метода. То-есть метод replace() возвращает новую строку.

Пример 2:

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

Комментарии к коду:

Как и в прошлом примере, мы заменили один символ на другой (в данном случае 'a' на 'i').

Обратите внимание - метод replace() заменяет все символы в строке на новый, а не только его первое вхождение.

Пример 3:

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

Комментарии к коду:

Теперь мы заменяем не символы, а строки - а именно, мы ищем в строке "Java" подстроку "av" и заменяем на "oshu". Подстрока "av" встречается в строке "Java" один раз ("J av a"). В результате выполнения метода, получаем новую строку "Joshua".

Обратите внимание - подстроки не должны иметь одинаковую длину (длина строки "oshua" больше длины строки "av", но метод все равно работает корректно).

Данная статья написана Vertex Academy. Можно пройти наши курсы Java с нуля. Детальнее на сайте.

Читайте также: