Sortowanie i filtrowanie tabel.
Techniki łatwego ponownego użycia

1.  Sort - najprościej

tabela.setAutoCreateRowSorter(true);

public class Tab1 extends JFrame implements ActionListener {
  
  public Tab1() {
    setDefaultCloseOperation(EXIT_ON_CLOSE);

    // Dane przykładowej tabeli
    Object[][] data = { { "Chopin Fryderyk",  "M", 1789 }, 
                        { "Kopernik Mikołaj", "M", 2900 },
                        { "Słowacki Juliusz", "M",  2000 },
                        { "Szymborska Wisława", "K", 5200 },
                        { "Polański Roman", "M", 3000 },
                        { "Skłodowska-Curie Maria", "K",  2000 },
                        { "Modrzejewska Helena", "K", 2000 },
                      };
    // Nazwy kolumn
    String[] columnNames = { "Nazwisko i imię", "Płeć", "Pensja" };
        
    JTable tab = new JTable(data, columnNames);
    tab.setAutoCreateRowSorter(true);
    add (new JScrollPane(tab));
    pack();
    setVisible(true);
  }


  public static void main(String[] args) {
    new Tab1();
  }  
  
}

2. Klucze sortowania

• zmienia porządek sortowania podanej kolumny (jeśli dane nie były posortowane to porządek będzie rosnący, jeśli były - następuje przełączenie  rosnąco <-> malejąco.
• ustala jako główny klucz sortowania podaną kolumnę - czyli jeśli lista kluczy jest pusta - wpisuje na nią SortKey z indeksem kolumny i określonym porządkiem, a jeśli na liście są już klucze (dane były wcześniej posortowane według innej kolumny), to dopisuje nowy klucz na początku listy,
• wywołuje metodę setSortKeys(List), która ustala przekazaną listę kluczy jako obowiązująca i wywołuje faktyczne sortowanie (metodę sort()).

public class Tab2 extends JFrame  {
  
  public Tab2() {
    Object[][] data = { { "Chopin Fryderyk",  "M", 1789 },
                        { "Chopin Fryderyk",  "M", 3000 },
                        { "Kopernik Mikołaj", "M", 2900 },
                        { "Słowacki Juliusz", "M",  2000 },
                        { "Szymborska Wisława", "K", 3200 },
                        { "Polański Roman", "M", 3000 },
                        { "Skłodowska-Curie Maria", "K",  2000 },
                        { "Skłodowska-Curie Maria", "K",  3000 },
                        { "Modrzejewska Helena", "K", 2000 },
    };
    String[] columnNames = { "Nazwisko i imię", "Płeć", "Pensja" };
        
    final JTable tab = new JTable(data, columnNames);
    tab.setAutoCreateRowSorter(true);
    
    final JTextArea report = new JTextArea(20, 40);

    // Nasłuch kliknięć w kolumny
    tab.getTableHeader().addMouseListener( 
        new MouseAdapter() {
          @Override
          public void mouseClicked(MouseEvent e) {
            JTableHeader head = (JTableHeader) e.getSource(); 
            int col = head.columnAtPoint(e.getPoint());
            report.append("Kliknięcie w kolumnę '" + tab.getColumnName(col) + 
                          "'\nDane posortowane wg:\n" );
            TableRowSorter tsorter = (TableRowSorter) tab.getRowSorter();
            List<SortKey> sortKeys =  tsorter.getSortKeys();
            for (SortKey key : sortKeys) {
              report.append("-- " +tab.getColumnName(key.getColumn()) + 
                            " w porządku " + key.getSortOrder() + '\n' );
            }

          }    
        }
    );

    tab.setPreferredScrollableViewportSize(tab.getPreferredSize());
    add (new JScrollPane(tab), "North");
    add(new JScrollPane(report));
    
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    pack();
    setLocationRelativeTo(null);
    setVisible(true);
  }

  public static void main(String[] args) {
    new Tab2();
  }
  
}

• aktualnego sortera tabeli (metoda getRowSorter() z klasy JTable),
• listy kluczy sortowania (metoda getSortKeys() z klasy DefaultRowSorter),
• zawartości kluczy (metody getColumn() i getSortOrder() z klasy SortKey).

            TableRowSorter<? extends TableModel> tsorter = 
              (TableRowSorter<? extends TableModel>) tab.getRowSorter();
            List<? extends SortKey> sortKeys =  tsorter.getSortKeys();

            tsorter.toggleSortOrder(2);
            tsorter.toggleSortOrder(0);
            tsorter.toggleSortOrder(1);
            tsorter.toggleSortOrder(1);

 // sortowanie po kluczach
 List<SortKey> sortKeys = Arrays.asList(
     new SortKey[] {
         new SortKey(1, SortOrder.DESCENDING),  // po płci - malejąco
         new SortKey(0, SortOrder.ASCENDING),   // następnie po nazwisku rosnąco
         new SortKey(2, SortOrder.ASCENDING),   // następnie po pensji rosnąco
     });
 tsorter.setSortKeys(sortKeys);       

// Przywrócenie niuporządkowanego stanu danych              
TableRowSorter tsorter = (TableRowSorter) tab.getRowSorter();
List<SortKey> sortKeys =  new ArrayList<SortKey>();
tsorter.setSortKeys(sortKeys);

    // Znieść sortowalnośc kolumn przez toggleSort()
    TableRowSorter tsorter = (TableRowSorter) tab.getRowSorter();
    for (int i=0; i < tab.getColumnCount(); i++)
      tsorter.setSortable(i, false);

3. Ikony porządku

UIManager.put("Table.ascendingSortIcon", iconA);
UIManager.put("Table.descendingSortIcon", iconB);

import sun.swing.icon.*;
// ...
UIManager.put("Table.ascendingSortIcon", new SortArrowIcon(true, Color.RED);

4. Komparatory

    // ....
    Object[][] data = { { "Chopin Fryderyk",  "M", 3 }, 
                        { "Kopernik Mikołaj", "M", 2900 },
                         // ...
    };
    String[] columnNames = { "Nazwisko i imię", "Płeć", "Pensja" };
    
    JTable tab = new JTable(data, columnNames);
    tab.setAutoCreateRowSorter(true);
    
    // Zobaczmy komparatory
    TableRowSorter<? extends TableModel> tsorter = 
      (TableRowSorter<? extends TableModel>) tab.getRowSorter();
    for (int i=0; i < tab.getColumnCount(); i++) {
      System.out.println(tsorter.getComparator(i));
    }

    // ...

1. Jeżeli dla kolumny ustalono komparator za pomocą metody setComparator - będzie użyty ten właśnie komparator.
2. W przeciwnym razie, jeżeli getColumnClass() modelu danych zwraca klasę String, użyty zostanie domyślny kolator (Collator.getInstance()).
3. W przeciwnym razie jeżeli getColumnClass() modelu danych zwraca klasę, która implementuje interfejs Comparable, zostanie użyty prywatny komparator, stosujący metodę compareTo(...) implementowaną w zwróconej klasie.
4. W przeciwnym razie, jeżeli dla danej kolumny ustalono sposób przekształcenia w napis za pomocą klasy TableStringConverter, zostanie dokonane to przekształcenie i wobec niego zastosowany domyślny kolator.
5. W przeciwnym razie stosowany jest domyślny kolator wobec wartości uzyskanych metodą toString.

• zdefiniować i ustalić własny komparator dla pensji,
• zdefiniować TableStringConverter.

    // Uwaga: błędne rozwiązanie!
    int col = tab.getColumnModel().getColumnIndex("Pensja");
    tsorter.setComparator(col, new Comparator<String>() {
      public int compare(String s1, String s2) {
        return Integer.parseInt(s1) - Integer.parseInt(s2);
      }
    });

    // .... 
    // Ustalenie komparatora dla pensji
    int col = tab.getColumnModel().getColumnIndex("Pensja");
    tsorter.setComparator(col, new Comparator() {

      public int compare(Object o1, Object o2) {
        int n1, n2;
        try {
           n1 = Integer.parseInt(String.valueOf(o1));
        } catch (NumberFormatException exc) {
           n1 = Integer.MIN_VALUE;  // nie-liczby będą na końcu
        }
        try {
          n2 = Integer.parseInt(String.valueOf(o2));
        } catch (NumberFormatException exc) {
          n2 = Integer.MIN_VALUE;  // nie-liczby będą na końcu
        }
        return n1 - n2;
      }
      
    });
    // ...

5. Konwertery napisowe

    final DecimalFormat df = new DecimalFormat("000000");
    
    tsorter.setStringConverter( new TableStringConverter() {

      @Override
      public String toString(TableModel model, int row, int col) {
        Object elt = model.getValueAt(row, col);
        if (col == 2) return df.format(elt);
        else return elt.toString(); 
      }

    });

6. Model danych tabeli - klucz do właściwego sortowania i filtrowania

public class Employee 
      implements Serializable, Comparable<Employee> {
  
  private String name;
  private Address address;
  private Date birthDate;
  private Integer salary;
 
  public Employee(String name, Address a, Date birthDate, 
                  Integer salary) {
    super();
    this.name = name;
    address = a;
    this.birthDate = birthDate;
    this.salary = salary;
  }
  
  public Employee() {
  }

  // gettery i setery, np:

  public Date getBirthDate() {
    return birthDate;
  }
  
  
  public void setBirthDate(Date birthDate) {
    this.birthDate = birthDate;
  }
  
  // itd. ...
  // ...

  // standardowe implementacje metod hashCode() i equals()
  @Override
  public int hashCode() {
    // ... 
  }

  @Override
  public boolean equals(Object obj) {
    // ...
  } 

  // Naturalny porządek
  public int compareTo(Employee o) {
    // ...
  }

public class Address 
       implements Serializable, Comparable<Address> {
  
  private String town;
  private String street;
  private int nr;
  
  public Address(String town, String street, int nr) {
    this.town = town;
    this.street = street;
    this.nr = nr;
  }
  
  // ...

  // gettery i settery (dla wszystkich pól)
  // na przykład:
  public int getNr() {
    return nr;
  }
  
  public void setNr(int nr) {
    this.nr = nr;
  }

  // ...
  
  // Ważna metoda toString()! 
  public String toString() {
    return town + "; " + street + "; " + nr;  
  }

  // Naturalny porządek
  public int compareTo(Address a) {
    int r = town.compareTo(a.town);
    if (r == 0) r = street.compareTo(a.street);
    if (r == 0) r = nr - a.nr;
    return r;
  }

}

import java.util.*;
import javax.swing.table.*;

public abstract class RowListModel<E> extends AbstractTableModel {

  private List<String> colNames;
  private List<E> rows;

  public RowListModel(List<E> elist, String[] cols) {
    rows = new ArrayList<E>(elist);
    colNames = Arrays.asList(cols);
  }

  @Override
  public int getColumnCount() {
    return colNames.size();
  }

  @Override
  public int getRowCount() {
    return rows.size();
  }

  @Override
  public String getColumnName(int column) {
    return colNames.get(column);
  }

  @Override
  public Class<?> getColumnClass(int c) {
    return getValueAt(0, c).getClass();
  }

  public E getRow(int r) {
    return rows.get(r);
  }

  public void addRow(E newVal) {
    rows.add(newVal);
    this.fireTableDataChanged();
  }

}

public class EmpTabModel extends RowListModel<Employee> {
  
  
  public EmpTabModel(List<Employee> elist, String[] cols) {
    super(elist, cols);
  }

  @Override
  public Object getValueAt(int r, int c) {
    Employee e = getRow(r);
    switch (c) {
      case 0 : return e.getName();
      case 1 : return e.getAddress();
      case 2 : return e.getBirthDate();
      case 3 : return e.getSalary();
      default : return null;
    }
  }
  
  @Override
  public void setValueAt(Object val, int r, int c) {
    Employee emp = getRow(r);
    switch (c) {
      case 0 :  emp.setName((String) val); break;
      case 1 : emp.setAddress((Address) val); break;
      case 2 : emp.setBirthDate((Date) val); break;
      case 3 : emp.setSalary((Integer) val); break;
      default : break;
    }
    this.fireTableCellUpdated(r, c);
  }
 
}

7. Uniwersalne GUI  sortowania i filtrowania tabel

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.table.*;

import static tabsort.GuiUtils.*;


public class TableGUI<M extends RowListModel<E>, E> extends JFrame implements ActionListener {
  
  private static ImageIcon specFiltersImg = 
    new ImageIcon(tabsort.TableGUI.class.getResource("images/help.gif")); 

  // Model danych
  private M model;
  // Tabela
  private JTable table;
  // Sorter
  private TableRowSorter<M> sorter;
  private FilterDialog<M> filterDialog;
  private SortPanel sortPanel;
  

  public TableGUI(String title, final M model) {
    super(title);
    this.model = model;
    setDefaultCloseOperation(DISPOSE_ON_CLOSE);
       
    // Utworzenie sortera
    sorter =  new TableRowSorter<M>(model);
    
    // Tabela i ustalenie sortera
    table = new JTable(model);
    table.setRowSorter(sorter);
    
    // Szybkie wyrównanie dat (jesli są) do prawej (bez własnego renderera)
    TableCellRenderer cellRenderer = table.getDefaultRenderer(Date.class);
    ((JLabel) cellRenderer).setHorizontalAlignment(JLabel.RIGHT);
    

    table.addMouseListener(new MouseAdapter() {

      @Override
      public void mouseReleased(MouseEvent e) {
        if (e.isAltDown()) {
          int r = table.rowAtPoint(e.getPoint());
          r = table.convertRowIndexToModel(r);
          SimpleDialog.show(TableGUI.this, "Edycja", model, r);
        }
        else if (e.isMetaDown()) {
          JPopupMenu pm = getPopupSortKeysWindow();
          pm.show(e.getComponent(), e.getX(), e.getY());
        }
      }

    });

    add(new JScrollPane(table));
     
    Box controls = Box.createHorizontalBox();
    controls.setBorder(BorderFactory.createEmptyBorder(10, 5, 5, 5));
    Dimension filler = new Dimension(5,5);
    controls.add(button("Sort ...", "cmd:sort", this));
    controls.add(Box.createRigidArea(filler));
    controls.add(button("Filter ...", "cmd:filter", this));
    controls.add(Box.createGlue());
    controls.add(button("Add record ...", "cmd:add", this));
    controls.add(Box.createRigidArea(filler));
    controls.add(check("Update on insert ?", "cmd:updateable", this));
    controls.add(Box.createGlue());
    controls.add(label(specFiltersImg, "hint:Special filters",  showSpecialsPopupMenu));
    add(controls, "South");
  }
  
  
  public M getModel() {
    return model;
  }
  
  public TableRowSorter<M> getSorter() {
    return sorter;
  }
  
  public JTable getTable() {
    return table;
  }

  private JPopupMenu getPopupSortKeysWindow() {  // panel sortowania dostępny jako popup
    final JPopupMenu popup = new JPopupMenu();
    if (sortPanel == null) sortPanel = new SortPanel(table);
    sortPanel.setCloseButton(true);
    popup.add(sortPanel);
    return popup;
  }
    

  public void actionPerformed(ActionEvent e) {
    String cmd = e.getActionCommand();
    M model = ((M) table.getModel());

    if (cmd.equals("add")) {
      // obsługa dodoawnia nowego rekordu
      
    } else if (cmd.equals("filter")) {  // dialog filtrowania
      if (filterDialog == null) filterDialog = 
          new FilterDialog<M>(TableGUI.this, "Filtrowanie", model);
      RowFilter<? super M, ? super Integer> filtr = filterDialog.getFilter();
      sorter.setRowFilter(filtr);
      
    } else if (cmd.equals("sort")) {  // dialog sortowania
      JDialog sortDialog = new JDialog(TableGUI.this, "Sortowanie", true);
      if (sortPanel == null) sortPanel = new SortPanel(table);
      sortPanel.setCloseButton(false);
      sortDialog.add(sortPanel);
      sortDialog.pack();
      sortDialog.setLocationRelativeTo(TableGUI.this);
      sortDialog.setVisible(true);
      
    } else if (cmd.equals("updateable")) {
      JToggleButton tb = (JToggleButton) e.getSource();
      sorter.setSortsOnUpdates(tb.isSelected());
    }

  }
  
  // Menu dla specjalnych akcji, które można okreslić z zewnątrz
  private JPopupMenu specialsPopupMenu;
  
  MouseListener showSpecialsPopupMenu = new MouseAdapter() {
    public void mouseClicked(MouseEvent e) {
      if (specialsPopupMenu == null) return;
      Dimension d = specialsPopupMenu.getPreferredSize();
      specialsPopupMenu.show(e.getComponent(), 
                            e.getX()-d.width , e.getY()-d.height);
    }
  };

  public void setSpecialsPopupMenu(Action[] specialActions) {
    specialsPopupMenu = new JPopupMenu();
    for (Action action : specialActions) {
      specialsPopupMenu.add(action);
    }
  }
  
}

• wykorzystano specjalnie przygotowane klasy SimpleDialog, SortPanel i FilterDialog,
• w specjalnie przygotowanej klasie GuiUtils znajdują się wygodne metody button)...) label (...) itp. Dzięki niem kod tworzący komponenty i nadający im właściwości jest bardzo zwięzły i klarowny,
• zamiast korzystać z metody setAutocreateRowSorter(...) utworzony został odrębny obiekt-sorter i ustalony dla tabeli metodą setRowSorter(...).

// odpowiednie importy

public class EmployeeApp {
  
  private TableGUI<EmpTabModel, Employee> gui;
  
  public EmployeeApp() {
    // Metoda genarate tworzy w sposób losowy lisę pracowników
    // tu o rozmiarze 100 elementów
    List<Employee> elist = Employee.generate(100);
    
    // Nazwy kolumn
    String[] colNames =  { "Nazwisko i imię", "Adres",  
                           "Data urodzenia", "Pensja" };
    
    // Utworzenie modelu danych
    EmpTabModel model = 
      new EmpTabModel(elist,  colNames);

    // Utworzenie GUI   
    gui =  new TableGUI<EmpTabModel, Employee>("Aplikacja tablicowa - pracownicy",
                                       model);
    
    gui.setSpecialsPopupMenu(specialActions);
    gui.pack();
    gui.setLocationRelativeTo(null);
    gui.setVisible(true);
  }
  
  
  public static void main(String[] args) {
    try {
      UIManager.setLookAndFeel(
          "com.jgoodies.looks.plastic.PlasticXPLookAndFeel"
          );
    } catch (Exception e) {
      e.printStackTrace();
    }
    SwingUtilities.invokeLater( new Runnable() {
      public void run() {
        new EmployeeApp();
      }
    });
  }

}

8. Model + uniwersalne GUI = łatwe dostosowania i modyfikacje

import javax.swing.*;

public class Car {
  private String make;
  private String model;
  private Integer year;
  private Integer price;
  private Icon icon;
  
  public Car(String make, String model, Integer year, Integer price, Icon icon) {
    super();
    this.make = make;
    this.model = model;
    this.year = year;
    this.price = price;
    this.icon = icon;
  }
  
  public String getMake() {
    return make;
  }
  
  public void setMake(String make) {
    this.make = make;
  }
 
  public String getModel() {
    return model;
  }
  
  public void setModel(String model) {
    this.model = model;
  }

  public Integer getPrice() {
    return price;
  }

  public void setPrice(Integer price) {
    this.price = price;
  }
  
  public Integer getYear() {
    return year;
  }
  
  public void setYear(Integer year) {
    this.year = year;
  }
  
  public Icon getIcon() {
    return icon;
  }
  
  public void setIcon(Icon icon) {
    this.icon = icon;
  }
  
}

public class CarTabModel extends RowListModel<Car> {
  
  
  public CarTabModel(List<Car> elist, String[] cols) {
    super(elist, cols);
  }

  @Override
  public Object getValueAt(int r, int c) {
    Car o = getRow(r);
    switch (c) {
      case 0 : return o.getMake();
      case 1 : return o.getModel();
      case 2 : return o.getYear();
      case 3 : return o.getPrice();
      case 4 : return o.getIcon();
      default : return null;
    }
  }
  
  @Override
  public void setValueAt(Object val, int r, int c) {
    Car car = getRow(r);
    switch (c) {
      case 0 :  car.setMake((String) val); break;
      case 1 : car.setModel((String) val); break;
      case 2 : car.setYear((Integer) val); break;
      case 3 : car.setPrice((Integer) val); break;
      case 4 : car.setIcon((Icon) val); break;
      default : break;
    }
    this.fireTableCellUpdated(r, c);
  }
 
}

public class CarApp {
  
  private TableGUI<CarTabModel, Car> gui;
  
  public CarApp() {
    
    Class kl = getClass();     
    ImageIcon icon = new ImageIcon(kl.getResource("images/lockkey.gif"));

    List<Car> clist = Arrays.asList( new Car[] {
        new Car("Plymouth", "Barracuda", 1970, 300, 
            new ImageIcon(kl.getResource("images/plym.jpeg" ))),
        new Car("Lamborghini", "Murcielago", 2007, 1000, 
            new ImageIcon(kl.getResource("images/lamborghini.jpeg"))),
        new Car("Jeep", "Cherokee", 1997, 6, icon),
        new Car("Jeep", "Cherokee", 2001, 12, icon),
        new Car("Fiat", "Spider", 1982, 40, icon),
        new Car("Fiat", "Bravo", 2005, 40, icon),
        new Car("Mitsubishi", "Galant", 2007, 80, 
            new ImageIcon(kl.getResource("images/mitsubishi.jpg"))),
    });
    
    // Nazwy kolumn
    String[] colNames =  { "Marka", "Model",  
                           "Rocznik", "Cena", "Foto" };
    // Utworzenie modelu danych
    CarTabModel model =
      new CarTabModel(clist,colNames);
    
    gui =  new TableGUI<CarTabModel, Car>("Aplikacja tablicowa - samochody", model);
   
    gui.getTable().setRowHeight(70);
    gui.getTable().getColumn("Foto").setWidth(70);

    gui.pack();
    gui.setLocationRelativeTo(null);
    gui.setVisible(true);
  }
  
  
  public static void main(String[] args) {
    try {
      UIManager.setLookAndFeel(
          "com.jgoodies.looks.plastic.PlasticXPLookAndFeel"
          );
    } catch (Exception e) {
      e.printStackTrace();
    }
    
    SwingUtilities.invokeLater( new Runnable() {
      public void run() {
        new CarApp();
      }
    });
  }
}

9. Sortowanie po kluczach

  // ...
  // Sorter
  private TableRowSorter<? extends TableModel> tsorter;

  // Model danych prawej listy (wybranych kluczy sortowania)
  private DefaultListModel sortKeysListModel = new DefaultListModel();

  // Lista kluczy sortowania
  private  List<SortKey> sortKeys = new ArrayList<SortKey>();

  private  JRadioButton rbSortOrder = new JRadioButton("Descending");

  // ...
  
  // Obsługa przycisków
  ActionListener sortHandler = new ActionListener() {

    public void actionPerformed(ActionEvent e) {
      String cmd = e.getActionCommand();
      // ...
      if (cmd.endsWith("sort")) {
        sortKeys.clear();                           // zawsze świeża lista
        if (!cmd.startsWith("un")) {                // przycisk "Sort"

          // Porządek sortowania
          SortOrder sortOrder = SortOrder.ASCENDING;
          if (rbSortOrder.isSelected()) sortOrder = SortOrder.DESCENDING;

          // ile kluczy? gdy więcej od 3 trzeba ustalić MaxSortKeys 
          int skn = sortKeysListModel.getSize();
          if (skn > 3) tsorter.setMaxSortKeys(skn);
           
          // Wybrane nazwy kolumn 
          List<?> klist = Collections.list(sortKeysListModel.elements());
           
          // Dla każdej wybranej kolumny ustalamy klucz sortowania
          for (Object col : klist) {
            int ind = tab.getColumnModel().getColumnIndex(col);
            sortKeys.add(new SortKey(ind, sortOrder));
          }
        }
        // Sortowanie 
        // (lub przywróoenie stanu "nieposortwana" gdy przycisk "Insort")
        tsorter.setSortKeys(sortKeys);
      }
      // ...
    }
  };    

10. Edycja

   sorter.setSortsOnUpdates(true);

// ...
table.addMouseListener(new MouseAdapter() {

      @Override
      public void mouseReleased(MouseEvent e) {
        if (e.isAltDown()) {
          int r = table.rowAtPoint(e.getPoint());
          r = table.convertRowIndexToModel(r);
          SimpleDialog.show(TableGUI.this, "Edycja", model, r);
        }
      }

});
// ...

11. Filtrowanie wierszy

 RowFilter.numberFilter(RowFilter.ComparisonType c, Number n, int ... indeksy)

• EQUAL - równe
• NOT_EQUAL - nierówne
• AFTER - większe,
• BEFORE - mniejsze

// sorter jest sorterem ustalonym dla tabeli pracowników
pensja = 3000;
kolumna = 3;   // indeks kolumny pensji
sorter.setRowFilter(RowFilter.numberFilter(ComparisonType.AFTER, pensja, kolumna));

RowFilter.dateFilter(RowFilter.ComparisonType c, Date d, int ... indeksy)

        SimpleDateFormat dateFormat = 
          new SimpleDateFormat("yyyy-MM-dd");
        // ...
        try {
          Date data = dateFormat.parse("1980-01-01");
          sorter.setRowFilter(RowFilter.dateFilter(ComparisonType.BEFORE, data, 2));
        } catch (ParseException exc) {
           System.out.println("Wadliwa data");
        }

RowFilter.regexFilter(String regex, int ... indeksy);

// ...
        String regex = JOptionPane.showInputDialog("Regex:");
        if (regex != null)
           sorter.setRowFilter(RowFilter.regexFilter(regex));
// ...

• getModel() - zwraca model,
• getIdentifier() - identyfikator wiersza (w modelu! dla tabeli będzie to indeks wiersza),
• getValueCount() - liczbę wartości w wierszu (gdy mowa o tabeli będzie to liczba kolumn),
• getValue(int i) - i-ta wartość w wierszu (dla tabeli wartość zapisana w i-ej kolumnie),
• getStringValue(int i)  - i-ta wartość, przekształcona na napis metodą toString().

        String in = showInputDialog("Street and firstName");
        if (in == null) return;
        final String[] data = in.split(" +");
        RowFilter<EmpTabModel, Integer> filtr = new RowFilter<EmpTabModel, Integer>() {

          @Override
          public boolean include(RowFilter.Entry<? extends EmpTabModel, 
                                                 ? extends Integer> entry) {
            EmpTabModel model = entry.getModel();
            int row = entry.getIdentifier();
            Employee emp = model.getRow(row);
            String[] names = emp.getName().split(" +");
            
            return emp.getAddress().getStreet().equals(data[0].trim()) &&
                   names[1].equals(data[1].trim()); 
          }
          
        };
        JTable table = gui.getTable();
        TableRowSorter<EmpTabModel> sorter = gui.getSorter();
        sorter.setRowFilter(filtr);

        int rows = sorter.getViewRowCount();
        for (int i=0; i < rows; i++) {
          System.out.println(table.getValueAt(i, 0) + " - " +
                             table.getValueAt(i, 1));
        }

          String regex = showInputDialog("Enter regex for names");
          if (regex == null) return;
          String number = showInputDialog("Enter minimal salary");
          if (number == null) return;
          int minSal = new Scanner(number).nextInt();
          // Lista filtrów łączonych za pomocą operacji AND lub OR
          List<RowFilter<? super EmpTabModel, ? super Integer>> filterList = 
            new ArrayList<RowFilter<? super EmpTabModel, ? super Integer>>();

          // Wynikowy filtr
          RowFilter<? super EmpTabModel, ? super Integer> rowFilter;
          

          filterList.add(RowFilter.regexFilter(regex, 0));
          filterList.add(RowFilter.numberFilter(ComparisonType.AFTER, minSal, 3));

          rowFilter = RowFilter.andFilter(filterList);
          gui.getSorter().setRowFilter(rowFilter);