java.util.regex
Class Pattern

java.lang.Object
  java.util.regex.Pattern

All Implemented Interfaces:

Serializable

public final class Pattern

extends Object

implements Serializable

Nested Class Summary
(package private) static class	Pattern.Add
(package private) static class	Pattern.All
(package private) static class	Pattern.BackRef
(package private) static class	Pattern.Begin
(package private) static class	Pattern.Behind
(package private) static class	Pattern.BitClass
(package private) static class	Pattern.BnM
(package private) static class	Pattern.Both
(package private) static class	Pattern.Bound
(package private) static class	Pattern.Branch
(package private) static class	Pattern.Caret
(package private) static class	Pattern.Category
(package private) static class	Pattern.CIBackRef
(package private) static class	Pattern.CINotRange
(package private) static class	Pattern.CIRange
(package private) static class	Pattern.Conditional
(package private) static class	Pattern.Ctype
(package private) static class	Pattern.Curly
(package private) static class	Pattern.Dollar
(package private) static class	Pattern.Dot
(package private) static class	Pattern.Dummy
(package private) static class	Pattern.End
(package private) static class	Pattern.First
(package private) static class	Pattern.GroupCurly
(package private) static class	Pattern.GroupHead
(package private) static class	Pattern.GroupRef
(package private) static class	Pattern.GroupTail
(package private) static class	Pattern.LastMatch
(package private) static class	Pattern.LastNode
(package private) static class	Pattern.LazyLoop
(package private) static class	Pattern.Loop
(package private) static class	Pattern.Neg
(package private) static class	Pattern.Node
(package private) static class	Pattern.Not
(package private) static class	Pattern.NotBehind
(package private) static class	Pattern.NotCtype
(package private) static class	Pattern.NotRange
(package private) static class	Pattern.NotSingle
(package private) static class	Pattern.NotSingleA
(package private) static class	Pattern.NotSingleU
(package private) static class	Pattern.Pos
(package private) static class	Pattern.Prolog
(package private) static class	Pattern.Ques
(package private) static class	Pattern.Range
(package private) static class	Pattern.Single
(package private) static class	Pattern.SingleA
(package private) static class	Pattern.SingleU
(package private) static class	Pattern.Slice
(package private) static class	Pattern.SliceA
(package private) static class	Pattern.SliceU
(package private) static class	Pattern.Specials
(package private) static class	Pattern.Start
(package private) static class	Pattern.Sub
(package private) static class	Pattern.TreeInfo
(package private) static class	Pattern.UnixCaret
(package private) static class	Pattern.UnixDollar
(package private) static class	Pattern.UnixDot

 

Field Summary
(package private) static Pattern.Node	accept
(package private)  char[]	buffer
static int	CANON_EQ
static int	CASE_INSENSITIVE
(package private) static HashMap	categories
private static String[]	categoryNames
private static Pattern.Node[]	categoryNodes
static int	COMMENTS
private  boolean	compiled
private  int	cursor
static int	DOTALL
(package private) static HashMap	families
private static String[]	familyNames
private static Pattern.Node[]	familyNodes
private  int	flags
(package private) static int	GREEDY
(package private)  int	groupCount
(package private)  Pattern.GroupHead[]	groupNodes
(package private) static int	INDEPENDENT
(package private) static Pattern.Node	lastAccept
(package private) static int	LAZY
(package private)  int	localCount
(package private)  Pattern.Node	matchRoot
(package private) static int	MAX_REPS
static int	MULTILINE
private  String	normalizedPattern
private  String	pattern
private  int	patternLength
(package private) static int	POSSESSIVE
(package private)  Pattern.Node	root
private static long	serialVersionUID
private  char[]	temp
static int	UNICODE_CASE
static int	UNIX_LINES

 

Constructor Summary
private	Pattern(String, int)

 

Method Summary
private  void	accept(int, String)
private  void	addFlag()
private  void	append(int, int)
private  Pattern.Node	atom()
private  int	c()
private  Pattern.Node	clazz(boolean)
private  Pattern.Node	closure(Pattern.Node)
private  void	compile()
static Pattern	compile(String)
static Pattern	compile(String, int)
private  String	composeOneStep(String)
private  Pattern.Node	createGroup(boolean)
private  Pattern.Node	error(String)
private  int	escape(boolean, boolean)
private  Pattern.Node	expr(Pattern.Node)
private  Pattern.Node	family(boolean, boolean)
private  Pattern.Node	familyError(String, String)
int	flags()
private  int	getClass(char)
private  Pattern.Node	group0()
private  boolean	has(int)
private  boolean	isLineSeparator(int)
private  void	mark(char)
Matcher	matcher(CharSequence)
static boolean	matches(String, CharSequence)
private  Pattern.Node	newSingle(int)
private  Pattern.Node	newSlice(char[], int)
private  int	next()
private  int	nextEscaped()
private  void	normalize()
private  int	normalizeCharClass(StringBuffer, int)
private  int	o()
private  int	parsePastLine()
private  int	parsePastWhitespace(int)
String	pattern()
private  int	peek()
private  int	peekPastLine()
private  int	peekPastWhitespace(int)
private static void	printObjectTree(Pattern.Node)
private  String	produceEquivalentAlternation(String)
private  String[]	producePermutations(String)
private  Pattern.Node	range(Pattern.BitClass)
private  int	read()
private  int	readEscaped()
private  void	readObject(ObjectInputStream)
private  Pattern.Node	ref(int)
private  Pattern.Node	retrieveCategoryNode(String)
private  Pattern.Node	retrieveFamilyNode(String)
private  Pattern.Node	sequence(Pattern.Node)
private  int	single()
private  int	skip()
String[]	split(CharSequence)
String[]	split(CharSequence, int)
private  void	subFlag()
private  int	u()
private  void	unread()
private  int	x()

 

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

 

Field Detail

matchRoot

transient Pattern.Node matchRoot

CANON_EQ

public static final int CANON_EQ

DOTALL

public static final int DOTALL

root

transient Pattern.Node root

groupCount

transient int groupCount

patternLength

private transient int patternLength

categoryNodes

private static final Pattern.Node[] categoryNodes

INDEPENDENT

static final int INDEPENDENT

temp

private transient char[] temp

MAX_REPS

static final int MAX_REPS

buffer

transient char[] buffer

UNICODE_CASE

public static final int UNICODE_CASE

MULTILINE

public static final int MULTILINE

GREEDY

static final int GREEDY

normalizedPattern

private transient String normalizedPattern

CASE_INSENSITIVE

public static final int CASE_INSENSITIVE

POSSESSIVE

static final int POSSESSIVE

groupNodes

transient Pattern.GroupHead[] groupNodes

compiled

private transient volatile boolean compiled

familyNodes

private static final Pattern.Node[] familyNodes

categoryNames

private static final String[] categoryNames

families

static HashMap families

lastAccept

static Pattern.Node lastAccept

categories

static HashMap categories

flags

private int flags

cursor

private transient int cursor

familyNames

private static final String[] familyNames

localCount

transient int localCount

UNIX_LINES

public static final int UNIX_LINES

accept

static Pattern.Node accept

COMMENTS

public static final int COMMENTS

serialVersionUID

private static final long serialVersionUID

LAZY

static final int LAZY

pattern

private String pattern

Pattern

private Pattern(String,
                int)

c

private int c()

flags

public int flags()

next

private int next()

nextEscaped

private int nextEscaped()

o

private int o()

parsePastLine

private int parsePastLine()

peek

private int peek()

peekPastLine

private int peekPastLine()

read

private int read()

readEscaped

private int readEscaped()

single

private int single()

skip

private int skip()

u

private int u()

x

private int x()

addFlag

private void addFlag()

compile

private void compile()

normalize

private void normalize()

subFlag

private void subFlag()

unread

private void unread()

getClass

private int getClass(char)

mark

private void mark(char)

parsePastWhitespace

private int parsePastWhitespace(int)

peekPastWhitespace

private int peekPastWhitespace(int)

has

private boolean has(int)

isLineSeparator

private boolean isLineSeparator(int)

append

private void append(int,
                    int)

escape

private int escape(boolean,
                   boolean)

readObject

private void readObject(ObjectInputStream)
                 throws IOException,
                        ClassNotFoundException

Throws:

IOException

ClassNotFoundException

pattern

public String pattern()

accept

private void accept(int,
                    String)

normalizeCharClass

private int normalizeCharClass(StringBuffer,
                               int)

atom

private Pattern.Node atom()

group0

private Pattern.Node group0()

newSingle

private Pattern.Node newSingle(int)

ref

private Pattern.Node ref(int)

printObjectTree

private static void printObjectTree(Pattern.Node)

clazz

private Pattern.Node clazz(boolean)

createGroup

private Pattern.Node createGroup(boolean)

family

private Pattern.Node family(boolean,
                            boolean)

newSlice

private Pattern.Node newSlice(char[],
                              int)

matches

public static boolean matches(String,
                              CharSequence)

split

public String[] split(CharSequence)

split

public String[] split(CharSequence,
                      int)

composeOneStep

private String composeOneStep(String)

produceEquivalentAlternation

private String produceEquivalentAlternation(String)

producePermutations

private String[] producePermutations(String)

matcher

public Matcher matcher(CharSequence)

compile

public static Pattern compile(String)

compile

public static Pattern compile(String,
                              int)

error

private Pattern.Node error(String)

retrieveCategoryNode

private Pattern.Node retrieveCategoryNode(String)

retrieveFamilyNode

private Pattern.Node retrieveFamilyNode(String)

range

private Pattern.Node range(Pattern.BitClass)

closure

private Pattern.Node closure(Pattern.Node)

expr

private Pattern.Node expr(Pattern.Node)

sequence

private Pattern.Node sequence(Pattern.Node)

familyError

private Pattern.Node familyError(String,
                                 String)