Класс scala.util.matching.Regex

Проверка двух объектов на неравенство.

Эквивалентно x.hashCode за исключением упакованных числовых типов и null. Для чисел он возвращает значение хеша, согласованное с равенством значений: если два экземпляра типа значения сравниваются как true, то ## для каждого из них вернёт одно и то же значение хеша. Для null возвращает хешкод, где null.hashCode выбрасывает NullPointerException.

Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

Привести объект-получатель к типу T0.

Обратите внимание, что успешность приведения в рантайме зависит от семантики стирания Scala. Таким образом, выражение 1.asInstanceOf[String] выбросит ClassCastException в рантайме, в то время как выражение List(1).asInstanceOf[List[String]] не выбросит. В последнем примере, поскольку тип аргумента стёрся во время компиляции, невозможно проверить, соответствуют ли содержимое списка требуемому типу.

Создать копию объекта-получателя.

Стандартная реализация метода clone зависит от платформы.

Проверяет, является ли аргумент (that) ссылкой на объект-получатель (this).

Метод eq реализует отношение эквивалентности на непустых экземплярах AnyRef, и обладает тремя дополнительными свойствами:

Он согласован: для любых непустых экземпляров x и y типа AnyRef, многократные вызовы x.eq(y) последовательно возвращают true или последовательно возвращают false.Для любого непустого экземпляра x типа AnyRef, вызовы x.eq(null) и null.eq(x) возвращают false. null.eq(null) возвращает true.

При переопределении методов equals или hashCode важно обеспечить согласованность их поведения с равенством ссылок. Поэтому, если два объекта являются ссылками друг на друга (o1 eq o2), они должны быть равны друг другу (o1 == o2) и они должны хешироваться до одного и того же значения (o1.hashCode == o2.hashCode).

Метод равенства для ссылочных типов. Реализация по умолчанию делегирует вызов eq.

См. также equals в scala.Any.

Вызывается сборщиком мусора для объекта-получателя, когда больше нет ссылок на объект.

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

Возвращает все неперекрывающиеся совпадения данного Regex в заданной последовательности символов как scala.util.matching.Regex.MatchIterator, который является специальным scala.collection.Iterator, возвращающим совпадающие строки, но также может быть запрошен для получения дополнительной информации о последнем совпадении, таких как группы захвата и начальная позиция.

MatchIterator также может быть преобразован в итератор, возвращающий объекты типа scala.util.matching.Regex.Match, как обычно возвращает findAllMatchIn.

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

val hat  = "hat[^a]+".r
val hathaway = "hathatthattthatttt"
val hats = hat.findAllIn(hathaway).toList                     // List(hath, hattth)
val pos  = hat.findAllMatchIn(hathaway).map(_.start).toList   // List(0, 7)

Для возвращения перекрывающихся совпадений можно сформулировать регулярное выражение с просмотром вперед (?=), которое не потребляет перекрывающуюся область.

val madhatter = "(h)(?=(at[^a]+))".r
val madhats   = madhatter.findAllMatchIn(hathaway).map {
  case madhatter(x,y) => s"$x$y"
}.toList                                       // List(hath, hatth, hattth, hatttt)

Попытка получить информацию о совпадении после исчерпания итератора приводит к java.lang.IllegalStateException. См. scala.util.matching.Regex.MatchIterator для деталей.

Возвращает все неперекрывающиеся совпадения данного регулярного выражения в заданной последовательности символов как scala.collection.Iterator объектов scala.util.matching.Regex.Match.

Возвращает необязательную первую совпадающую строку данного Regex в заданной последовательности символов или None, если совпадения нет.

Возвращает необязательное первое совпадение данного Regex в заданной последовательности символов или None, если совпадения нет.

Если совпадение успешно, то scala.util.matching.Regex.Match можно использовать для запроса дополнительной информации.

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

В отличие от findFirstMatchIn, этот метод будет возвращать совпадение только в начале входных данных.

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

В отличие от findFirstIn, этот метод будет возвращать совпадение только в начале входных данных.

Возвращает строку, отформатированную в соответствии с заданной format строкой. Форматные строки аналогичны String.format (@see java.lang.String.format).

Возвращает представление класса объекта во время выполнения.

Метод hashCode для ссылочных типов. См. hashCode в scala.Any.

Проверяет, соответствует ли динамический тип объекта получателя типу T0.

Обратите внимание, что результат проверки зависит от стирания типов в Scala. Следовательно, выражение 1.isInstanceOf[String] вернёт false, а выражение List(1).isInstanceOf[List[String]] вернёт true. В последнем примере, из-за стирания типа в процессе компиляции, невозможно проверить, относятся ли элементы списка к указанному типу.

Эквивалентно !(this eq that).

Разбуживает один поток, ожидающий на мониторе объекта-получателя.

Разбуживает все потоки, ожидающие на мониторе объекта-получателя.

Заменяет все совпадения с помощью функции замены. Функция replacer принимает scala.util.matching.Regex.Match, чтобы получить дополнительную информацию из совпадения. Например:

import scala.util.matching.Regex
val datePattern = new Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day")
val text = "From 2011-07-15 to 2011-07-17"
val repl = datePattern replaceAllIn (text, m => s"${m group "month"}/${m group "day"}")

В строке замены знак доллара ($) за которым следует число будет интерпретироваться как ссылка на группу в сопоставленном шаблоне, при этом числа от 1 до 9 соответствуют первым девяти группам, а 0 — всему совпадению. Любой другой символ является ошибкой. Символ обратного слэша (\) будет интерпретироваться как символ экранирования и может использоваться для экранирования знака доллара. Используйте Regex.quoteReplacement для экранирования этих символов.

Заменяет все совпадения строкой.

В строке replacement знак доллара ($) за которым следует число будет интерпретироваться как ссылка на группу в сопоставленном шаблоне, при этом числа от 1 до 9 соответствуют первым девяти группам, а 0 — всему совпадению. Любой другой символ является ошибкой. Знак обратного слэша (\) интерпретируется как символ экранирования и может использоваться для экранирования знака доллара. Используйте Regex.quoteReplacement для экранирования этих символов.

Заменяет первое совпадение строкой.

В строке replacement знак доллара ($) за которым следует число будет интерпретироваться как ссылка на группу в сопоставленном шаблоне, при этом числа от 1 до 9 соответствуют первым девяти группам, а 0 — всему совпадению. Любой другой символ является ошибкой. Знак обратного слэша (\) интерпретируется как символ экранирования и может использоваться для экранирования знака доллара. Используйте Regex.quoteReplacement для экранирования этих символов.

Заменяет некоторые совпадения с использованием функции replacer, которая возвращает scala.Option. Функция replacer принимает scala.util.matching.Regex.Match для получения дополнительной информации из совпадения. Например:

import scala.util.matching.Regex._

val vars = Map("x" -> "a var", "y" -> """some $ and \ signs""")
val text = "A text with variables %x, %y and %z."
val varPattern = """%(\w+)""".r
val mapper = (m: Match) => vars get (m group 1) map (quoteReplacement(_))
val repl = varPattern replaceSomeIn (text, mapper)

В строке replacement знак доллара ($) за которым следует число будет интерпретироваться как ссылка на группу в сопоставленном шаблоне, при этом числа от 1 до 9 соответствуют первым девяти группам, а 0 — всему совпадению. Любой другой символ является ошибкой. Знак обратного слэша (\) интерпретируется как символ экранирования и может использоваться для экранирования знака доллара. Используйте Regex.quoteReplacement для экранирования этих символов.

Разделяет предоставленную последовательность символов вокруг совпадений этого регулярного выражения.

Строка, определяющая регулярное выражение

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

Обычно сопоставление с date ведет себя так, как будто шаблон был заключен в якоря, "^pattern$"..

Неякоренное Regex ведет себя так, как будто эти якоря были удалены.

Обратите внимание, что этот метод не на самом деле удаляет какие-либо совпадения из шаблона.

Вызов anchored возвращает исходный Regex.

val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r.unanchored

val date(year, month, day) = "Date 2011-07-15"                       // OK

val copyright: String = "Date of this document: 2011-07-15" match {
  case date(year, month, day) => s"Copyright $year"                  // OK
  case _                      => "No copyright"
}

Пытается сопоставить scala.util.matching.Regex.Match.

Предыдущее неудачное сопоставление приводит к None.

Если успешное сопоставление было сделано с текущим шаблоном, то этот результат используется.

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

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

Если сопоставление успешно, результатом является первая совпадающая группа, если группы определены, или пустая последовательность в противном случае.

Например:

val cat = "cat"
// the case must consume the group to match
val r = """(\p{Lower})""".r
cat(0) match { case r(x) => true }
cat(0) match { case r(_) => true }
cat(0) match { case r(_*) => true }
cat(0) match { case r() => true }     // no match

// there is no group to extract
val r = """\p{Lower}""".r
cat(0) match { case r(x) => true }    // no match
cat(0) match { case r(_) => true }    // no match
cat(0) match { case r(_*) => true }   // matches
cat(0) match { case r() => true }     // matches

// even if there are multiple groups, only one is returned
val r = """((.))""".r
cat(0) match { case r(_) => true }    // matches
cat(0) match { case r(_,_) => true }  // no match

Пытается сопоставить java.lang.CharSequence.

Если сопоставление успешно, результатом является список сопоставленных групп (или элемент null, если ни одна группа не сопоставилась с вводом). Если шаблон не определяет групп, то результатом при успешном сопоставлении будет пустой список.

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

Например:

val p1 = "ab*c".r
val p1Matches = "abbbc" match {
  case p1() => true               // no groups
  case _    => false
}
val p2 = "a(b*)c".r
val p2Matches = "abbbc" match {
  case p2(_*) => true             // any groups
  case _      => false
}
val numberOfB = "abbbc" match {
  case p2(b) => Some(b.length)    // one group
  case _     => None
}
val p3 = "b*".r.unanchored
val p3Matches = "abbbc" match {
  case p3() => true               // find the b's
  case _    => false
}
val p4 = "a(b*)(c+)".r
val p4Matches = "abbbcc" match {
  case p4(_*) => true             // multiple groups
  case _      => false
}
val allGroups = "abbbcc" match {
  case p4(all @ _*) => all mkString "/" // "bbb/cc"
  case _            => ""
}
val cGroup = "abbbcc" match {
  case p4(_, c) => c
  case _        => ""
}