JTable sortieren ohne Berücksichtigung der leeren Zellen

[Milo]

Hallo,

ich habe den Artikel JTable - Teil 8 - Sortieren gelesen und es funktioniert sowiet auch prima. Bei meiner Anwendung ist es jedoch so, dass ich zunächst eine leere Tabelle mit zB 20 Zeilen vorgebe, die der User ausfüllen kann. Wenn er in der (jeweils) letzten Zeile ist, füge ich eine Zeile an, sodass er endlos Daten einfügen kann.
Es gibt also immer mind. eine Zeile, die leer ist (weil gerade angefügt).

Beim Sortieren wird diese Zeile jedoch mitberücksichtigt und steht entweder oben oder unten. Bei einer Zeile ist es noch okay aber nehmen wir an, der User füllt nur 5 Zeilen aus, dann stehen in einer Version 15 Leerzeilen oben und das ist eher unübersichtlich.

Zunächst dachte ich, ich könne es über die Comparator Schnittstelle lösen; diesem werden aber die Leerzellen nicht übergeben, wie es aussieht. Gibt es eine Möglichkeit, die leeren Zellen beim sortieren immer ans Ende zu setzen?

Gruß
Micha

 

[André Uhres]

Hier ist ein möglicher Lösungsansatz. Das Beispiel funktioniert für die "Point" Spalte aus dem Tutorial.
WICHTIG: die leeren Points dürfen nicht "null" sein sondern müssen "new Point(-1, -1)" enthalten
(bzw. irgendeinen Wert, der sonst nicht vorkommt):

...
        // Den Comparator für die 2. Spalte (mit den Points) setzen.
        sorter.setComparator(2, new PointComparator());
        // dieser Listener informiert uns über RowSorterEvents:
        sorter.addRowSorterListener(new RowSorterListener() {

            @Override
            public void sorterChanged(RowSorterEvent e) {
                doSorterChanged(e);
            }
        });
...
    static private void doSorterChanged(RowSorterEvent e) {
        TableRowSorter sorter = (TableRowSorter) e.getSource();
        if (e.getType().equals(RowSorterEvent.Type.SORT_ORDER_CHANGED)) {
            //falls sortiert werden soll, holen wir die SortKeys:
            java.util.List<SortKey> l = sorter.getSortKeys();
            for (SortKey sortKey : l) {
                if (sortKey.getColumn() == 2) {//"Point" Spalte
                    if (sortKey.getSortOrder() == SortOrder.ASCENDING) {
                        sorter.setComparator(2, new PointComparator2());//Comparator für SortOrder.ASCENDING
                    } else {
                        sorter.setComparator(2, new PointComparator());//Comparator für SortOrder.DESCENDING
                    }

                }
            }
        }
    }
...
//Comparator für SortOrder.ASCENDING
class PointComparator2 implements Comparator<Point> {

    @Override
    public int compare(Point o1, Point o2) {
        int x1 = o1.x;
        int x2 = o2.x;
        int y1 = o1.y;
        int y2 = o2.y;
        if (x1 == -1) {
            x1 = 99999;
        }
        if (x2 == -1) {
            x2 = 99999;
        }
        if (y1 == -1) {
            y1 = 99999;
        }
        if (y2 == -1) {
            y2 = 99999;
        }
        if (x1 < x2) {
            return -1;
        } else if (x1 > x2) {
            return 1;
        } else if (y1 < y2) {
            return -1;
        } else if (y1 > y2) {
            return 1;
        } else {
            return 0;
        }
    }
}
//PointRender gibt leeren Text aus bei Koordinaten -1,-1
class PointRender extends DefaultTableCellRenderer {

    @Override
    public Component getTableCellRendererComponent(JTable table, Object value,
            boolean isSelected, boolean hasFocus, int row, int column) {
        Point point = (Point) value;
        String text = "";
        try {
            text = point.x + " / " + point.y;
        } catch (NullPointerException e) {
        }
        if (point.x == -1 && point.y == -1) {
            text = "";
        }
        return super.getTableCellRendererComponent(table, text, isSelected,
                hasFocus, row, column);
    }
}

 

[Milo]

Hi,

eine allg. gülte Lösung siehst Du auch nicht oder?

Micha

 

[Milo]

Hallo,

Daniel Thoma hat noch eine weitere Möglichkeit beschrieben, wie man diesen Mißstand beheben kann. Hier die zusammengefasste Version (fürs Archiv):

// Ich würde von TableRowSorter ableiten und dabei setModel wie folgt überschreiben:
// Dann kannst Du einfach statt auf null in deinem Comparator auf NULL_OBJECT vergleichen.
public static final Object NULL_OBJECT = new Object();

public void setModel(M model) {
  super.setModel(model);
  final ModelWrapper<M,Integer> wrapper = getModelWrapper();
  setModelWrapper(new ModelWrapper<M,Integer> {

        public M getModel() {
            return wrapper.getModel();
        }

        public int getColumnCount() {
            return wrapper.getColumnCount();
        }

        public int getRowCount() {
            return wrapper.getRowCount();
        }

        public Object getValueAt(int row, int column) {
            Object obj = wrapper.getValueAt(row, column);
            return obj == null ? NULL_OBJECT : obj;
        }

        public String getStringValueAt(int row, int column) {
            return wrapper.getStringValueAt(row, column);
        }

        public Integer getIdentifier(int index) {
            return wrapper.getIdentifier(index);
        }
    }
}

Was mich noch interessiert ist, muß ich zwei Comparator-Klassen haben, damit ich die Null_Objekte stets unten habe? Sprich: Muß ich immer das Event abfragen und dann den jeweiligen Comparator neu zuweisen?

In meinem Fall ist der Vergleich noch simpler als oben beschrieben. Ich vergleich absolute Zahlenwerte.

import java.util.Comparator;
public class AbsoluteNumberComparator implements Comparator<Number>{
    public int compare( Number n1, Number n2 ) {
        if( Math.abs(n1.doubleValue()) < Math.abs(n2.doubleValue()) )
            return -1;
        else if( Math.abs(n1.doubleValue()) > Math.abs(n2.doubleValue()) )
            return 1;
        return 0;
    }
}

für die Implementierung des oben beschriebenen, müsste ich diese Funktion abändern in zB:

import java.util.Comparator;
public class AbsoluteNumberComparator implements Comparator<Object>{
    public int compare( Object o1, Object o2 ) {
	
		if (o1.equals(MyTableRowSorter.NULL_OBJECT) && o2.equals(MyTableRowSorter.NULL_OBJECT))
			return 0;
		else if( o1.equals(MyTableRowSorter.NULL_OBJECT) 
			return -1;
		else if( o2.equals(MyTableRowSorter.NULL_OBJECT) 
			return 1;	
	
		if (o1 instanceof Number && o2 instanceof Number)
			if( Math.abs(o1.doubleValue()) < Math.abs(o2.doubleValue()) )
				return -1;
			else if( Math.abs(o1.doubleValue()) > Math.abs(o2.doubleValue()) )
				return 1;
        return 0;
    }
}

Kann ich hier direkt dafür sorgen, dass das Null_Objekt immer am Ende steht?

Gruß Micha