Java 通过拖放重新排序JList

我遇到了一个关于使用拖放对JList中的元素重新排序的问题。下面的代码是对代码的修改，您可以将元素从一个JList拖到另一个JList（仅以一种方式工作）。我试图使它只对一个JList可用，但这些元素甚至无法从列表中拖出。所以我想这是不可能的。你知道我做错了什么或没有考虑到什么吗

我们的想法是让它为带有缩略图的Jlist工作，但由于我甚至不能让它只使用字符串工作。。。我已经看了好几本D'n'D教程，但还是没法让它发挥作用。 感谢您的帮助

import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;
import java.awt.datatransfer.*;
import java.io.IOException;

public class DragAndDrop extends JFrame {


DefaultListModel<String> transport = new DefaultListModel<String>();
JList<String> transportList = new JList<String>(transport);

public DragAndDrop() {
    setLayout(new FlowLayout());

    transport.addElement("Bike");
    transport.addElement("Car");
    transport.addElement("Truck");
    transport.addElement("Boat");

    JScrollPane transportScroll = new JScrollPane(transportList);
    transportScroll.setBorder(new TitledBorder("Transportation"));

    add(transportScroll);

    transportList.setDragEnabled(true);

    transportList.setTransferHandler(new TransferHandler() {
        int index;  

        @Override
        public int getSourceActions(JComponent comp) {
            return COPY_OR_MOVE;
        }

        @Override
        public Transferable createTransferable(JComponent comp) {
            index = transportList.getSelectedIndex(); 
            return new StringSelection(transportList.getSelectedValue());
        }


        @Override
        public void exportDone( JComponent comp, Transferable trans, int action ) {
            if (action==MOVE) {
                transport.remove(index);
            }
        }
    });

    transportList.setDropMode(DropMode.ON);

    transportList.setTransferHandler(new TransferHandler() {
        @Override
        public boolean canImport(TransferHandler.TransferSupport support) {
            // data of type string?
            return support.isDataFlavorSupported(DataFlavor.stringFlavor);
        }

        @Override
        public boolean importData(TransferHandler.TransferSupport support) {
            try {
                // convert data to string
                String s = (String)support.getTransferable().getTransferData(DataFlavor.stringFlavor);
                JList.DropLocation dl = (JList.DropLocation)support.getDropLocation();
                transport.add(dl.getIndex(),s);
                return true;
            } 
            catch (UnsupportedFlavorException e) {} 
            catch (IOException e) {}

            return false;
        }
    });

    pack();

    setDefaultCloseOperation(EXIT_ON_CLOSE);
    setVisible(true);
}

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

}

import javax.swing.*；
导入javax.swing.border.*；
导入java.awt.*；
导入java.awt.datatransfer.*；
导入java.io.IOException；
公共类DragAndDrop扩展JFrame{
DefaultListModel传输=新建DefaultListModel（）；
JList transportList=新的JList（传输）；
公共DragAndDrop（）{
setLayout（新的FlowLayout（））；
运输.补充（“自行车”）；
运输附录（“汽车”）；
运输.补充（“卡车”）；
运输附录（“船”）；
JScrollPane transportScroll=新的JScrollPane（transportList）；
运输订单（新标题边界（“运输”）；
添加（滚动）；
transportList.setDragEnabled（true）；
setTransferHandler（新的TransferHandler（）{
整数指数；
@凌驾
public int getSourceActions（JComponent comp）{
返回拷贝或移动；
}
@凌驾
公共可转让或可转让（JComponent comp）{
index=transportList.getSelectedIndex（）；
返回新的StringSelection（transportList.getSelectedValue（））；
}
@凌驾
公共无效导出已完成（JComponent comp、可转移的trans、int action）{
如果（动作==移动）{
运输。移除（索引）；
}
}
});
transportList.setDropMode（DropMode.ON）；
setTransferHandler（新的TransferHandler（）{
@凌驾
公共布尔值canImport（TransferHandler.TransferSupport）{
//字符串类型的数据？
返回support.isDataFlavorSupported（DataFlavor.stringFlavor）；
}
@凌驾
公共布尔输入数据（TransferHandler.TransferSupport）{
试一试{
//将数据转换为字符串
字符串s=（字符串）support.getTransferable（）.getTransferData（DataFlavor.stringFlavor）；
JList.DropLocation dl=（JList.DropLocation）support.getDropLocation（）；
transport.add（dl.getIndex（），s）；
返回true；
} 
捕获（无支持的Lavore异常）{}
捕获（IOE）{}
返回false；
}
});
包装（）；
setDefaultCloseOperation（关闭时退出）；
setVisible（真）；
}
公共静态void main（字符串[]args）{
新DragAndDrop（）；
}
}

请注意，如果这是一个重新发布，请道歉

编辑 我想我已经把它修好了：必须使用不同的TransferHandler-应该只有一个，并且包含第二个中的所有方法。

请参阅DnD上Swing教程中的，以获取将放在同一个JList或另一个JList上的示例。

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.EventQueue;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.dnd.DragSource;
import java.io.IOException;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Objects;
// import javax.activation.ActivationDataFlavor;
// import javax.activation.DataHandler;
import javax.swing.BorderFactory;
import javax.swing.DefaultListModel;
import javax.swing.DropMode;
import javax.swing.Icon;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.ListCellRenderer;
import javax.swing.ListSelectionModel;
import javax.swing.TransferHandler;
import javax.swing.UIManager;
import javax.swing.WindowConstants;

public class DragAndDropTest {
  public JComponent makeUI() {
    DefaultListModel<Thumbnail> m = new DefaultListModel<>();
    for (String s : Arrays.asList("error", "information", "question", "warning")) {
      m.addElement(new Thumbnail(s));
    }

    JList<Thumbnail> list = new JList<>(m);
    list.getSelectionModel().setSelectionMode(
      ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
    list.setTransferHandler(new ListItemTransferHandler());
    list.setDropMode(DropMode.INSERT);
    list.setDragEnabled(true);
    // https://java-swing-tips.blogspot.com/2008/10/rubber-band-selection-drag-and-drop.html
    list.setLayoutOrientation(JList.HORIZONTAL_WRAP);
    list.setVisibleRowCount(0);
    list.setFixedCellWidth(80);
    list.setFixedCellHeight(80);
    list.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));

    list.setCellRenderer(new ListCellRenderer<Thumbnail>() {
      private final JPanel p = new JPanel(new BorderLayout());
      private final JLabel icon = new JLabel((Icon)null, JLabel.CENTER);
      private final JLabel label = new JLabel("", JLabel.CENTER);

      @Override
      public Component getListCellRendererComponent(
        JList<? extends Thumbnail> list, Thumbnail value, int index,
        boolean isSelected, boolean cellHasFocus) {
        icon.setIcon(value.icon);
        label.setText(value.name);
        label.setForeground(isSelected ? list.getSelectionForeground()
                            : list.getForeground());
        p.add(icon);
        p.add(label, BorderLayout.SOUTH);
        p.setBackground(isSelected ? list.getSelectionBackground()
                        : list.getBackground());
        return p;
      }
    });
    return new JScrollPane(list);
  }

  public static void main(String[] args) {
    EventQueue.invokeLater(() -> createAndShowGUI());
  }

  public static void createAndShowGUI() {
    JFrame f = new JFrame();
    f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    f.getContentPane().add(new DragAndDropTest().makeUI());
    f.setSize(320, 240);
    f.setLocationRelativeTo(null);
    f.setVisible(true);
  }
}

class Thumbnail implements Serializable {
  public final String name;
  public final Icon icon;
  public Thumbnail(String name) {
    this.name = name;
    this.icon = UIManager.getIcon("OptionPane." + name + "Icon");
  }
}

// @camickr already suggested above.
// https://docs.oracle.com/javase/tutorial/uiswing/dnd/dropmodedemo.html
@SuppressWarnings("serial")
class ListItemTransferHandler extends TransferHandler {
  protected final DataFlavor localObjectFlavor;
  protected int[] indices;
  protected int addIndex = -1; // Location where items were added
  protected int addCount; // Number of items added.

  public ListItemTransferHandler() {
    super();
    // localObjectFlavor = new ActivationDataFlavor(
    //   Object[].class, DataFlavor.javaJVMLocalObjectMimeType, "Array of items");
    localObjectFlavor = new DataFlavor(Object[].class, "Array of items");
  }

  @Override
  protected Transferable createTransferable(JComponent c) {
    JList<?> source = (JList<?>) c;
    c.getRootPane().getGlassPane().setVisible(true);

    indices = source.getSelectedIndices();
    Object[] transferedObjects = source.getSelectedValuesList().toArray(new Object[0]);
    // return new DataHandler(transferedObjects, localObjectFlavor.getMimeType());
    return new Transferable() {
      @Override public DataFlavor[] getTransferDataFlavors() {
        return new DataFlavor[] {localObjectFlavor};
      }
      @Override public boolean isDataFlavorSupported(DataFlavor flavor) {
        return Objects.equals(localObjectFlavor, flavor);
      }
      @Override public Object getTransferData(DataFlavor flavor)
            throws UnsupportedFlavorException, IOException {
        if (isDataFlavorSupported(flavor)) {
          return transferedObjects;
        } else {
          throw new UnsupportedFlavorException(flavor);
        }
      }
    };
  }

  @Override
  public boolean canImport(TransferSupport info) {
    return info.isDrop() && info.isDataFlavorSupported(localObjectFlavor);
  }

  @Override
  public int getSourceActions(JComponent c) {
    Component glassPane = c.getRootPane().getGlassPane();
    glassPane.setCursor(DragSource.DefaultMoveDrop);
    return MOVE; // COPY_OR_MOVE;
  }

  @SuppressWarnings("unchecked")
  @Override
  public boolean importData(TransferSupport info) {
    TransferHandler.DropLocation tdl = info.getDropLocation();
    if (!canImport(info) || !(tdl instanceof JList.DropLocation)) {
      return false;
    }

    JList.DropLocation dl = (JList.DropLocation) tdl;
    JList target = (JList) info.getComponent();
    DefaultListModel listModel = (DefaultListModel) target.getModel();
    int max = listModel.getSize();
    int index = dl.getIndex();
    index = index < 0 ? max : index; // If it is out of range, it is appended to the end
    index = Math.min(index, max);

    addIndex = index;

    try {
      Object[] values = (Object[]) info.getTransferable().getTransferData(localObjectFlavor);
      for (int i = 0; i < values.length; i++) {
        int idx = index++;
        listModel.add(idx, values[i]);
        target.addSelectionInterval(idx, idx);
      }
      addCount = values.length;
      return true;
    } catch (UnsupportedFlavorException | IOException ex) {
      ex.printStackTrace();
    }

    return false;
  }

  @Override
  protected void exportDone(JComponent c, Transferable data, int action) {
    c.getRootPane().getGlassPane().setVisible(false);
    cleanup(c, action == MOVE);
  }

  private void cleanup(JComponent c, boolean remove) {
    if (remove && Objects.nonNull(indices)) {
      if (addCount > 0) {
        // https://github.com/aterai/java-swing-tips/blob/master/DragSelectDropReordering/src/java/example/MainPanel.java
        for (int i = 0; i < indices.length; i++) {
          if (indices[i] >= addIndex) {
            indices[i] += addCount;
          }
        }
      }
      JList source = (JList) c;
      DefaultListModel model = (DefaultListModel) source.getModel();
      for (int i = indices.length - 1; i >= 0; i--) {
        model.remove(indices[i]);
      }
    }

    indices = null;
    addCount = 0;
    addIndex = -1;
  }
}

导入java.awt.BorderLayout；
导入java.awt.Component；
导入java.awt.EventQueue；
导入java.awt.datatransfer.DataFlavor；
导入java.awt.datatransfer.transfer；
导入java.awt.datatransfer.UnsupportedFlavorException；
导入java.awt.dnd.DragSource；
导入java.io.IOException；
导入java.io.Serializable；
导入java.util.array；
导入java.util.Objects；
//导入javax.activation.ActivationDataFlavor；
//导入javax.activation.DataHandler；
导入javax.swing.BorderFactory；
导入javax.swing.DefaultListModel；
导入javax.swing.DropMode；
导入javax.swing.Icon；
导入javax.swing.JComponent；
导入javax.swing.JFrame；
导入javax.swing.JLabel；
导入javax.swing.JList；
导入javax.swing.JPanel；
导入javax.swing.JScrollPane；
导入javax.swing.ListCellRenderer；
导入javax.swing.ListSelectionModel；
导入javax.swing.TransferHandler；
导入javax.swing.UIManager；
导入javax.swing.WindowConstants；
公共类DragAndDropTest{
公共JComponent makeUI（）{
DefaultListModel m=新的DefaultListModel（）；
对于（字符串s:Arrays.asList（“错误”、“信息”、“问题”、“警告”））{
m、 添加元素（新缩略图）；
}
JList列表=新JList（m）；
list.getSelectionModel（）.setSelectionMode(
ListSelectionModel.MULTIPLE_INTERVAL_SELECTION）；
setTransferHandler（新的ListItemTransferHandler（））；
list.setDropMode（DropMode.INSERT）；
list.setDragEnabled（true）；
// https://java-swing-tips.blogspot.com/2008/10/rubber-band-selection-drag-and-drop.html
list.setLayoutOrientation（JList.HORIZONTAL_WRAP）；
list.setVisibleRowCount（0）；
列表。设置固定单元格宽度（80）；
列表。设置固定单元高度（80）；
list.setboorder（BorderFactory.createEmptyBorder（10,10,10,10））；
setCellRenderer（新的ListCellRenderer（）{
private final JPanel p=new JPanel（new BorderLayout（））；
私有最终JLabel图标=新JLabel（（图标）null，JLabel.CENTER）；
专用最终JLabel标签=新的JLabel（“，JLabel.CENTER）；
@凌驾
公共组件GetListCellRenderComponent(
JList正如OP在对原始问题的编辑中所指出的，给出的示例中的问题是有两个传输处理程序，并且正如他们在回答中正确指出的，Java教程中有一个示例可以工作

Java教程中的示例的问题是，当使用DropMode.INSERT

并将当前

JList

中的项目移动到所选索引之前时，该项目是重复的。这将删除

JList

中的项目，并将该项目的副本放在所选位置

import java.awt.EventQueue;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.StringSelection;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;

import javax.swing.DefaultListModel;
import javax.swing.DropMode;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JScrollPane;
import javax.swing.ListSelectionModel;
import javax.swing.TransferHandler;

@SuppressWarnings("serial")
public class GUI extends JFrame {
    protected GUI() {
        super("Simple Rearrangeable List");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        createPanel();
        setBounds(10, 10, 350, 500);
        setVisible(true);
    }

    private void createPanel() {
        DefaultListModel<String> strings = new DefaultListModel<String>();

        for(int i = 1; i <= 100; i++) {
            strings.addElement("Item " + i);
        }

        JList<String> dndList = new JList<String>(strings);
        dndList.setDragEnabled(true);
        dndList.setDropMode(DropMode.INSERT);
        dndList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        dndList.setTransferHandler(new TransferHandler() {
            private int index;
            private boolean beforeIndex = false; //Start with `false` therefore if it is removed from or added to the list it still works

            @Override
            public int getSourceActions(JComponent comp) {
                return MOVE;
            }

            @Override
            public Transferable createTransferable(JComponent comp) {
                index = dndList.getSelectedIndex(); 
                return new StringSelection(dndList.getSelectedValue());
            }

            @Override
            public void exportDone(JComponent comp, Transferable trans, int action) {
                if (action == MOVE) {
                    if(beforeIndex)
                        strings.remove(index + 1);
                    else
                        strings.remove(index);
                }
            }

            @Override
            public boolean canImport(TransferHandler.TransferSupport support) {
                return support.isDataFlavorSupported(DataFlavor.stringFlavor);
            }

            @Override
            public boolean importData(TransferHandler.TransferSupport support) {
                try {
                    String s = (String) support.getTransferable().getTransferData(DataFlavor.stringFlavor);
                    JList.DropLocation dl = (JList.DropLocation) support.getDropLocation();
                    strings.add(dl.getIndex(), s);
                    beforeIndex = dl.getIndex() < index ? true : false;
                    return true;
                } catch (UnsupportedFlavorException | IOException e) {
                    e.printStackTrace();
                }

                return false;
            }
        });

        JScrollPane scrollPane = new JScrollPane(dndList);
        getContentPane().add(scrollPane);
    }

    public static void main(String[] args) {
        EventQueue.invokeLater(() -> new GUI());
    }
}