Java 如何使用气泡排序对JTable进行排序？

我想知道如何在

DefaultTableModel

上实现冒泡排序。（我知道有自动分拣机，但我必须使用气泡排序。）我已经知道如何使用气泡排序，但不知道如何在

DefaultTableModel

上实现。我在考虑首先获取行值并将值存储到

字符串[]

中，然后对

字符串[]

进行排序，然后将其转换回

字符串[]

，然后将其放回

表格模型中。有没有更快的办法

编辑：有没有更好的方法？仍然在实现冒泡排序？
在表模型（而不是外部数组）上使用冒泡排序的唯一原因是，我们可以通过查看表来观察排序过程

因此，使用
DefaultTableModel
的
setValueAt
和
getValueAt
方法进行比较和交换。
这里有一个例子

class DTMSlowSorter {
   /**
    */
   private DefaultTableModel model;
   /**
    * the number of the column by which we want to sort
    */
   private int sortColNum;
   /**
    * the comparator for the elements.
    */
   private Comparator comparator;

   /**
    * The time to sleep between two sorting steps.
    */
   private int sleepTime = 500;

   /**
    * swaps the contents of two rows.
    */
   void swap(final int rowA, final int rowB) {
        try {
            EventQueue.invokeAndWait(new Runnable(){public void run() {
                int colCount = model.getColumnCount();
                Object[] temp = new Object[colCount];
                for(int i = 0; i < colCount; i++) {
                   temp[i] = model.getValueAt(rowA, i);
                }
                for(int i = 0; i < colCount; i++) {
                   model.setValueAt(model.getValueAt(rowB, i), rowA, i);
                }
                for(int i = 0; i < colCount; i++) {
                   model.setValueAt(temp[i], rowA, i);
                }
            }});
           Thread.sleep(sleepTime);
        } catch(InterruptedException ex) { ex.printStackTrace();}
   }

   /**
    * compares two rows.
    * @returns
    *      -1 if  A < B
    *       0 if  A = B
    *       1 if  A > B
    */
   int compare(int rowA, int rowB) {
       Object valA = model.getValueAt(rowA, sortColNum);
       Object valB = model.getValueAt(rowB, sortColNum);
       if(comparator != null) {
          return comparator.compare(valA, valB);
       }
       else {
          return ((comparable)valA).compareTo(valB);
       }
   }

   public void sort() {
      // here your bubblesort implementation, using compare and swap.
   }

}

class DTMSlow分拣机{
/**
*/
私有模型；
/**
*要按其排序的列的编号
*/
私家旅馆；
/**
*元素的比较器。
*/
专用比较器；
/**
*两个排序步骤之间的睡眠时间。
*/
私人int睡眠时间=500；
/**
*交换两行的内容。
*/
无效交换（最终整数行A、最终整数行B）{
试一试{
invokeAndWait（新Runnable（）{public void run（））{
int colCount=model.getColumnCount（）；
Object[]temp=新对象[colCount]；
for（int i=0；iB
*/
int比较（int rowA，int rowB）{
Object valA=model.getValueAt（rowA，sortColNum）；
Object valB=model.getValueAt（rowB，sortColNum）；
if（比较器！=null）{
返回比较器。比较（valA，valB）；
}
否则{
收益率（（可比）valA），与（可比）valB；
}
}
公共无效排序（）{
//这里是使用比较和交换的bubblesort实现。
}
}

（我希望我没有在这里完成您的全部作业，但至少您必须自己实现排序。）
在表模型（而不是外部数组）上使用气泡排序的唯一原因是，我们可以通过查看表来观察排序过程

因此，使用
DefaultTableModel
的
setValueAt
和
getValueAt
方法进行比较和交换。
这里有一个例子

class DTMSlowSorter {
   /**
    */
   private DefaultTableModel model;
   /**
    * the number of the column by which we want to sort
    */
   private int sortColNum;
   /**
    * the comparator for the elements.
    */
   private Comparator comparator;

   /**
    * The time to sleep between two sorting steps.
    */
   private int sleepTime = 500;

   /**
    * swaps the contents of two rows.
    */
   void swap(final int rowA, final int rowB) {
        try {
            EventQueue.invokeAndWait(new Runnable(){public void run() {
                int colCount = model.getColumnCount();
                Object[] temp = new Object[colCount];
                for(int i = 0; i < colCount; i++) {
                   temp[i] = model.getValueAt(rowA, i);
                }
                for(int i = 0; i < colCount; i++) {
                   model.setValueAt(model.getValueAt(rowB, i), rowA, i);
                }
                for(int i = 0; i < colCount; i++) {
                   model.setValueAt(temp[i], rowA, i);
                }
            }});
           Thread.sleep(sleepTime);
        } catch(InterruptedException ex) { ex.printStackTrace();}
   }

   /**
    * compares two rows.
    * @returns
    *      -1 if  A < B
    *       0 if  A = B
    *       1 if  A > B
    */
   int compare(int rowA, int rowB) {
       Object valA = model.getValueAt(rowA, sortColNum);
       Object valB = model.getValueAt(rowB, sortColNum);
       if(comparator != null) {
          return comparator.compare(valA, valB);
       }
       else {
          return ((comparable)valA).compareTo(valB);
       }
   }

   public void sort() {
      // here your bubblesort implementation, using compare and swap.
   }

}

class DTMSlow分拣机{
/**
*/
私有模型；
/**
*要按其排序的列的编号
*/
私家旅馆；
/**
*元素的比较器。
*/
专用比较器；
/**
*两个排序步骤之间的睡眠时间。
*/
私人int睡眠时间=500；
/**
*交换两行的内容。
*/
无效交换（最终整数行A、最终整数行B）{
试一试{
invokeAndWait（新Runnable（）{public void run（））{
int colCount=model.getColumnCount（）；
Object[]temp=新对象[colCount]；
for（int i=0；iB
*/
int比较（int rowA，int rowB）{
Object valA=model.getValueAt（rowA，sortColNum）；
Object valB=model.getValueAt（rowB，sortColNum）；
if（比较器！=null）{
返回比较器。比较（valA，valB）；
}
否则{
收益率（（可比）valA），与（可比）valB；
}
}
公共无效排序（）{
//这里是使用比较和交换的bubblesort实现。
}
}

（我希望我没有在这里完成你的全部作业，但至少你必须自己实现排序。）
这里的观点很愚蠢，但如果你必须使用冒泡排序，那么你就不会追求速度，那么为什么要寻找更快的方法呢？你的计划听起来不错。目标是分类泡泡糖，所以分类泡泡糖。如果你必须绕冥王星运行，那又怎样？看这个例子@camickr这个网站是关于学习和帮助他人的，而不是积累声望点。发帖后，你应该稍后（几小时/几天）再来查看答案。选择最适合您的答案，单击答案左侧的空心复选标记接受。它将用绿色的支票填写，表明你接受了它。哦，我从来没有看到过！我真的很抱歉=（我真的从来没有看到过，我唯一看到的是上下箭头。这里的观点很愚蠢，但是如果你必须使用气泡排序，那么你就不会追求速度，那么为什么要寻找更快的方法呢？你的计划听起来不错。目标是对气泡进行排序，所以对气泡进行排序。如果你必须绕冥王星运行的话