62,612
社区成员
发帖
与我相关
我的任务
分享
package JList;
import java.awt.GridLayout;
import java.awt.event.KeyEvent;
import javax.swing.DefaultListModel;
import javax.swing.JOptionPane;
import JList.SortedListModel.SortOrder;
public class SortedListModelDemo extends javax.swing.JFrame {
public SortedListModelDemo() {
super("Sorted ListModel Demo");
unsortedModel = new DefaultListModel();
sortedModel = new SortedListModel(unsortedModel);
initComponents();
}
private void initComponents() {
bgSortOrder = new javax.swing.ButtonGroup();
txtAddEntry = new javax.swing.JTextField();
btnAddEntry = new javax.swing.JButton();
scrollPane = new javax.swing.JScrollPane();
list = new javax.swing.JList();
btnDeleteSelection = new javax.swing.JButton();
panelSort = new javax.swing.JPanel();
rbAscendingSort = new javax.swing.JRadioButton();
rbDescendingSort = new javax.swing.JRadioButton();
rbUnordered = new javax.swing.JRadioButton();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
txtAddEntry.addKeyListener(new java.awt.event.KeyAdapter() {
public void keyPressed(java.awt.event.KeyEvent evt) {
txtAddEntryKeyPressed(evt);
}
});
btnAddEntry.setText("Add");
btnAddEntry.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
btnAddEntryActionPerformed(evt);
}
});
scrollPane.setBorder(javax.swing.BorderFactory
.createTitledBorder("JList with SortedListModel"));
scrollPane.setMinimumSize(new java.awt.Dimension(0, 0));
scrollPane.setPreferredSize(new java.awt.Dimension(250, 150));
list.setModel(sortedModel);
list.addKeyListener(new java.awt.event.KeyAdapter() {
public void keyPressed(java.awt.event.KeyEvent evt) {
listKeyPressed(evt);
}
});
list
.addListSelectionListener(new javax.swing.event.ListSelectionListener() {
public void valueChanged(
javax.swing.event.ListSelectionEvent evt) {
listValueChanged(evt);
}
});
scrollPane.setViewportView(list);
btnDeleteSelection.setText("Delete");
btnDeleteSelection
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
btnDeleteSelectionActionPerformed(evt);
}
});
panelSort.setBorder(javax.swing.BorderFactory
.createTitledBorder("Sort Order"));
bgSortOrder.add(rbAscendingSort);
rbAscendingSort.setSelected(true);
rbAscendingSort.setText("Ascending");
rbAscendingSort.setBorder(javax.swing.BorderFactory.createEmptyBorder(
0, 0, 0, 0));
rbAscendingSort.setMargin(new java.awt.Insets(0, 0, 0, 0));
rbAscendingSort.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
rbAscendingSortActionPerformed(evt);
}
});
bgSortOrder.add(rbDescendingSort);
rbDescendingSort.setText("Descending");
rbDescendingSort.setBorder(javax.swing.BorderFactory.createEmptyBorder(
0, 0, 0, 0));
rbDescendingSort.setMargin(new java.awt.Insets(0, 0, 0, 0));
rbDescendingSort.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
rbDescendingSortActionPerformed(evt);
}
});
bgSortOrder.add(rbUnordered);
rbUnordered.setText("Unordered");
rbUnordered.setBorder(javax.swing.BorderFactory.createEmptyBorder(0, 0,
0, 0));
rbUnordered.setMargin(new java.awt.Insets(0, 0, 0, 0));
rbUnordered.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
rbUnorderedActionPerformed(evt);
}
});
this.setSize(350, 300);
this.setLayout(null);
scrollPane.setBounds(10, 10, 180, 180);
this.add(scrollPane);
panelSort.setLayout(new GridLayout(3, 1));
panelSort.add(rbAscendingSort);
panelSort.add(rbDescendingSort);
panelSort.add(rbUnordered);
panelSort.setBounds(220, 10, 100, 100);
this.add(panelSort);
txtAddEntry.setBounds(10, 210, 150, 30);
this.add(txtAddEntry);
btnAddEntry.setBounds(220, 180, 80, 30);
this.add(btnAddEntry);
btnDeleteSelection.setBounds(220, 220, 80, 30);
this.add(btnDeleteSelection);
}
private void listValueChanged(javax.swing.event.ListSelectionEvent evt) {
int sortedFirstIndex = evt.getFirstIndex();
int sortedLastIndex = evt.getLastIndex();
for (int sortedIndex = sortedFirstIndex; sortedIndex <= sortedLastIndex; sortedIndex++) {
int unsortedIndex = sortedModel.toUnsortedModelIndex(sortedIndex);
System.out.printf(
"listValueChanged index: %d (sorted) %d (unsorted)\n",
sortedIndex, unsortedIndex);
}
}
private void listKeyPressed(java.awt.event.KeyEvent evt) {
int key = evt.getKeyCode();
if (key == evt.VK_DELETE) {
int option = JOptionPane.showConfirmDialog(this,
"Delete selected elements?");
if (option == JOptionPane.YES_OPTION) {
btnDeleteSelectionActionPerformed(null);
}
}
}
private void rbUnorderedActionPerformed(java.awt.event.ActionEvent evt) {
sortedModel.setSortOrder(SortOrder.UNORDERED);
}
private void rbDescendingSortActionPerformed(java.awt.event.ActionEvent evt) {
sortedModel.setSortOrder(SortOrder.DESCENDING);
}
private void rbAscendingSortActionPerformed(java.awt.event.ActionEvent evt) {
sortedModel.setSortOrder(SortOrder.ASCENDING);
}
private void btnDeleteSelectionActionPerformed(
java.awt.event.ActionEvent evt) {
int[] sortedSelection = list.getSelectedIndices();
int[] unsortedSelection = sortedModel
.toUnsortedModelIndices(sortedSelection);
for (int x = unsortedSelection.length - 1; x >= 0; --x) {
unsortedModel.remove(unsortedSelection[x]);
}
}
private void txtAddEntryKeyPressed(java.awt.event.KeyEvent evt) {
int keyCode = evt.getKeyCode();
if (keyCode == KeyEvent.VK_ENTER) {
btnAddEntryActionPerformed(null);
}
}
private void btnAddEntryActionPerformed(java.awt.event.ActionEvent evt) {
String newText = txtAddEntry.getText();
if (newText != null && newText.length() > 0) {
unsortedModel.addElement(newText);
}
txtAddEntry.setText(null);
}
void test1() {
String[] list = { "turtle", "frog", "anteater", "ant", "rabbit", "dog",
"cat" };
for (String data : list) {
unsortedModel.addElement(data);
}
}
public static void main(String args[]) {
SortedListModelDemo app = new SortedListModelDemo();
app.setVisible(true);
app.test1();
}
private SortedListModel sortedModel;
private DefaultListModel unsortedModel;
private javax.swing.ButtonGroup bgSortOrder;
private javax.swing.JButton btnAddEntry;
private javax.swing.JButton btnDeleteSelection;
private javax.swing.JList list;
private javax.swing.JPanel panelSort;
private javax.swing.JRadioButton rbAscendingSort;
private javax.swing.JRadioButton rbDescendingSort;
private javax.swing.JRadioButton rbUnordered;
private javax.swing.JScrollPane scrollPane;
private javax.swing.JTextField txtAddEntry;
}
public class SortedListModel extends AbstractListModel {
private SortedListModel() {
}
public SortedListModel(ListModel model) {
this(model, SortOrder.ASCENDING, null);
}
public SortedListModel(ListModel model, SortOrder sortOrder) {
this(model, sortOrder, null);
}
public SortedListModel(ListModel model, SortOrder sortOrder, Comparator comp) {
unsortedModel = model;
unsortedModel.addListDataListener(new ListDataListener() {
public void intervalAdded(ListDataEvent e) {
unsortedIntervalAdded(e);
}
public void intervalRemoved(ListDataEvent e) {
unsortedIntervalRemoved(e);
}
public void contentsChanged(ListDataEvent e) {
unsortedContentsChanged(e);
}
});
this.sortOrder = sortOrder;
if (comp != null) {
comparator = comp;
} else {
comparator = Collator.getInstance();
}
int size = model.getSize();
sortedModel = new ArrayList<SortedListEntry>(size);
for (int x = 0; x < size; ++x) {
SortedListEntry entry = new SortedListEntry(x);
int insertionPoint = findInsertionPoint(entry);
sortedModel.add(insertionPoint, entry);
}
}
public Object getElementAt(int index) throws IndexOutOfBoundsException {
int modelIndex = toUnsortedModelIndex(index);
Object element = unsortedModel.getElementAt(modelIndex);
return element;
}
public int getSize() {
int size = sortedModel.size();
return size;
}
public int toUnsortedModelIndex(int index) throws IndexOutOfBoundsException {
int modelIndex = -1;
SortedListEntry entry = sortedModel.get(index);
modelIndex = entry.getIndex();
return modelIndex;
}
public int[] toUnsortedModelIndices(int[] sortedSelectedIndices) {
int[] unsortedSelectedIndices = new int[sortedSelectedIndices.length];
int x = 0;
for(int sortedIndex: sortedSelectedIndices) {
unsortedSelectedIndices[x++] = toUnsortedModelIndex(sortedIndex);
}
Arrays.sort(unsortedSelectedIndices);
return unsortedSelectedIndices;
}
public int toSortedModelIndex(int unsortedIndex) {
int sortedIndex = -1;
int x = -1;
for (SortedListEntry entry : sortedModel) {
++x;
if (entry.getIndex() == unsortedIndex) {
sortedIndex = x;
break;
}
}
return sortedIndex;
}
public int[] toSortedModelIndices(int[] unsortedModelIndices) {
int[] sortedModelIndices = new int[unsortedModelIndices.length];
int x = 0;
for(int unsortedIndex : unsortedModelIndices) {
sortedModelIndices[x++] = toSortedModelIndex(unsortedIndex);
}
Arrays.sort(sortedModelIndices);
return sortedModelIndices;
}
private void resetModelData() {
int index = 0;
for (SortedListEntry entry : sortedModel) {
entry.setIndex(index++);
}
}
public void setComparator(Comparator comp) {
if (comp == null) {
sortOrder = SortOrder.UNORDERED;
comparator = Collator.getInstance();
resetModelData();
} else {
comparator = comp;
Collections.sort(sortedModel);
}
fireContentsChanged(ListDataEvent.CONTENTS_CHANGED, 0, sortedModel.size()-1);
}
public void setSortOrder(SortOrder sortOrder) {
if (this.sortOrder != sortOrder) {
this.sortOrder = sortOrder;
if (sortOrder == SortOrder.UNORDERED) {
resetModelData();
} else {
Collections.sort(sortedModel);
}
fireContentsChanged(ListDataEvent.CONTENTS_CHANGED, 0, sortedModel.size()-1);
}
}
private void unsortedIntervalAdded(ListDataEvent e) {
int begin = e.getIndex0();
int end = e.getIndex1();
int nElementsAdded = end-begin+1;
for (SortedListEntry entry: sortedModel) {
int index = entry.getIndex();
if (index >= begin) {
entry.setIndex(index+nElementsAdded);
}
}
for (int x = begin; x <= end; ++x) {
SortedListEntry newEntry = new SortedListEntry(x);
int insertionPoint = findInsertionPoint(newEntry);
sortedModel.add(insertionPoint, newEntry);
fireIntervalAdded(ListDataEvent.INTERVAL_ADDED, insertionPoint, insertionPoint);
}
}
private void unsortedIntervalRemoved(ListDataEvent e) {
int begin = e.getIndex0();
int end = e.getIndex1();
int nElementsRemoved = end-begin+1;
int sortedSize = sortedModel.size();
boolean[] bElementRemoved = new boolean[sortedSize];
for (int x = sortedSize-1; x >=0; --x) {
SortedListEntry entry = sortedModel.get(x);
int index = entry.getIndex();
if (index > end) {
entry.setIndex(index - nElementsRemoved);
} else if (index >= begin) {
sortedModel.remove(x);
bElementRemoved[x] = true;
}
}
for(int x = bElementRemoved.length-1; x>=0; --x) {
if (bElementRemoved[x]) {
fireIntervalRemoved(ListDataEvent.INTERVAL_REMOVED, x, x);
}
}
}
private void unsortedContentsChanged(ListDataEvent e) {
Collections.sort(sortedModel);
fireContentsChanged(ListDataEvent.CONTENTS_CHANGED, 0, sortedModel.size()-1);
}
private int findInsertionPoint(SortedListEntry entry) {
int insertionPoint = sortedModel.size();
if (sortOrder != SortOrder.UNORDERED) {
insertionPoint = Collections.binarySearch((List)sortedModel, entry);
if (insertionPoint < 0) {
insertionPoint = -(insertionPoint +1);
}
}
return insertionPoint;
}
private List<SortedListEntry> sortedModel;
private ListModel unsortedModel;
private Comparator comparator;
private SortOrder sortOrder;
public enum SortOrder {
UNORDERED,
ASCENDING,
DESCENDING;
}
class SortedListEntry implements Comparable {
private SortedListEntry() {
}
public SortedListEntry(int index) {
this.index = index;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public int compareTo(Object o) {
Object thisElement = unsortedModel.getElementAt(index);
SortedListEntry thatEntry = (SortedListEntry)o;
Object thatElement = unsortedModel.getElementAt(thatEntry.getIndex());
if (comparator instanceof Collator) {
thisElement = thisElement.toString();
thatElement = thatElement.toString();
}
int comparison = comparator.compare(thisElement, thatElement);
if (sortOrder == SortOrder.DESCENDING) {
comparison = -comparison;
}
return comparison;
}
private int index;
}
}