From the Super Mario Wiki
Notable Members
Not to be confused with .
Big Boos, also called Atomic Boos or Mega Boos, are a sub-species of . Usually, they resemble and behave similarly to normal Boos, except that they are larger.
The Big Boo.
The Big Boos (or The Big “Boo”) first appear in . In the game, Big Boos inhabit the various
located around . Curiously, although they are over ten times bigger than a normal Boo, Big Boos still have the same mannerisms of their smaller counterparts. Of course, this means that when looked at, a Big Boo will fade and hide behind its arms, occasionally peeking to see if they are still being looked at. However, if someone's back is turned, a Big Boo will attack them from behind.
In the game, Big Boos are much more difficult to pass than their smaller brethren. As such, Mario or Luigi usually have to use a trampoline to
over these massive ghosts. However, if Mario or Luigi can get a running start, they can usually
over a Big Boo. Additionally, if there is room, the brothers can use a
to fly over a Big Boo or perform a sliding Cape Attack during descent to actually destroy the Big Boo. Additionally, a translucent white one also called "" is a hidden boss of the . He can be defeated by throwing
at his face. He has two normal
accompany him in battle. However, normal Big Boos don't appear. Only
A Big Boo from Super Mario 64.
Big Boos return in the game . Again, a Big Boo disappears when looked at, and become visible again when Mario turns away. They have a high pitch laugh like a normal Boo, but make the same low pitch grunt as a
does when hit.
Big Boos can only be attacked when visible, so Mario has to attack these massive ghosts by either Ground Pounding them from above or punching them from the side. Inside , Mario can fight three Big Boos. These Big Boos take three hits to defeat, becoming smaller after each hit. After destroying a Big Boo, Mario will receive a . In the Japanese version, the giant Boos are known as "Boss Boo" rather than their usual Japanese name "Atomic Boo". The giant Boo that appears when all the ghost house Boos are defeated is also known as "Master Boo".
makes an appearance. In this game, King Boo has his trademark crown from later appearances and characteristic cackle. However, in-game, he is erroneously referred to as Big Boo in English versions.
Big Boos as they appears in New Super Mario Bros. Wii.
A Big Boo.
Big Boos reappear in the game , and act much like they do in . They can only be encountered in , and are usually seen with many smaller . Unlike regular Boos, a Big Boo will not stop attacking unless every player is facing it, unless there are 4 players, in which case only 3 need to face it.
The Big Boo and four smaller Boos in Super Mario Galaxy 2.
in , but were removed. They do appear in , however, behaving as they would have in the first Galaxy game.
In Super Mario Galaxy 2, Big Boos are known as Mega Boos and follow Mario through a thin hall, not stopping unless they are looked at or the player reaches a
or . Big Boos are only found in groups of five, with the Big Boo in the middle being larger than the ones
surrounding it. Big Boos are only seen in 'Sneaking Down the Creepy Corridor' in .
These gigantic
reappear in , where they behave similarly to their New Super Mario Bros. Wii counterparts. They appear in a few ghost houses. Sometimes, if Mario is very far away from the Big Boo and looks in the opposite direction, it will float away instead of drifting towards him.
A Golden Big Boo leaving a trail of coins.
Big Boos appear in . Appearing in Ghost Houses, Big Boos can be turned golden by hitting them with a gold fireball or passing through a . While in their golden form, they cover their faces and leave a trail of
behind them for
to take. Whenever it covers its face, the Big Boo glows red, while it radiates a dark shadow around it once Mario stops staring at it.
Big Boos reappear on the Nintendo
title , once again only appearing in . Nothing has changed in their behavior, but now if
is watching, Big Boos began to sweat.
Big Boos also appear in
with the same behavior of Super Mario 3D Land. Some can be seen outside the windows in
watching the player, but these Big Boos do not do anything special. Big Boos can now be defeated by , leaving coins.
A Big Boo, with three Boos, from the Super Mario World episode "Ghosts 'R' Us".
Big Boos appeared in two episodes of the
animated series. In the episode "", , while exploring , encounters a Big Boo and three regular . Terrified of the Boos, Yoshi proceeds to run away in a panic as the four ghosts give chase. After running some time through Wizardheimer's Haunted House and losing the three regular Boos, Yoshi manages to trick the Big Boo into entering a vacant room. With the Big Boo apparently trapped in this room, Yoshi locks the door. Unfortunately, the Big Boo simply phases through the wall and resumes chasing Yoshi. Yoshi eventually escapes his Big Boo tormentor by fleeing into the basement of Wizardheimer's Haunted House.
In Super Mario World's final episode, "", a Big Boo is seen acting as a guard to . Mario, Luigi and Yoshi easily sneak past this Big Boo guard by using a nearby , which led to the basement of Neon Castle.
The Big Boo, trying to sneak up on
while its smaller brethren distract the plumbers.
An unnamed Big Boo was also featured prominently in the
comic by . After being lured into a Ghost House, Mario and Luigi, after an encounter with several dozen Boos, encounter a Big Boo. Attempting to stare down this Big Boo and the swarm of Boos, Mario and Luigi become exhausted after hours of simply staring at the shy ghosts. Nearly collapsing of exhaustion, Mario spots a door and, dragging Luigi, dashes to it, with the Boos and Big Boos after him. Bursting through the door of the room Mario and Luigi just entered, the Big Boo and his Boo minions are surprised to see Mario , with Luigi as his nurse. Acting as a psychiatrist, Mario manages to learn that, as a child, this Big Boo was constantly bullied, which led to its vicious behavior. After hearing this Big Boo's sad tale, Mario gives some helpful words of wisdom and advice. The Big Boo, having become a changed ghost through Mario's therapy, happily leads Mario out of the Ghost House and gratefully thanks him as Mario, Luigi and
take-off to . Another Big Boo was later seen among the attendees to 's wedding to the brainwashed .
The Big Boo appears as the boss of the level Ghost mansion in , Mario must shoot it with the
as he makes parts of the wall fall down on him. Later the Boo will separate into three smaller Boos. Mario must shoot the one with his tongue out to win.
In , they appear in many
and . However, in this game, they are only about three times bigger than a normal Boo, unlike in Super Mario World. Like normal Boos, they could only be defeated by looking away from the ghost and bouncing an egg off a wall, hitting the ghost in the face. They release
when defeated. Additionally, one of the bosses, , starts as a normal Big Boo before being transformed by Kamek's magic.
Big Boos re-appear in , behaving the same way as they did in the prequel.
One boo-like enemy is transformed by
into a boss, named "."
In , Big Boos, first appearing in , are powerful enemies, being about one-sixth the s Big Boos in this game attacked in a manner similar to the ones of Super Mario World, slowly floating towards Mario or Luigi when they look away, turning transparent when directly looked at.
One Big Boo has a cameo appearance in this game - it is used in 's
attack. The enemy, "The Big Boo", is just a misnamed regular .
Big Boo's appearance in Mario Party 2.
a Big Boo appears in the
stage. As a typical Boo, it is able to steal objects from player's rivals, being coins or stars. However, Big Boo will deal for stealing the coins or the stars from all the opponents, while paying to him three times the amount of coins than a normal Boo would do. Characters can ask for hi in daytime, Big Boo appears as a giant Boo statue.
In , Big Boo reappears in the board . In the game, it appears in an odd blue color.
Big Boo fighting
during a boxing match in .
Big Boo is an opponent in the Boxing game for . He is Luigi's second opponent. However, instead of boxing gloves, Big Boo uses smaller Boos to pummel his opponent.
           72           
Big Boo reappears in , now under the retranslated name Atomic Boo. The Atomic Boo is an optional mini-boss composed of approximately two hundred different Boos. To fight this boss, Mario must go to the
after freeing the 200 Boos in Chapter 4 (if he guesses the number right, a Boo will give him an ). Even though Mario agreed to be nice to the Boos, they swarm him as soon as they are free. If Mario knocks the Boos away twice with the Super
by using the Spin Attack, the Boos will combine together to make the Atomic Boo.
Atomic Boo attacks by flinging Boos at Mario, charging up a powerful glare attack, hiding his face and becoming invisible like regular Boos, floating over and falling onto both Mario and his partner, and inflicting Mario with status ailments such as confusion and paralysis. Once Atomic Boo is defeated, he will relinquish his
to Mario and the Boos will stop their swarming and appear as normal enemies.
A purple variant of Atomic Boo, called Dark Atomic Boo, was , but cannot be encountered. It would have been fought on the 50th floor of the . It is reasonable to assume that Dark Atomic Boo would have been a more powerful version of Atomic Boo.
That's an Atomic Boo. That is one enormous Boo... Max HP is 10. Attack is 2. It will follow you until you turn around, then it just disappears... It has a lot of HP, so you may want to use an item when your back is turned... Some say this Boo is a huge, massive ball of many smaller Boos...
           95           
Atomic Boos are rare enemies in . In fact, only one appears in , where it is considerably weaker. This Atomic Boo will attempt to attack the player by charging at them while they are facing the direction opposite of them and will turn intangible and shy away if the player faces it. Also in Super Paper Mario, Atomic Boos will occasionally app though slower than regular Boos, Atomic Boos take several hits to defeat instead a single one.
the Atomic Boo is known as Big Boo. In this game, the Big Boo looks like a large, crumpled paper ball with a
face. The Big Boo only appears once in the entire game and is a mini-boss found in . It is created when
combines the
found in .
In battle, the Big Boo's only attack is eating Mario and then spitting him out. However, once the Big Boo uses its turn, the candles will come on and the Big Boo will turn invisible. During this time, Mario is unable to attack the Big Boo, but the Big Boo is still able to hurt Mario. In order to make the mini-boss visible again, a
with wind or water properties needs to be used in order to extinguish the candles. However, using a
with fire properties such as Matches and Lighter while the candle has been put out will light up the candle once more. Note that although the Big Boo is invisible while the candle is lit, it can still take damage from Spike Helmet or .
Once the Big Boo has been defeated, the
will stay on its pedestal and the mansion will be free of ghosts.
The Big Boo in Mario Pinball Land.
In , Big Boo is one of the four bosses. He appears in the haunted house at the Fun Fair. He has the last . To defeat him, Mario has to attack him from behind. He has no direct attacks, but instead approaches Mario continuously. If Mario comes into contact with Big Boo from the front, he will temporarily spin out of control as if in a daze.
The Big Boo from Super Princess Peach.
Big Boos also appear in . Unlike normal Boos, they are invincible. However, they can be stunned permanently by leading one to a ray of light, which only appears in World 3-2. When they are stunned, they are harmless and can be used to step on to reach a platform. This game also introduces a new Big Boos sub-species, the . A Mad Big Boo is a Big Boo under the 's power. Like normal , they stay still when Peach turns away from one, and chases after her when she looks at it.
Although Big Boo never made it in , King Boo's beta sprite was a Big Boo. There is also a boss in
named , an enormous
made of 15 other .
The Big Boo in Luigi's Mansion: Dark Moon.
is one of the three bosses fought in , the final mansion in the game, with the final one being King Boo himself. Luigi and E. Gadd were tricked by King Boo to come into the miniature train station inside the , because E. Gadd thought that
was there along with Mario's painting. Ten Boos are inside a mini train display in which they come together to form into Big Boo. The 10 Boos that assemble together are the only ghosts in the game who are not sucked into the , as they are trapped in the trains' cages and later placed in the
by E. Gadd.
In battle, the Big Boo has three attacks. Its first attack involves it trying to crush Luigi from above. It will attempt to crush Luigi three times in a row. If it misses all three times, it will be momentarily dazed. Its other attack involves hiding halfway in the ground and attempting to charge into Luigi from there. If it misses Luigi and hits the moving train, it will be stunned. However, if it misses Luigi and the train, it will just float back into the arena. When separated into individual Boos, they can ram into Luigi. The third attack happens only if Luigi pulls back on the tongue for too long. The Big Boo will get out of the stun and ram Luigi. This also applies for the Boos.
To defeat Big Boo, Luigi has two different methods of attacking it. The first one involves avoiding Big Boo while it slams into the ground three times before becoming stunned. Luigi has to pull Big Boo's tongue and launch it into the drill of the moving toy train. The other way is to make Big Boo dash slightly in front of the train. When the Big Boo hits the drill on the train, he splits into ten Boos. Luigi must pull their tongues and send them flying towards the carriages of the train. When one of them hits a carriage, that Boo gets imprisoned inside the carriage and will be unable to escape. Once all of Boos have been imprisoned in the carriages, the mission is complete and the
takes Luigi out of the train display and back to the . Afterwards, E. Gadd Pixelates the Boos into the Boo Canister.
Big Boos reappear in
with only a few tweaks from . While they act the same by following a Toad when they aren't being watched, they are far less a threat due to
headlamp, which can destroy them. To compensate for this, Big Boos generally appear in groups of two or more.
There is a boss in
that is an enormous
While Boolossus is made from fifteen Boos, the Atomic Boo from
is still smaller than Boolossus, even though it is made from two hundred Boos.
Boolossus and Atomic Boo have the same attack by trying to squish the player in
and , however, the Atomic Boo in
acts like a normal Boo.
As named in the Super Mario RPG: Legend of the Seven Stars manual.
Navigation menu
This page was last modified on 24 February 2015, at 16:44.There are four windows (
C.in_百度知道
There are four windows (
提问者采纳
C不要选BON指得是在墙的表面而窗子是嵌在墙&里面&的
其他类似问题
其他5条回答
b on the wall 在墙上
C，固定用法。类似的还有there are three birds in the tree.
C:in.因为窗户是镶嵌在墙里面的，所以应该用in.遇到窗户和门都选择in，窗帘或壁画类的才选择on，挂在墙的表面的~
C 窗户是镶嵌在墙里面的，用in，而on是只表面的
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁Pattern (Java Platform SE 7 )
JavaScript is disabled on your browser.
Class Pattern
java.util.regex.Pattern
All Implemented Interfaces:
public final class Pattern
implements
A compiled representation of a regular expression.
A regular expression, specified as a string, must first be compiled into
an instance of this class.
The resulting pattern can then be used to create
object that can match arbitrary
against the regular
expression.
All of the state involved in performing a match resides in the
matcher, so many matchers can share the same pattern.
A typical invocation sequence is thus
Pattern p = Pattern.("a*b");
Matcher m = p.("aaaaab");
boolean b = m.();
method is defined by this class as a
convenience for when a regular expression is used just once.
This method
compiles an expression and matches an input sequence against it in a single
invocation.
The statement
boolean b = Pattern.matches("a*b", "aaaaab");
is equivalent to the three statements above, though for repeated matches it
is less efficient since it does not allow the compiled pattern to be reused.
Instances of this class are immutable and are safe for use by multiple
concurrent threads.
Instances of the
class are not safe for
&&=&0xh...h&&=&nbsp
The tab character ('\u0009')
The newline (line feed) character ('\u000A')
The carriage-return character ('\u000D')
The form-feed character ('\u000C')
The alert (bell) character ('\u0007')
The escape character ('\u001B')
The control character corresponding to x
Character classes
a, b, or c (simple class)
Any character except a, b, or c (negation)
a through z
or A through Z, inclusive (range)
[a-d[m-p]]
a through d,
or m through p: [a-dm-p] (union)
[a-z&&[def]]
d, e, or f (intersection)
[a-z&&[^bc]]
a through z,
except for b and c: [ad-z] (subtraction)
[a-z&&[^m-p]]
a through z,
and not m through p: [a-lq-z](subtraction)
Predefined character classes
Any character (may or may not match )
A digit: [0-9]
A non-digit: [^0-9]
A whitespace character: [ \t\n\x0B\f\r]
A non-whitespace character: [^\s]
A word character: [a-zA-Z_0-9]
A non-word character: [^\w]
POSIX character classes (US-ASCII only)
A lower-case alphabetic character: [a-z]
An upper-case alphabetic character:[A-Z]
All ASCII:[\x00-\x7F]
An alphabetic character:[\p{Lower}\p{Upper}]
A decimal digit: [0-9]
An alphanumeric character:[\p{Alpha}\p{Digit}]
Punctuation: One of !"#$%&'()*+,-./:;?@[\]^_`{|}~
A visible character: [\p{Alnum}\p{Punct}]
A printable character: [\p{Graph}\x20]
A space or a tab: [ \t]
A control character: [\x00-\x1F\x7F]
\p{XDigit}
A hexadecimal digit: [0-9a-fA-F]
A whitespace character: [ \t\n\x0B\f\r]
java.lang.Character classes (simple )
\p{javaLowerCase}
Equivalent to java.lang.Character.isLowerCase()
\p{javaUpperCase}
Equivalent to java.lang.Character.isUpperCase()
\p{javaWhitespace}
Equivalent to java.lang.Character.isWhitespace()
\p{javaMirrored}
Equivalent to java.lang.Character.isMirrored()
Classes for Unicode scripts, blocks, categories and binary properties
* \p{IsLatin}
A Latin&script character ()
\p{InGreek}
A character in the Greek&block ()
An uppercase letter ()
\p{IsAlphabetic}
An alphabetic character ()
A currency symbol
\P{InGreek}
Any character except one in the Greek block (negation)
[\p{L}&&[^\p{Lu}]]&
Any letter except an uppercase letter (subtraction)
Boundary matchers
The beginning of a line
The end of a line
A word boundary
A non-word boundary
The beginning of the input
The end of the previous match
The end of the input but for the final
The end of the input
Greedy quantifiers
X, once or not at all
X, zero or more times
X, one or more times
X, exactly n times
X, at least n times
X, at least n but not more than m times
Reluctant quantifiers
X, once or not at all
X, zero or more times
X, one or more times
X, exactly n times
X, at least n times
X, at least n but not more than m times
Possessive quantifiers
X, once or not at all
X, zero or more times
X, one or more times
X, exactly n times
X, at least n times
X, at least n but not more than m times
Logical operators
X followed by Y
Either X or Y
Back references
Whatever the nth
Whatever the
"name" matched
Nothing, but quotes the following character
Nothing, but quotes all characters until \E
Nothing, but ends quoting started by \Q
Special constructs (named-capturing and non-capturing)
X, as a named-capturing group
X, as a non-capturing group
(?idmsuxU-idmsuxU)&
Nothing, but turns match flags
(?idmsux-idmsux:X)&&
given flags
X, via zero-width positive lookahead
X, via zero-width negative lookahead
X, via zero-width positive lookbehind
X, via zero-width negative lookbehind
X, as an independent, non-capturing group
mode is activated, then the only line terminators
recognized are newline characters.
The regular expression . matches any character except a line
terminator unless the
flag is specified.
By default, the regular expressions ^ and $ ignore
line terminators and only match at the beginning and the end, respectively,
of the entire input sequence. If
mode is activated then
^ matches at the beginning of input and after any line terminator
except at the end of input. When in
matches just before a line terminator or the end of the input sequence.
The captured input associated with a group is always the subsequence
that the group most recently matched.
If a group is evaluated a second time
because of quantification then its previously-captured value, if any, will
be retained if the second evaluation fails.
Matching the string
"aba" against the expression (a(b)?)+, for example, leaves
group two set to "b".
All captured input is discarded at the
beginning of each match.
Groups beginning with (? are either pure, non-capturing groups
that do not capture text and do not count towards the group total, or
named-capturing group.
Unicode support
This class is in conformance with Level 1 of Unicode Technical
Standard #18: Unicode Regular Expression, plus RL2.1
Canonical Equivalents.
Unicode escape sequences such as \u2014 in Java source code
are processed as described in section 3.3 of
The Java& Language Specification.
Such escape sequences are also implemented directly by the regular-expression
parser so that Unicode escapes can be used in expressions that are read from
files or from the keyboard.
Thus the strings "\u2014" and
"\\u2014", while not equal, compile into the same pattern, which
matches the character with hexadecimal value 0x2014.
A Unicode character can also be represented in a regular-expression by
using its Hex notation(hexadecimal code point value) directly as described in construct
\x{...}, for example a supplementary character U+2011F
can be specified as \x{2011F}, instead of two consecutive
Unicode escape sequences of the surrogate pair
\uD840\uDD1F.
Unicode scripts, blocks, categories and binary properties are written with
the \p and \P constructs as in Perl.
\p{prop} matches if
the input has the property prop, while \P{prop}
does not match if the input has that property.
Scripts, blocks, categories and binary properties can be used both inside
and outside of a character class.
in the version specified by the
class. The category names are those
defined in the Standard, both normative and informative.
flag is specified.
A lowercase character:\p{IsLowercase}
An uppercase character:\p{IsUppercase}
All ASCII:[\x00-\x7F]
An alphabetic character:\p{IsAlphabetic}
A decimal digit character:p{IsDigit}
An alphanumeric character:[\p{IsAlphabetic}\p{IsDigit}]
A punctuation character:p{IsPunctuation}
A visible character: [^\p{IsWhite_Space}\p{gc=Cc}\p{gc=Cs}\p{gc=Cn}]
A printable character: [\p{Graph}\p{Blank}&&[^\p{Cntrl}]]
A space or a tab: [\p{IsWhite_Space}&&[^\p{gc=Zl}\p{gc=Zp}\x0a\x0b\x0c\x0d\x85]]
A control character: \p{gc=Cc}
\p{XDigit}
A hexadecimal digit: [\p{gc=Nd}\p{IsHex_Digit}]
A whitespace character:\p{IsWhite_Space}
A digit: \p{IsDigit}
A non-digit: [^\d]
A whitespace character: \p{IsWhite_Space}
A non-whitespace character: [^\s]
A word character: [\p{Alpha}\p{gc=Mn}\p{gc=Me}\p{gc=Mc}\p{Digit}\p{gc=Pc}]
A non-word character: [^\w]
The backreference constructs, \g{n} for
the nth and
\g{name} for
The named character construct, \N{name}
for a Unicode character by its name.
The conditional constructs
(?(condition)X) and
(?(condition)X|Y),
The embedded code constructs (?{code})
and (??{code}),
The embedded comment syntax (?#comment), and
The preprocessing operations \l \u,
\L, and \U.
Constructs supported by this class but not by Perl:
Character-class union and intersection as described
Notable differences from Perl:
In Perl, \1 through \9 are always interpreted
a backslash-escaped number greater than 9 is
treated as a back reference if at least that many subexpressions exist,
otherwise it is interpreted, if possible, as an octal escape.
class octal escapes must always begin with a zero. In this class,
\1 through \9 are always interpreted as back
references, and a larger number is accepted as a back reference if at
least that many subexpressions exist at that point in the regular
expression, otherwise the parser will drop digits until the number is
smaller or equal to the existing number of groups or it is one digit.
Perl uses the g flag to request a match that resumes
where the last match left off.
This functionality is provided implicitly
class: Repeated invocations of the
method will resume where the last match left off,
unless the matcher is reset.
In Perl, embedded flags at the top level of an expression affect
the whole expression.
In this class, embedded flags always take effect
at the point at which they appear, whether they are at the top level or
in the latter case, flags are restored at the end of the
group just as in Perl.
For a more precise description of the behavior of regular expression
constructs, please see
See Also:,
Field Summary
Modifier and Type
Field and Description
static int
Enables canonical equivalence.
static int
Enables case-insensitive matching.
static int
Permits whitespace and comments in pattern.
static int
Enables dotall mode.
static int
Enables literal parsing of the pattern.
static int
Enables multiline mode.
static int
Enables Unicode-aware case folding.
static int
Enables the Unicode version of Predefined character classes and
POSIX character classes.
static int
Enables Unix lines mode.
Method Summary
Modifier and Type
Method and Description
Compiles the given regular expression into a pattern.
int&flags)
Compiles the given regular expression into a pattern with the given
Returns this pattern's match flags.
Creates a matcher that will match the given input against this pattern.
static boolean
Compiles the given regular expression and attempts to match the given
input against it.
Returns the regular expression from which this pattern was compiled.
Returns a literal pattern String for the specified
Splits the given input sequence around matches of this pattern.
int&limit)
Splits the given input sequence around matches of this pattern.
Returns the string representation of this pattern.
Methods inherited from class&java.lang.
, , , , , , , , ,
Field Detail
UNIX_LINES
public static final&int UNIX_LINES
Enables Unix lines mode.
In this mode, only the '\n' line terminator is recognized
in the behavior of ., ^, and $.
Unix lines mode can also be enabled via the embedded flag
expression&(?d).
CASE_INSENSITIVE
public static final&int CASE_INSENSITIVE
Enables case-insensitive matching.
By default, case-insensitive matching assumes that only characters
in the US-ASCII charset are being matched.
Unicode-aware
case-insensitive matching can be enabled by specifying the
flag in conjunction with this flag.
Case-insensitive matching can also be enabled via the embedded flag
expression&(?i).
Specifying this flag may impose a slight performance penalty.
public static final&int COMMENTS
Permits whitespace and comments in pattern.
In this mode, whitespace is ignored, and embedded comments starting
with # are ignored until the end of a line.
Comments mode can also be enabled via the embedded flag
expression&(?x).
public static final&int MULTILINE
Enables multiline mode.
In multiline mode the expressions ^ and $ match
just after or just before, respectively, a line terminator or the end of
the input sequence.
By default these expressions only match at the
beginning and the end of the entire input sequence.
Multiline mode can also be enabled via the embedded flag
expression&(?m).
public static final&int LITERAL
Enables literal parsing of the pattern.
When this flag is specified then the input string that specifies
the pattern is treated as a sequence of literal characters.
Metacharacters or escape sequences in the input sequence will be
given no special meaning.
The flags CASE_INSENSITIVE and UNICODE_CASE retain their impact on
matching when used in conjunction with this flag. The other flags
become superfluous.
There is no embedded flag character for enabling literal parsing.
public static final&int DOTALL
Enables dotall mode.
In dotall mode, the expression . matches any character,
including a line terminator.
By default this expression does not match
line terminators.
Dotall mode can also be enabled via the embedded flag
expression&(?s).
(The s is a mnemonic for
"single-line" mode, which is what this is called in Perl.)
UNICODE_CASE
public static final&int UNICODE_CASE
Enables Unicode-aware case folding.
When this flag is specified then case-insensitive matching, when
enabled by the
flag, is done in a manner
consistent with the Unicode Standard.
By default, case-insensitive
matching assumes that only characters in the US-ASCII charset are being
Unicode-aware case folding can also be enabled via the embedded flag
expression&(?u).
Specifying this flag may impose a performance penalty.
public static final&int CANON_EQ
Enables canonical equivalence.
When this flag is specified then two characters will be considered
to match if, and only if, their full canonical decompositions match.
The expression "a\u030A", for example, will match the
string "\u00E5" when this flag is specified.
By default,
matching does not take canonical equivalence into account.
There is no embedded flag character for enabling canonical
equivalence.
Specifying this flag may impose a performance penalty.
UNICODE_CHARACTER_CLASS
public static final&int UNICODE_CHARACTER_CLASS
Enables the Unicode version of Predefined character classes and
POSIX character classes.
When this flag is specified then the (US-ASCII only)
Predefined character classes and POSIX character classes
are in conformance with
Annex C: Compatibility Properties.
The UNICODE_CHARACTER_CLASS mode can also be enabled via the embedded
flag expression&(?U).
The flag implies UNICODE_CASE, that is, it enables Unicode-aware case
Specifying this flag may impose a performance penalty.
Method Detail
public static&&compile(&regex)
Compiles the given regular expression into a pattern.
Parameters:regex - The expression to be compiled
- If the expression's syntax is invalid
public static&&compile(&regex,
int&flags)
Compiles the given regular expression into a pattern with the given
Parameters:regex - The expression to be compiledflags - Match flags, a bit mask that may include
- If bit values other than those corresponding to the defined
match flags are set in flags
- If the expression's syntax is invalid
public&&pattern()
Returns the regular expression from which this pattern was compiled.
Returns:The source of this pattern
public&&toString()
Returns the string representation of this pattern. This
is the regular expression from which this pattern was
Overrides:
&in class&
Returns:The string representation of this patternSince:
public&&matcher(&input)
Creates a matcher that will match the given input against this pattern.
Parameters:input - The character sequence to be matched
Returns:A new matcher for this pattern
public&int&flags()
Returns this pattern's match flags.
Returns:The match flags specified when this pattern was compiled
public static&boolean&matches(&regex,
Compiles the given regular expression and attempts to match the given
input against it.
An invocation of this convenience method of the form
Pattern.matches(regex, input);
behaves in exactly the same way as the expression
pile(regex).matcher(input).matches()
If a pattern is to be used multiple times, compiling it once and reusing
it will be more efficient than invoking this method each time.
Parameters:regex - The expression to be compiledinput - The character sequence to be matched
- If the expression's syntax is invalid
public&[]&split(&input,
int&limit)
Splits the given input sequence around matches of this pattern.
The array returned by this method contains each substring of the
input sequence that is terminated by another subsequence that matches
this pattern or is terminated by the end of the input sequence.
substrings in the array are in the order in which they occur in the
If this pattern does not match any subsequence of the input then
the resulting array has just one element, namely the input sequence in
string form.
The limit parameter controls the number of times the
pattern is applied and therefore affects the length of the resulting
If the limit n is greater than zero then the pattern
will be applied at most n&-&1 times, the array's
length will be no greater than n, and the array's last entry
will contain all input beyond the last matched delimiter.
is non-positive then the pattern will be applied as many times as
possible and the array can have any length.
If n is zero then
the pattern will be applied as many times as possible, the array can
have any length, and trailing empty strings will be discarded.
The input "boo:and:foo", for example, yields the following
results with these parameters:
Result&&&&
{ "boo", "and:foo" }
{ "boo", "and", "foo" }
{ "boo", "and", "foo" }
{ "b", "", ":and:f", "", "" }
{ "b", "", ":and:f", "", "" }
{ "b", "", ":and:f" }
Parameters:input - The character sequence to be splitlimit - The result threshold, as described above
Returns:The array of strings computed by splitting the input
around matches of this pattern
public&[]&split(&input)
Splits the given input sequence around matches of this pattern.
This method works as if by invoking the two-argument
method with the given input
sequence and a limit argument of zero.
Trailing empty strings are
therefore not included in the resulting array.
The input "boo:and:foo", for example, yields the following
results with these expressions:
{ "boo", "and", "foo" }
{ "b", "", ":and:f" }
Parameters:input - The character sequence to be split
Returns:The array of strings computed by splitting the input
around matches of this pattern
public static&&quote(&s)
Returns a literal pattern String for the specified
This method produces a String that can be used to
create a Pattern that would match the string
s as if it were a literal pattern. Metacharacters
or escape sequences in the input sequence will be given no special
Parameters:s - The string to be literalized
Returns:A literal string replacementSince:
For further API reference and developer documentation, see . That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
© , Oracle and/or its affiliates.
All rights reserved.
Scripting on this page tracks web page traffic, but does not change the content in any way.