java.lang.Object | |
↳ | javax.swing.RowFilter<M, I> |
RowFilter
is used to filter out entries from the
model so that they are not shown in the view. For example, a
RowFilter
associated with a JTable
might
only allow rows that contain a column with a specific string. The
meaning of entry depends on the component type.
For example, when a filter is
associated with a JTable
, an entry corresponds to a
row; when associated with a JTree
, an entry corresponds
to a node.
Subclasses must override the include
method to
indicate whether the entry should be shown in the
view. The Entry
argument can be used to obtain the values in
each of the columns in that entry. The following example shows an
include
method that allows only entries containing one or
more values starting with the string "a":
RowFilter<Object,Object> startsWithAFilter = new RowFilter<Object,Object>() { public boolean include(Entry<? extends Object, ? extends Object> entry) { for (int i = entry.getValueCount() - 1; i >= 0; i--) { if (entry.getStringValue(i).startsWith("a")) { // The value starts with "a", include it return true; } } // None of the columns start with "a"; return false so that this // entry is not shown return false; } };
RowFilter
has two formal type parameters that allow
you to create a RowFilter
for a specific model. For
example, the following assumes a specific model that is wrapping
objects of type Person
. Only Person
s
with an age over 20 will be shown:
RowFilter<PersonModel,Integer> ageFilter = new RowFilter<PersonModel,Integer>() { public boolean include(Entry<? extends PersonModel, ? extends Integer> entry) { PersonModel personModel = entry.getModel(); Person person = personModel.getPerson(entry.getIdentifier()); if (person.getAge() > 20) { // Returning true indicates this row should be shown. return true; } // Age is <= 20, don't show it. return false; } }; PersonModel model = createPersonModel(); TableRowSorter<PersonModel> sorter = new TableRowSorter<PersonModel>(model); sorter.setRowFilter(ageFilter);
Nested Classes | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
RowFilter.ComparisonType | Enumeration of the possible comparison values supported by
some of the default RowFilter s. |
||||||||||
RowFilter.Entry<M, I> | An Entry object is passed to instances of
RowFilter , allowing the filter to get the value of the
entry's data, and thus to determine whether the entry should be shown. |
Public Constructors | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Public Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Returns a
RowFilter that includes entries if all
of the supplied filters include the entry. | |||||||||||
Returns a
RowFilter that includes entries that
have at least one Date value meeting the specified
criteria. | |||||||||||
Returns true if the specified entry should be shown;
returns false if the entry should be hidden.
| |||||||||||
Returns a
RowFilter that includes entries if the
supplied filter does not include the entry. | |||||||||||
Returns a
RowFilter that includes entries that
have at least one Number value meeting the
specified criteria. | |||||||||||
Returns a
RowFilter that includes entries if any
of the supplied filters includes the entry. | |||||||||||
Returns a
RowFilter that uses a regular
expression to determine which entries to include. |
[Expand]
Inherited Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From class
java.lang.Object
|
Returns a RowFilter
that includes entries if all
of the supplied filters include the entry.
The following example creates a RowFilter
that will
include any entries containing the string "foo" and the string
"bar":
List<RowFilter<Object,Object>> filters = new ArrayList<RowFilter<Object,Object>>(2); filters.add(RowFilter.regexFilter("foo")); filters.add(RowFilter.regexFilter("bar")); RowFilter<Object,Object> fooBarFilter = RowFilter.andFilter(filters);
filters | the RowFilter s to test |
---|
RowFilter
implementing the specified criteriaIllegalArgumentException | if any of the filters
are null |
---|---|
NullPointerException | if filters is null |
Returns a RowFilter
that includes entries that
have at least one Date
value meeting the specified
criteria. For example, the following RowFilter
includes
only entries with at least one date value after the current date:
RowFilter.dateFilter(ComparisonType.AFTER, new Date());
type | the type of comparison to perform |
---|---|
date | the date to compare against |
indices | the indices of the values to check. If not supplied all values are evaluated |
RowFilter
implementing the specified criteriaNullPointerException | if date is
null |
---|---|
IllegalArgumentException | if any of the indices
are < 0 or type is
null |
Returns true if the specified entry should be shown; returns false if the entry should be hidden.
The entry
argument is valid only for the duration of
the invocation. Using entry
after the call returns
results in undefined behavior.
entry | a non-null object that wraps the underlying
object from the model |
---|
Returns a RowFilter
that includes entries if the
supplied filter does not include the entry.
filter | the RowFilter to negate |
---|
RowFilter
implementing the specified criteriaIllegalArgumentException | if filter is
null
|
---|
Returns a RowFilter
that includes entries that
have at least one Number
value meeting the
specified criteria. For example, the following
filter will only include entries with at
least one number value equal to 10:
RowFilter.numberFilter(ComparisonType.EQUAL, 10);
type | the type of comparison to perform |
---|---|
indices | the indices of the values to check. If not supplied all values are evaluated |
RowFilter
implementing the specified criteriaIllegalArgumentException | if any of the indices
are < 0, type is null
or number is null
|
---|
Returns a RowFilter
that includes entries if any
of the supplied filters includes the entry.
The following example creates a RowFilter
that will
include any entries containing the string "foo" or the string
"bar":
List<RowFilter<Object,Object>> filters = new ArrayList<RowFilter<Object,Object>>(2); filters.add(RowFilter.regexFilter("foo")); filters.add(RowFilter.regexFilter("bar")); RowFilter<Object,Object> fooBarFilter = RowFilter.orFilter(filters);
filters | the RowFilter s to test |
---|
RowFilter
implementing the specified criteriaIllegalArgumentException | if any of the filters
are null |
---|---|
NullPointerException | if filters is null |
Returns a RowFilter
that uses a regular
expression to determine which entries to include. Only entries
with at least one matching value are included. For
example, the following creates a RowFilter
that
includes entries with at least one value starting with
"a":
RowFilter.regexFilter("^a");
The returned filter uses find()
to test for inclusion. To test for exact matches use the
characters '^' and '$' to match the beginning and end of the
string respectively. For example, "^foo$" includes only rows whose
string is exactly "foo" and not, for example, "food". See
Pattern
for a complete description of
the supported regular-expression constructs.
regex | the regular expression to filter on |
---|---|
indices | the indices of the values to check. If not supplied all values are evaluated |
RowFilter
implementing the specified criteriaNullPointerException | if regex is
null |
---|---|
IllegalArgumentException | if any of the indices
are < 0 |
if regex is
not a valid regular expression. |