Package Summary Overview Summary

### class:RowFilter [NONE]
- Type Parameters: `M` - the type of the model; for example `PersonModel` `I` - the type of the identifier; when using `TableRowSorter` this will be `Integer`
      public abstract class RowFilter<M,I>
      extends Object
  `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);
Since: 1.6 See Also: `TableRowSorter`

### constructor:RowFilter() [NONE]
- #### RowFilter
      public RowFilter()

### method:regexFilter(java.lang.String, int...) [NONE]
- #### regexFilter
      public static <M,I> RowFilter<M,I> regexFilter(String regex,
                                                     int... indices)
  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 `Matcher.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. Type Parameters: `M` - the type of the model to which the `RowFilter` applies `I` - the type of the identifier passed to the `RowFilter` Parameters: `regex` - the regular expression to filter on `indices` - the indices of the values to check. If not supplied all values are evaluated Returns: a `RowFilter` implementing the specified criteria Throws: `NullPointerException` - if `regex` is `null` `IllegalArgumentException` - if any of the `indices` are < 0 `PatternSyntaxException` - if `regex` is not a valid regular expression. See Also: `Pattern`

### method:dateFilter(javax.swing.RowFilter.ComparisonType, java.util.Date, int...) [NONE]
- #### dateFilter
      public static <M,I> RowFilter<M,I> dateFilter(RowFilter.ComparisonType type,
                                                    Date date,
                                                    int... indices)
  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 Parameters: `M` - the type of the model to which the `RowFilter` applies `I` - the type of the identifier passed to the `RowFilter` Parameters: `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 Returns: a `RowFilter` implementing the specified criteria Throws: `NullPointerException` - if `date` is `null` `IllegalArgumentException` - if any of the `indices` are < 0 or `type` is `null` See Also: `Calendar`, `Date`

### method:numberFilter(javax.swing.RowFilter.ComparisonType, java.lang.Number, int...) [NONE]
- #### numberFilter
      public static <M,I> RowFilter<M,I> numberFilter(RowFilter.ComparisonType type,
                                                      Number number,
                                                      int... indices)
  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 Parameters: `M` - the type of the model to which the `RowFilter` applies `I` - the type of the identifier passed to the `RowFilter` Parameters: `type` - the type of comparison to perform `number` - a `Number` value to compare against `indices` - the indices of the values to check. If not supplied all values are evaluated Returns: a `RowFilter` implementing the specified criteria Throws: `IllegalArgumentException` - if any of the `indices` are < 0, `type` is `null` or `number` is `null`

### method:orFilter(java.lang.Iterable) [NONE]
- #### orFilter
      public static <M,I> RowFilter<M,I> orFilter(Iterable<? extends RowFilter<? super M,? super I>> filters)
  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);
Type Parameters: `M` - the type of the model to which the `RowFilter` applies `I` - the type of the identifier passed to the `RowFilter` Parameters: `filters` - the `RowFilter`s to test Returns: a `RowFilter` implementing the specified criteria Throws: `IllegalArgumentException` - if any of the filters are `null` `NullPointerException` - if `filters` is null See Also: `Arrays.asList(T...)`

### method:andFilter(java.lang.Iterable) [NONE]
- #### andFilter
      public static <M,I> RowFilter<M,I> andFilter(Iterable<? extends RowFilter<? super M,? super I>> filters)
  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);
Type Parameters: `M` - the type of the model the `RowFilter` applies to `I` - the type of the identifier passed to the `RowFilter` Parameters: `filters` - the `RowFilter`s to test Returns: a `RowFilter` implementing the specified criteria Throws: `IllegalArgumentException` - if any of the filters are `null` `NullPointerException` - if `filters` is null See Also: `Arrays.asList(T...)`

### method:notFilter(javax.swing.RowFilter) [NONE]
- #### notFilter
      public static <M,I> RowFilter<M,I> notFilter(RowFilter<M,I> filter)
Returns a `RowFilter` that includes entries if the supplied filter does not include the entry. Type Parameters: `M` - the type of the model to which the `RowFilter` applies `I` - the type of the identifier passed to the `RowFilter` Parameters: `filter` - the `RowFilter` to negate Returns: a `RowFilter` implementing the specified criteria Throws: `IllegalArgumentException` - if `filter` is `null`

### method:include(javax.swing.RowFilter.Entry) [NONE]
- #### include
      public abstract boolean include(RowFilter.Entry<? extends M,? extends I> entry)
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. Parameters: `entry` - a non-`null` object that wraps the underlying object from the model Returns: true if the entry should be shown