Замена символа в строке java: Java – replace() – замена символов в строке

Замена текста | XSLT с примерами кода

Задача

Требуется заменить все вхождения заданной подстроки другой строкой.

Решение

XSLT 1.0

Следующий рекурсивный шаблон заменяет все вхождения искомой строки на строку замены.

<xsl:template name="search-and-replace">
  <xsl:param name="input" />
  <xsl:param name="search-string" />
  <xsl:param name="replace-string" />
  <xsl:choose>
    <!-- Смотрим, содержит ли входная строка искомую -->
    <xsl:when
      test="$search-string and contains($input,$search-string)"
    >
      <!-- Если да, конкатенируем подстроку, предшествующую искомой,
            со строкой замены, и со строкой, являющейся результатом
            рекурсивного применения шаблона к оставшейся подстроке -->
      <xsl:value-of
        select="substring-before($input,$search-string)"
      />
      <xsl:value-of select="$replace-string" />
      <xsl:call-template name="search-and-replace">
        <xsl:with-param
          name="input"
          select="substring-after($input,$search-string)"
        />
        <xsl:with-param
          name="search-string"
          select="$search-string"
        />
        <xsl:with-param
          name="replace-string"
          select="$replace-string"
        />
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <!-- Больше вхождений искомой строки нет, поэтому возвращаем
            текущую входную строку -->
      <xsl:value-of select="$input" />
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

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

<xsl:template name="search-and-replace-whole-words-only">
  <xsl:param name="input" />
  <xsl:param name="search-string" />
  <xsl:param name="replace-string" />
  <xsl:variable
    name="punc"
    select="concat('.,;:()[][email protected]&amp;&quot;',&quot;&apos;&quot;)"
  />
  <xsl:choose>
    <!-- Смотрим, содержит ли входная строка искомую -->
    <xsl:when test="contains($input,$search-string)">
      <!-- Если да, проверяем, что до и после нее находятся
            разделители слов -->
      <xsl:variable
        name="before"
        select="substring-before($input,$search-string)"
      />
      <xsl:variable
        name="before-char"
        select="substring(concat(' ',$before),
            string-length($before) + 1,1)"
      />
      <xsl:variable
        name="after"
        select="substring-after($input,$search-string)"
      />
      <xsl:variable
        name="after-char"
        select="substring($after,1,1)"
      />
      <xsl:value-of select="$before" />
      <xsl:choose>
        <xsl:when
          test="(not(normalize-space($before-char)) or contains($punc,$before-char)) and (not(normalize-space($after-char)) or contains($punc,$after-char))"
        >
          <xsl:value-of select="$replace-string" />
        </xsl:when>
        <xsl:otherwise>
          <xsl:value-of select="$search-string" />
        </xsl:otherwise>
      </xsl:choose>
      <xsl:call-template
        name="search-and-replace-whole-words-only"
      >
        <xsl:with-param name="input" select="$after" />
        <xsl:with-param
          name="search-string"
          select="$search-string"
        />
        <xsl:with-param
          name="replace-string"
          select="$replace-string"
        />
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <!-- Больше вхождений искомой строки нет, поэтому возвращаем
            текущую входную строку -->
      <xsl:value-of select="$input" />
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

Обратите внимание на то, как переменная $punc строится с помощью функции concat(), чтобы в нее вошли символы одиночной и двойной кавычек. и $ учитывают случай, когда слово находится в начале или в конце строки. Мы должны также вернуть сопоставленный символ назад в текст, воспользовавшись ссылками на запомненные группы $1 и $2.

Функция replace() позволяет больше, чем в решении для XPath 1.0, так как она пользуется регулярными выражениями и может запоминать отдельные сопоставленные части и подставлять их в строку замены с помощью псевдопеременных $1, $2 и т. д.

Обсуждение

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

contains(), substring-before() и substring-after(). Вполне вероятно, что каждая из этих функций повторно просматривает всю входную строку в поисках искомой. И, стало быть, при таком подходе выполняется на два поиска больше, чем необходимо. Немного поразмыслив, вы можете найти решения, показанные в примерах 2.4 и 2.5, которые на первый взгляд представляются более эффективными.

Пример 2.4. Использование временной строки в неудачной попытке улучшить производительность поиска и замены

<xsl:template name="search-and-replace">
  <xsl:param name="input" />
  <xsl:param name="search-string" />
  <xsl:param name="replace-string" />
  <!-- Найти подстроку, предшествующую искомой строке,
    и сохранить ее в переменной -->
  <xsl:variable
    name="temp"
    select="substring-before($input,$search-string)"
  />
  <xsl:choose>
    <!-- Если $temp не пуста или входная строка начинается с искомой
        подстроки, то необходимо произвести замену. Тем самым мы
        избегаем вызова функции contains(). -->
    <xsl:when
      test="$temp or starts-with($input,$search-string)"
    >
      <xsl:value-of
        select="concat($temp,$replace-string)"
      />
      <xsl:call-template name="search-and-replace">
        <!-- Вызова substring-after избегаем за счет
                использования длины temp и искомой строки
                для извлечения остатка строки в рекурсивном вызове.
  -->
        <xsl:with-param
          name="input"
          select="substring($input,string-length($temp)+ string-length($search-string)+1)"
        />
        <xsl:with-param
          name="search-string"
          select="$search-string"
        />
        <xsl:with-param
          name="replace-string"
          select="$replace-string"
        />
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="$input" />
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

Пример 2.5. Использование временного целого в неудачной попытке улучшить производительность поиска и замены

<xsl:template name="search-and-replace">
  <xsl:param name="input" />
  <xsl:param name="search-string" />
  <xsl:param name="replace-string" />
  <!-- Найти длину подстроки, предшествующей искомой строке,
    и сохранить ее в переменной -->
  <xsl:variable
    name="temp"
    select="string-length(substring-before($input,$search-string))"
  />
  <xsl:choose>
    <!-- Если $temp не равно 0 или входная строка начинается
        с искомой подстроки, то необходимо произвести замену.
  Тем самым мы избегаем вызова функции contains(). -->
    <xsl:when
      test="$temp or starts-with($input,$search-string)"
    >
      <xsl:value-of select="substring($input,1,$temp)" />
      <xsl:value-of select="$replace-string" />
      <!-- Вызова substring-after избегаем за счет
            использования temp и длины искомой строки для
            извлечения остатка строки в рекурсивном вызове. -->
      <xsl:call-template name="search-and-replace">
        <xsl:with-param
          name="input"
          select="substring($input,$temp+string-length($search-string)+1)"
        />
        <xsl:with-param
          name="search-string"
          select="$search-string"
        />
        <xsl:with-param
          name="replace-string"
          select="$replace-string"
        />
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="$input" />
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

Идея обоих вариантов одна и та же: если запомнить, где функция substring-before() нашла соответствие, то можно воспользоваться этой информацией для того, чтобы не вызывать функции contains() и substring-after(). Но мы вынуждены обращаться к функции starts-with(), чтобы выделить случай, когда substring-before() возвращает пустую строку; такое может случиться, если искомая строка отсутствует или исходная строка начинается с искомой.

Впрочем, starts-with(), вероятно, работает быстрее, чем contains(), поскольку ей не нужно просматривать больше символов, чем содержится в искомой строке. Второй вариант отличается от первого предположением, что сохранение целочисленного смещения может оказаться эффективнее сохранения подстроки целиком.

Увы, ни одна из этих оптимизаций не дает никакого выигрыша при использовании процессора XSLT Xalan. Более того, при некоторых входных данных реализации Saxon и XT показывают на порядок большее время работы! Столкнувшись с этим парадоксальным результатом, я сначала предположил, что использование переменной $temp в рекурсивном вызове как-то препятствует оптимизации хвостовой рекурсии в Saxon (см. рецепт 2.6). Однако, экспериментируя с длинными входными строками, в которых искомая строка встречается много раз, я не сумел вызвать переполнение стека. Тогда я заподозрил, что по какой-то причине функция

substring() в XSLT работает медленнее, чем substring-before() и substring-after().

Майкл Кэй, автор реализации Saxon, указал, что substring() действительно работает медленно из-за сложных правил, которые приходится поддерживать, в том числе округления аргументов с плавающей точкой, обработки особых случаев, когда начальная или конечная точки оказываются за границами строки, и вопросов, связанных с суррогатными парами Unicode. Напротив, функции substring-before() и substring-after() гораздо лучше транслируются на язык Java.

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

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

4. Основы Kotlin. Списки — Страница 3 — Fandroid.info

Функции высшего порядка над списками

Вернёмся ещё раз к задаче формирования списка из отрицательных чисел в исходном списке. На Котлине, данная задача допускает ещё и такое, очень короткое решение:

fun negativeList(list: List<Int>) = list.filter { it < 0 }

Это короткое решение, однако, является довольно ёмким в плане его содержания. Попробуем в нём разобраться.

list.filter — это один из примеров так называемой функции высшего порядка. Суть функции filter в том, что она фильтрует содержимое списка-получателя. Её результатом также является список, содержащий все элементы списка-получателя, удовлетворяющие определённому условию.

Как же она это делает и что такое вообще функция высшего порядка? Это тоже функция, которая, однако, принимает в качестве параметра другую функцию. Более подробная запись вызова filter выглядела бы так:

fun negativeList(list: List<Int>) = list.filter(fun(it: Int) = it < 0)

Функция-аргумент в данном случае должна иметь параметр it того же типа, что и элементы списка, и результат типа Boolean. В этой записи она отличается от обычной функции только отсутствием имени. Функция filter передаёт функции-аргументу каждый элемент списка. Если функция-аргумент вернула true, элемент помещается в список-результат, если false — он фильтруется.

Более короткая запись list.filter({ it < 0 }) использует так называемую лямбду { it < 0 } в качестве аргумента функции filter. Этот краткий синтаксис не включает в себя не только имени функции, но и ключевого слова fun, а также явного указания имён и типов параметров. При этом предполагается, что:

• параметр называется it; если параметру хочется дать другое имя, лямбда записывается как, например, { element -> element < 0 }
• тип параметра — ровно тот, который требуется функции высшего порядка, для filter это тип элементов списка
• тип результата — опять-таки ровно тот, что требуется
• в фигурные скобки помещается блок, определяющий результат функции; в идеале он состоит из одного оператора, в данном случае это it < 0

Наконец, в том случае, если лямбда является последним аргументом функции, при вызове функции разрешается вынести её за круглые скобки: list.filter() { it < 0 }. Если других аргументов у функции нет, разрешается опустить в этой записи круглые скобки, получив запись из исходного примера: list.filter { it < 0 }

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

fun squares(list: List<Int>) = list.map { it * it }

list.map предназначена для преобразования списка list в другой список такого же размера, при этом над каждым элементом списка list выполняется преобразование, указанное в функции-аргументе map. Тип параметра функции-аргумента совпадает с типом элементов списка list, а вот тип результата может быть произвольным. Например, преобразование list.map { "$it" } создаст из списка чисел вида [0, 1, 2] список строк [«0», «1», «2»].

Чуть более сложный пример: проверка числа на простоту.

fun isPrime(n: Int) = n >= 2 && (2..n/2).all { n % it != 0 }

Функция высшего порядка all в данном примере вызывается для получателя-интервала: 2. .n/2. Применима она и для списка, как и для любого другого объекта, элементы которого можно перебрать с помощью for. Функция allимеет логический результат и возвращает true, если функция-аргумент возвращает true для ВСЕХ элементов списка. Тип параметра функции-аргумента совпадает с типом элементов списка, тип результата — Boolean. Аналогично можно было бы применить функцию высшего порядка any:

fun isNotPrime(n: Int) = n < 2 || (2..n/2).any { n % it == 0 }

Функция высшего порядка any возвращает true, если функция-аргумент возвращает true ХОТЯ БЫ для одного элемента списка.

Наконец, функция высшего порядка fold предназначена для «сворачивания» списка в один элемент или значение. Например:

fun multiplyAll(list: List<Int>) = list.fold(1.0) {
    previousResult, element -> previousResult * element
}

Функция fold работает следующим образом. Изначально она берёт свой первый аргумент (в данном примере 1.0) и сохраняет его как текущий результат. Далее перебираются все элементы списка получателя и для каждого из них применяется указанная лямбда, которая из текущего результата previousResult с предыдущего шага и очередного элемента element делает текущий результат этого шага (в данном примере предыдущий результат домножается на очередной элемент). По окончании элементов списка последний текущий результат становится окончательным. В данном примере результатом будет произведение всех элементов списка (или 1.0, если список пуст).

Строки

Строки String во многих отношениях подобны спискам, хотя формально и не являются ими. Список состоит из однотипных элементов, к которым можно обращаться по индексу и перебирать с помощью цикла for. Строки же точно так же состоят из символов Char, к которым также можно обращаться по индексу и которые также можно перебирать с помощью цикла for.

Напомним, что строковый литерал (явно указанная строка) в Котлине записывается в двойных кавычках. Переменную name произвольного типа можно преобразовать в строку, используя запись "$name" — строковый шаблон, или чуть более сложную запись name.toString() с тем же самым результатом.

Как мы видим, $ внутри строкового литерала имеет специальный смысл — вместо $name в строку будет подставлено содержимое переменной name. Как быть, если мы хотим просто включить в строку символ доллара? В этом случае следует применить так называемое экранирование, добавив перед символом доллара символ \. Например: "The price is 9.99 \$".

Экранирование может применяться и для добавления в строку различных специальных символов, не имеющих своего обозначения либо имеющих специальный смысл внутри строкового литерала. Например: \n — символ новой строки, \t — символ табуляции, \\ — символ «обратная косая черта», \" — символ «двойная кавычка».

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

Перечислим наиболее распространённые операции над строками:

1. string1 + string2 — сложение или конкатенация строк, приписывание второй строки к первой.
2. string + char — сложение строки и символа (с тем же смыслом).
3. string.length — длина строки, то есть количество символов в ней.
4. string.isEmpty(), string.isNotEmpty() — получение признаков пустоты и непустоты строки (Boolean).
5. string[i] — индексация, то есть получение символа по целочисленному индексу (номеру) i в диапазоне от 0 до string.length - 1.
6. string.substring(from, to) — создание строки меньшего размера (подстроки), в который войдут символы строки string с индексами from, from + 1, …​, to - 2, to - 1. Символ с индексом to не включается.
7. char in string — проверка принадлежности символа char строке string.
8. for (char in list) { …​ } — цикл for, перебирающий все символы строки string.
9. string.first() — получение первого символа строки.
10. string.last() — получение последнего символа строки.
11. string.indexOf(char, startFrom) — найти индекс первого символа char в строке, начиная с индекса startFrom.
12. string.lastIndexOf(char, startFrom) — найти индекс первого символа char в строке, идя с конца и начиная с индекса startFrom.
13. string.toLowerCase() — преобразование строки в нижний регистр (то есть, замена прописных букв строчными).
14. string.toUpperCase() — преобразование строки в верхний регистр (замена строчных букв прописными).
15. string.capitalize() — замена первой буквы строки прописной.
16. string.trim() — удаление из строки пробельных символов в начале и конце: " ab c " преобразуется в "ab c"

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

fun isPalindrome(str: String): Boolean {
    val lowerCase = str.toLowerCase().filter { it != ' ' }
    for (i in 0..lowerCase.length / 2) {
        if (lowerCase[i] != lowerCase[lowerCase.length - i - 1]) return false
    }
    return true
}

Обратите внимание, что мы с самого начала переписываем исходную строку str в промежуточную переменную lowerCase, преобразуя все буквы в нижний регистр и удаляя из строки все пробелы. Функция filter работает для строк точно так же, как и для списков — в строке оставляются только те символы, для которых функция-аргумент { it != ' '} вернёт true. Затем мы перебираем символы в первой половине строки, сравнивая каждый из них с символом из второй половины. Символ с индексом 0 (первый) должен соответствовать символу с индексом length - 1(последнему) и так далее.

Страницы: 1 2 3 4

Учебное пособие по тексту замены. Специальные символы

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

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

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

В .NET, JavaScript, VBScript, XRegExp, PCRE2 и std::regex знак доллара можно заменить другим знаком доллара. $$ заменяется буквальным знаком доллара. XRegExp и PCRE2 требуют экранирования всех буквальных знаков доллара. Они рассматривают неэкранированные знаки доллара, которые не образуют действительных заменяющих текстовых токенов, как ошибки. В .NET, JavaScript (без XRegExp) и VBScript вам нужно только экранировать знак доллара, чтобы подавить его особое значение в сочетании с другими символами. В $\ и $! доллар является буквальным символом, потому что он не имеет специального значения в сочетании с обратной косой чертой или восклицательным знаком. Вы не можете и не должны экранировать обратную косую черту, восклицательный знак или любой другой символ, кроме доллара, потому что они не имеют особого значения в строках замены .NET, JavaScript, VBScript и PCRE2.

В Java неэкранированный знак доллара, который не образует токен, является ошибкой. Вы должны экранировать знак доллара обратной косой чертой или другим знаком доллара, чтобы использовать его как буквальный символ. $! является ошибкой, поскольку знак доллара не экранирован и не имеет специального значения в сочетании с восклицательным знаком. Обратная косая черта всегда экранирует следующий символ. \! заменяется буквальным восклицательным знаком, а \\ заменяется одной обратной косой чертой. Единственная обратная косая черта в конце замещающего текста является ошибкой.

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

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

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

В R знак доллара не имеет особого значения. Обратная косая черта всегда экранирует следующий символ. \! заменяется буквальным восклицательным знаком, а \\ заменяется одной обратной косой чертой. Единственная обратная косая черта в конце замещающего текста игнорируется.

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

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

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

Правила из предыдущего раздела объясняют, как функции поиска и замены в этих языках программирования анализируют замещающий текст. Если ваше приложение получает замещающий текст из пользовательского ввода, то пользователь вашего приложения должен будет следовать этим правилам выхода и только этим правилам. Вы можете быть удивлены тем, что такие символы, как одинарная и двойная кавычки, не являются специальными символами. Это правильно. При использовании регулярного выражения или инструмента grep, такого как PowerGREP, или функции поиска и замены текстового редактора, такого как EditPad Pro, вы не должны экранировать или повторять символы кавычек, как в языке программирования.

Если вы указываете замещающий текст как строковую константу в исходном коде, то вы должны помнить, какие символы обрабатываются внутри строковых констант вашим языком программирования. Это связано с тем, что эти символы обрабатываются компилятором до того, как функция замены текста увидит строку. Так, например, в Java, чтобы заменить все совпадения регулярных выражений одним знаком доллара, вам нужно использовать текст замены \$, который вам нужно ввести в исходный код как «\\$». Компилятор Java превращает экранированную обратную косую черту в исходном коде в одиночную обратную косую черту в строке, которая передается функции replaceAll(). Затем эта функция видит одиночную обратную косую черту и знак доллара как экранированный знак доллара.

Дополнительную информацию о том, как использовать строки замены в различных языках программирования, см. в разделе «Инструменты и языки» на этом веб-сайте.

| Быстрый старт | Учебник | Инструменты и языки | Примеры | Ссылка | Обзоры книг |

| Введение | Персонажи | Непечатаемые символы | Совпадающий текст | Обратные ссылки | Совпадение с контекстом | Преобразование случая | Условные операторы |

Что такое метод StringUtils.replace() в Java?

abhilash

Устали от LeetCode? 😩

Изучите 24 шаблона, чтобы решить любой вопрос на собеседовании по кодированию, не заблудившись в лабиринте практических задач в стиле LeetCode. Практикуйте свои навыки в практической среде кодирования, не требующей настройки. 💪

Обзор

В Java replace() — это статический метод класса StringUtils , который используется для замены строки поиска строкой замены. Метод необязательно принимает первое максимальное количество совпадений строки поиска, которая будет заменена в заданном тексте. Сопоставление строк здесь чувствительно к регистру.

Примечание: См. Что такое StringUtils.replaceIgnoreCase в Java? для нечувствительного к регистру сопоставления и замены.

Как импортировать

StringUtils

Определение StringUtils можно найти в пакете Apache Commons Lang, который мы можем добавить в проект Maven, добавив следующую зависимость в файл pom.xml .

 
 <зависимость> 
 
 org.apache.commons 
 
 commons-lang3 
 
 3. 12.0 
 
  
 

Импорт StringUtils

Примечание. Другие версии пакета commons-lang см. в репозитории Maven.

Мы можем импортировать класс StringUtils следующим образом:

 import org.apache.commons.lang3.StringUtils;
 

Синтаксис

 public static String replace(final String text, final String searchString, final String replace, final int max)
 

Параметры

• final Текст строки : Текст для поиска и замены.
• final String searchString : Строка для поиска.
• final Замена строки : Замена строки.
• final int max : Первое максимальное количество значений для замены.

Возвращаемое значение

Этот метод возвращает текст, в котором строка поиска заменена строкой замены.

Перегруженные методы:

• public static String replace(final String text, final String searchString, final String replace)

 
<проект xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-экземпляр"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.0.0
    org.example
    тест
    <версия>1.0-SNAPSHOT
    <свойства>
        8
        8
    
    <зависимости>
        <зависимость>
            org.apache.commons
            commons-lang3
            <версия>3.12.0
        
    
    <сборка>
        <плагины>
            <плагин>
                org. apache.maven.plugins
                плагин maven-shade
                <версия>2.1
                <выполнения>
                    <исполнение>
                        <фаза>пакет
                        <цели>
                            оттенок
                        
                        <конфигурация>
                            <трансформеры>
                                <трансформер
                                        реализация = "org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    Основной
                                
                            
                        
                    
                
            
        
    
 

Объяснение

Зависимость Maven для StringUtils включена в файл Pom.