Jtable_Swing part 8


Trong phần này, chúng ta sẽ tìm hiểu cách để sắp xếp các hàng trong một bảng theo chiều tăng dần hoặc giảm dần của các giá trị trong một cột nào đó của bảng.

Sắp xếp các hàng trong một bảng
Khi hiển thị thông tin trong một JTable, sẽ có lúc chúng ta muốn sắp xếp lại các hàng trong bảng đó theo chiều tăng dần hoặc giảm dần của các giá trị trong một hoặc nhiều cột của bảng. Bởi vì việc sắp xếp thường là chậm và sẽ trở thành phức tạp khi mà tập dữ liệu của chúng ta lớn, vì vậy chúng ta nên có các dữ liệu đã được sắp xếp sẵn từ một ứng dụng bên ngoài. Ví dụ như nếu chúng ta hiển thị dữ liệu lấy từ một cơ sở dữ liệu quan hệ, chúng ta có thể lấy được tập dữ liệu đã được sắp xếp sẵn từ câu truy vấn. Tuy nhiên, sẽ có đôi khi vì một lý do nào đó chúng ta cần phải sắp xếp dữ liệu trên chính cái bảng của chúng ta, và bởi vì JTable không trực tiếp hỗ trợ việc sắp xếp này, cho nên chúng ta phải tự tay viết những dòng lệnh để thực hiện việc này.

Để sắp xếp dữ liệu hiển thị trong một bảng, chúng ta có thể sử dụng một trong hai cách tiếp cận: Cách thứ nhất là sắp xếp dữ liệu “ngay tại chỗ”, cách thứ hai là việc sắp xếp được thực hiện thông qua một lớp nằm giữa JTable và TableModel. Sắp xếp dữ liệu ngay tại chỗ có nghĩa là chúng ta thay đổi vị trí của dữ liệu trong một mảng hoặc trong một đối tượng collection. Ví dụ như trong trường hợp của chúng ta, dữ liệu được định nghĩa trong lớp TableValues, chúng ta sẽ sắp xếp lại các giá trị này trong mảng sao cho chúng tăng dần hoặc giảm dần. Tức là trong cách tiếp cận này, ta sắp xếp lại dữ liệu trong cái model của bảng.

Một cách tiếp cận có vẻ linh động hơn đó là thêm một lớp làm việc sắp xếp giữa bảng và cái model của nó. Cụ thể hơn, nó liên quan đến việc tạo ra một TableModel thứ hai gọi là model sắp xếp (sort model). Model sắp xếp này sẽ có một tham chiếu đến cái model gốc (source model – trong ví dụ chính là TableValues) của chúng ta. Trong trường hợp này, dữ liệu trong model gốc không cần phải chuyển đổi hay thay đổi gì. Thay vào đó, model sắp xếp có thể tạo một danh sách các chỉ số. Các chỉ số này tham chiếu đến các dữ liệu trong model gốc và được sắp xếp theo thứ tự tăng dần hoặc giảm dần. Cho ví dụ, giả sử có ba giá trị kiểu String được lưu trong model gốc như sau:

  • Kirk
  • Ashworth
  • Spyres

Model sắp xếp có thể sắp xếp các giá trị này và tạo một tập các chỉ số tham chiếu đến chúng. Trong trường hợp này, các chỉ số sẽ được đánh như sau:

  • 1
  • 0
  • 2

Bằng việc sử dụng một danh sách các chỉ số để tham chiếu đến các hàng trong model gốc, dữ liệu có thể xuất hiện theo thứ tự đã sắp xếp, kể cả dù trong thực tế, dữ liệu vẫn được lưu theo thứ tự ban đầu của nó. Chúng ta tạo một lớp là SortedTableModel trong file SortedTableModel.java như sau:

  1. public class SortedTableModel extends AbstractTableModel{
  2.     protected TableModel sourceModel;
  3.     protected int[ indexValues;
  4.     public SortedTableModel(TableModel model){
  5.         super();
  6.         sourceModel = model;
  7.     }
  8.     public int getRowCount() {
  9.         return sourceModel.getRowCount();
  10.     }
  11.     public int getColumnCount() {
  12.         return sourceModel.getColumnCount();
  13.     }
  14.     public Object getValueAt(int rowIndex, int columnIndex) {
  15.         if(indexValues != null){
  16.             rowIndex = getSourceIndex(rowIndex);
  17.         }
  18.         return sourceModel.getValueAt(rowIndex, columnIndex);
  19.     }
  20.     @Override
  21.     public void setValueAt(Object value, int row, int column){
  22.         if(indexValues != null){
  23.             row = getSourceIndex(row);
  24.         }
  25.     }
  26.     @Override
  27.     public boolean isCellEditable(int row, int column){
  28.         return sourceModel.isCellEditable(row, column);
  29.     }
  30.     @Override
  31.     public String getColumnName(int column){
  32.         return sourceModel.getColumnName(column);
  33.     }
  34.     @Override
  35.     public Class getColumnClass(int column){
  36.         return sourceModel.getColumnClass(column);
  37.     }
  38.     public int getSourceIndex(int index){
  39.         if(indexValues != null){
  40.             return indexValues[index];
  41.         }
  42.         return -1;
  43.     }
  44.     public void sortRows(int column, boolean ascending){
  45.         SortedItemHolder holder;
  46.         TreeSet sortedList = new TreeSet();
  47.         int count = getRowCount();
  48.         for(int i =0; i< count; i++){
  49.             holder = new SortedItemHolder(sourceModel.getValueAt(i, column),i);
  50.             sortedList.add(holder);
  51.         }
  52.         indexValues = new int[count];
  53.         Iterator iterator = sortedList.iterator();
  54.         int index = (ascending ?0: count-1);
  55.         while(iterator.hasNext()){
  56.             holder = (SortedItemHolder)(iterator.next());
  57.             indexValues[index] = holder.position;
  58.             index += (ascending ? 1: -1);
  59.         }
  60.         refreshViews();
  61.     }
  62.     public void clearSort(){
  63.         indexValues = null;
  64.         refreshViews();
  65.     }
  66.     public void refreshViews(){
  67.         fireTableDataChanged();
  68.     }
  69.     class SortedItemHolder implements Comparable{
  70.         public final Object value;
  71.         public final int position;
  72.         public SortedItemHolder(Object value, int position){
  73.             this.value = value;
  74.             this.position = position;
  75.         }
  76.         public int compareTo(Object parm) {
  77.             SortedItemHolder holder = (SortedItemHolder)parm;
  78.             Comparable comp = (Comparable)value;
  79.             int result = comp.compareTo(holder.value);
  80.             if(result == 0){
  81.                 result = (position < holder.position) ? -1: 1;
  82.             }
  83.             return result;
  84.         }
  85.         @Override
  86.         public int hashCode(){
  87.             return position;
  88.         }
  89.         @Override
  90.         public boolean equals(Object comp){
  91.             if(comp instanceof SortedItemHolder){
  92.                 SortedItemHolder other = (SortedItemHolder)comp;
  93.                 if((position == other.position) && (value == other.value)){
  94.                     return true;
  95.                 }
  96.             }
  97.             return false;
  98.         }
  99.     }
  100. }

Phương thức sortRows được sử dụng để chỉ ra dữ liệu sẽ được sắp xếp theo cột nào và theo thứ tự là tăng dần hay giảm dần. Lớp SortedItemHolder nằm ở bên trong lớp SortedTableModel làm nhiệm vụ sắp xếp các giá trị và tất nhiên, bên trong lớp SortedTableModel phải có một tham chiếu đến model gốc. Thêm vào đó, một phần của hai phương thức là getValueAt và setValueAt là thực hiện việc chuyển đổi chỉ số hàng giữa hai model.

Bằng việc sử dụng lớp này, chúng ta có thể hiển thị dữ liệu trong bảng theo một thứ tự được sắp xếp. Chẳng hạn sửa đoạn mã trong lớp SimpleTableTest sau sẽ sắp xếp dữ liệu trong bảng theo giá trị tăng dần (từ trên xuống dưới) của cột Account Balance:

  1. public class SimpleTableTest extends JFrame{
  2.     protected JTable table;
  3.     public SimpleTableTest(){
  4.         Container pane = getContentPane();
  5.         pane.setLayout(new BorderLayout());
  6.         TableValues tv = new TableValues();
  7.         SortedTableModel stm = new SortedTableModel(tv);
  8.         stm.sortRows(TableValues.ACCOUNT_BALANCE, true);
  9.         table = new JTable(stm);
  10.         table.setRowSelectionAllowed(false);
  11.         […]
  12.         JScrollPane jsp = new JScrollPane(table);
  13.         pane.add(jsp, BorderLayout.CENTER);
  14.         addHeaderListener();
  15.         […]
  16.     }
  17.     public void addHeaderListener(){
  18.         […]
  19.     }
  20.     public static void main(String [ args){
  21.         […]
  22.     }
  23. }

Kết quả khi chạy chương trình, các hàng trong bảng sẽ được sắp xếp lại sao cho giá trị trong cột Account Balance tăng dần như hình dưới đây:

Trong ví dụ trên, một cột được chọn để sắp xếp sẽ được cố định ở trong đoạn mã và chúng ta không thể thay đổi khi mà chương trình đã chạy. Tuy nhiên, việc tạo một giao diện để cho phép người sử dụng chọn một cột để sắp xếp theo thì cũng khá dễ dàng. Chúng ta có thể tạo một renderer cho các tiêu đề của các cột trong bảng. Renderer này sẽ phát hiện hiện tượng nhấp chuột, xác định cột nào đang được con trỏ chuột chỉ tởi và sắp xếp các dữ liệu trong bảng dựa trên các giá trị của cột đó. Chúng ta tạo lớp SortedColumnHeaderRenderer trong file SortedColumnHeaderRenderer như sau:

  1. public class SortedColumnHeaderRenderer implements TableCellRenderer{
  2.     protected TableCellRenderer textRenderer;
  3.     protected SortedTableModel sortedModel;
  4.     protected int sortColumn = -1;
  5.     protected boolean sortAscending = true;
  6.     public SortedColumnHeaderRenderer(SortedTableModel model, TableCellRenderer renderer){
  7.         sortedModel = model;
  8.         textRenderer = renderer;
  9.     }
  10.     public SortedColumnHeaderRenderer(SortedTableModel model){
  11.         this(model, null);
  12.     }
  13.     public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
  14.         Component text;
  15.         JPanel panel = new JPanel();
  16.         panel.setLayout(new BorderLayout());
  17.         if(textRenderer != null){
  18.             text = textRenderer.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
  19.         }else{
  20.             text = new JLabel((String)value, JLabel.CENTER);
  21.             LookAndFeel.installColorsAndFont((JComponent)text, “TableHeader.background”, “TableHeader.foreground”, “TableHeader.font”);
  22.         }
  23.         panel.add(text,BorderLayout.CENTER);
  24.         if(column == sortColumn){
  25.             BasicArrowButton bab = new BasicArrowButton((sortAscending?SwingConstants.NORTH:SwingConstants.SOUTH));
  26.             panel.add(bab,BorderLayout.WEST);
  27.         }
  28.         LookAndFeel.installBorder(panel, “TableHeader.cellBorder”);
  29.         return panel;
  30.     }
  31.     public void columnSelected(int column){
  32.         if(column!=sortColumn){
  33.             sortColumn = column;
  34.             sortAscending = true;
  35.         }else{
  36.             sortAscending = !sortAscending;
  37.             if(sortAscending) sortColumn = -1;
  38.         }
  39.         if(sortColumn != -1){
  40.             sortedModel.sortRows(sortColumn, sortAscending);
  41.         }else{
  42.             sortedModel.clearSort();
  43.         }
  44.     }
  45. }

Chúng ta cần chú ý đến hai điểm quan trọng trong renderer này. Thứ nhất, nó có thể được truyền vào một tham chiếu đến renderer khác. Renderer khác này có nhiệm vụ là vẽ đoạn chữ cho tiêu đề. Điều này cho phép chúng ta kết hợp được các chức năng của nhiều renderer lại với nhau. Nói cách khác, chúng ta vừa có thể tạo một bảng với các tiêu đề có thể hiển thị đoạn chữ trên nhiều dòng, vừa cho phép chúng ta chọn cột sắp xếp một cách động bằng cách nhấp chuột vào tiêu đề của cột đó.

Thứ hai, lớp này duy trì một biến để nhận diện ra cột nào sẽ được sắp xếp. Bởi vì thế, chúng ta chỉ có thể sử dụng một đối tượng duy nhất của lớp renderer này cho tất cả các cột mà chúng ta muốn chọn để sắp xếp trong bảng.

Khi chúng ta gán renderer này đến các ô tiêu đề, nó cho phép chúng ta có thể sắp xếp dữ liệu theo giá trị trong một cột bằng cách nhấp chuột vào tiêu đề của cột đó. Lần đầu tiên chúng ta kích vào tiêu đề của một cột, các hàng trong bảng sẽ được sắp xếp theo thứ tự tăng dần của giá trị trong cột đó. Nếu chúng ta kích chuột một lần nữa vào tiêu đề đó, các hàng sẽ được sắp xếp lại nhưng lần này là theo thứ tự giảm dần và lần kích chuột thứ ba sẽ là nguyên nhân để các hàng được trở về vị trí ban đầu khi chưa được sắp xếp. Khi mà giá trị trong bảng được sắp xếp, sẽ có một hiển thị xuất hiện để chỉ thị giá trị này được sắp xếp như thế nào. Đó là hình một mũi tên hướng lên trong trường hợp sắp xếp các giá trị theo thứ thự tăng dần và hình một mũi tên hướng xuống trong trường hợp sắp xếp các giá trị theo thứ tự giảm dần (từ trên xuống dưới). Chúng ta thay đổi lớp SimpleTableTest như sau:

  1. public class SimpleTableTest extends JFrame{
  2.     protected JTable table;
  3.     protected SortedColumnHeaderRenderer renderer;
  4.     public SimpleTableTest(){
  5.         Container pane = getContentPane();
  6.         pane.setLayout(new BorderLayout());
  7.         TableValues tv = new TableValues();
  8.         SortedTableModel stm = new SortedTableModel(tv);
  9.         table = new JTable(stm);
  10.         table.setRowSelectionAllowed(false);
  11.         table.setColumnSelectionAllowed(true);
  12.         TableColumnModel tcm = table.getColumnModel();
  13.         TableColumn tc = tcm.getColumn(TableValues.GENDER);
  14.         tc.setCellRenderer(new GenderRenderer());
  15.         tc.setCellEditor(new GenderEditor());
  16.         MultiLineHeaderRenderer mlhr = new MultiLineHeaderRenderer();
  17.         renderer = new SortedColumnHeaderRenderer(stm, mlhr);
  18.         int count = tcm.getColumnCount();
  19.         for(int i=0;i<count; i++){
  20.             tc = tcm.getColumn(i);
  21.             tc.setHeaderRenderer(renderer);
  22.         }
  23.         JTableHeaderToolTips jthtt = new JTableHeaderToolTips(table.getColumnModel());
  24.         […]
  25.         addHeaderListener();
  26.         […]
  27.     }
  28.     public void addHeaderListener(){
  29.         table.getTableHeader().addMouseListener(new MouseAdapter(){
  30.             public void mousePressed(MouseEvent event){
  31.                 JTableHeader header = (JTableHeader)(event.getSource());
  32.                 int index = header.columnAtPoint(event.getPoint());
  33.                 renderer.columnSelected(index);
  34.                 table.setColumnSelectionInterval(index, index);
  35.             }
  36.         });
  37.     }
  38.     public static void main(String [ args){
  39.         […]
  40.     }
  41. }

Sau khi chạy chương trình và nhấp chuột lên cột Date of Birth, ta sẽ thấy các giá trị trong cột này được sắp xếp lại giống như hình dưới đây:

Sử dụng interface Comparable
Một trong những giới hạn của cách sắp xếp mà chúng ta đã trình bày ở trên là việc sử dụng interface Comparableđể xác định mối tương quan giữa giá trị của hai đối tượng (lớn hơn, nhỏ hơn, bằng nhau). Thông thường thì trong Java 2, hầu hết các lớp đều cài đặt interface Comparable và điều đó cho phép chúng ta có thể sắp xếp các đối tượng của chúng theo một cách thức nào đó. Cho ví dụ như các lớp Integer, Float, Long, String, Date… đều cài đặt interface Comparable. Tuy nhiên, lớp Boolean thì không cài đặt interface Comparable(1), bởi vì mặc dù tất nhiên là giá trị true không bằng với giá trị false, nhưng sẽ rất mập mờ trong việc quy định giữa true và false thì giá trị nào lớn hơn. Trong ví dụ của chúng ta, nếu chúng ta nhấp chuột vào tiêu đề của cột Gender, chương trình sẽ sinh ra mộtClassCastException. Đấy là bởi vì chúng ta đang cố ép các giá trị thuộc kiểu Boolean về các giá trị kiểu Comparable.

Một trong những cách để giải quyết vấn đề trên đó là chúng ta sẽ kiểm tra kiểu dữ liệu trong cột được chọn trước khi các dữ liệu trong cột đó được sắp xếp. Việc lấy kiểu dữ liệu của một cột sẽ được thực hiện bởi phương thứcgetColumnClass của TableModel và chúng ta có thể sử dụng đối tượng trả về thuộc kiểu Class của phương thức đó để xác định xem lớp của nó có cài đặt interface Comparable hay không. Trở lại ví dụ, chúng ta thực hiện việc này bằng việc thay đổi lớp SimpleTableTest như sau:

  1. public class SimpleTableTest extends JFrame{
  2.     protected JTable table;
  3.     protected SortedColumnHeaderRenderer renderer;
  4.     public SimpleTableTest(){
  5.         […]
  6.     }
  7.     public void addHeaderListener(){
  8.         table.getTableHeader().addMouseListener(new MouseAdapter(){
  9.             public void mousePressed(MouseEvent event){
  10.                 JTableHeader header = (JTableHeader)(event.getSource());
  11.                 int index = header.columnAtPoint(event.getPoint());
  12.                 Class dataType = table.getModel().getColumnClass(index);
  13.                 Class[ interfaces = dataType.getInterfaces();
  14.                 for(int i = 0; i<interfaces.length; i++){
  15.                     if(interfaces<img src=”http://hp-aptech.edu.vn/emoticons/emotion-55.gif” alt=”Idea” /&gt;.equals(java.lang.Comparable.class)){
  16.                         renderer.columnSelected(index);
  17.                         break;
  18.                     }
  19.                 }
  20.                 table.setColumnSelectionInterval(index, index);
  21.             }
  22.         });
  23.     }
  24.     public static void main(String [ args){
  25.         […]
  26.     }
  27. }

Khi chạy chương trình, với việc sửa đổi như trên giờ đây chúng ta không thể chọn sắp xếp theo giá trị trong cột Gender như hình dưới đây:

Tuy nhiên, vẫn còn một vấn đề nữa sinh ra từ việc làm này đó là khi ta chọn các cột như First Name hoặc Last Name, các giá trị cũng không được sắp xếp. Đấy là bởi vì trong TableModel chúng ta chỉ chỉ định kiểu dữ liệu cho hai cột đó là Date of Birth và Account Balance. Các cột khác sẽ được ngầm hiểu rằng chúng có kiểu dữ liệu là Object. Hay nói cách khác, chương trình sẽ không thực hiện sắp xếp trên các cột First Name, Last Name, Gender bởi vì chương trình đang hiểu các cột này có kiểu dữ liệu là Object, mà kiểu Object thì lại không cài đặt interface Comparable. Tuy nhiên, vấn đề này có thể giải quyết một cách dễ dàng bằng cách chúng ta sửa lại phương thức getColumnClass trong lớp TableValues như sau:

  1. public class TableValues extends AbstractTableModel{
  2.     public final static int FIRST_NAME = 0;
  3.     public final static int LAST_NAME = 1;
  4.     public final static int DATE_OF_BIRTH = 2;
  5.     public final static int ACCOUNT_BALANCE = 3;
  6.     public final static int GENDER = 4;
  7.     public final static boolean GENDER_MALE = true;
  8.     public final static boolean GENDER_FEMALE = false;
  9.     public final static String[ columnNames = {
  10.         “First Name”, “Last Name”, “Date of Birth”, “Account\nBalance”,”Gender”
  11.     };
  12.     public Object[[ values = {
  13.         […]
  14.     };
  15.     public int getRowCount() {
  16.         return values.length;
  17.     }
  18.     public int getColumnCount() {
  19.         return values[0].length;
  20.     }
  21.     public Object getValueAt(int rowIndex, int columnIndex) {
  22.         return values[rowIndex][columnIndex];
  23.     }
  24.     @Override
  25.     public String getColumnName(int column){
  26.         return columnNames[column];
  27.     }
  28.     @Override
  29.     public Class getColumnClass(int column){
  30.         Class dataType = super.getColumnClass(column);
  31.         if(column == ACCOUNT_BALANCE){
  32.             dataType = Float.class;
  33.         }else if(column == DATE_OF_BIRTH){
  34.             dataType = java.util.Date.class;
  35.         }else if((column == FIRST_NAME) || (column == LAST_NAME)){
  36.             dataType = String. class;
  37.         }else if(column == GENDER){
  38.             dataType = Boolean.class;
  39.         }
  40.         return dataType;
  41.     }
  42.     @Override
  43.     public boolean isCellEditable(int row, int column){
  44.         if(column == GENDER){
  45.             return true;
  46.         }
  47.         return false;
  48.     }
  49.     @Override
  50.     public void setValueAt(Object value, int row, int column){
  51.         values[row][column] = value;
  52.     }
  53. }

Bây giờ chạy chương trình, chúng ta có thể sắp xếp dữ liệu trong bảng dựa vào các giá trị của cột First Name như hình dưới đây:

Chú ý
(1): Điều này có lẽ chỉ đúng trong phiên bản java cũ mà tác giả dùng để viết ví dụ minh họa. Theo tôi được biết bắt đầu từ JDK 1.5, lớp Boolean của chúng ta đã cài đặt interface Comparable và bằng chứng là khi chạy chương trình của chúng ta, cột Gender vẫn được sắp xếp bình thường như hình dưới đây:

Các bạn cũng có thể tham khảo thêm tại đây.

Như vậy sau bài viết này chúng ta đã nắm được cách để sắp xếp các hàng trong một bảng theo chiều tăng dần hoặc giảm dần của các giá trị trong một cột nào đó.  Phần 9 sẽ trình bày cách thêm và xóa một dòng trong bảng.

One Response to “Jtable_Swing part 8”

  1. Swing in Java « Thái Hoàng Hải Says:

    […] 1 Part 2 Part 3 Part 4 Part 5 Part 6 Part 7 Part 8 Part 9 Share this:TwitterFacebookLike this:LikeBe the first to like this post. Comments RSS […]


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: