Java 使用自己的对象从JTree拖放到JList

我有一个JTree和DefaultMutableTreeNodes。在某些级别上，这些节点是用我自己的可序列化对象初始化的。总共有两种不同类型的对象（称为“步骤”和“顺序”）。我希望能够只删除使用这两个对象之一初始化的节点。任何其他仅仅是字符串的节点都不应该是可拖放的。一个“顺序”可以包含多个“步骤”。如果它们被插入JList，我希望能够将它们拖到JPanel上。如果删除了“订单”，则所有“步骤”都应插入，如果只删除了“步骤”，则只应插入特定的“步骤”

SSCCE下面

JTree：

tree = new JTree();
tree.setShowsRootHandles(true);
tree.setRootVisible(false);
tree.setDragEnabled(true);
tree.setModel(treeModel);
tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);

JPanel：

public class TablePanel extends JPanel
{
    private static final long serialVersionUID = 3216206960422611905L;

    public TablePanel()
    {
        super();

        setLayout(new MigLayout("", "[grow]", "[][grow]"));

        JProgressBar progressBar = new JProgressBar();
        progressBar.setMaximum(28800); // 8 hours in seconds
        progressBar.setStringPainted(true);
        add(progressBar, "cell 0 0,growx");

        DefaultListModel<Step> listModel = new DefaultListModel<Step>();

        JList<Step> list = new JList<Step>();
        list.setModel(listModel);

        setDropTarget(new DropTarget(this, TransferHandler.COPY, new DropTargetAdapter()
        {
            private int    index    = 0;
            private int    amount    = 0;

            @Override
            public void drop(DropTargetDropEvent dtde)
            {
                amount = 0;
                index = 0;
            }

            @Override
            public void dragExit(DropTargetEvent dte)
            {
                if (listModel.size() > 0)
                {
                    if (amount == 1)
                    {
                        listModel.remove(index);
                    }
                    else
                    {
                        for (int i = 0; i < amount; i++)
                        {
                            listModel.remove(index + i);
                        }
                    }

                    amount = 0;
                }
            }

            @Override
            public void dragEnter(DropTargetDragEvent dtde)
            {
                try
                {
                    Transferable tr = dtde.getTransferable();
                    if (dtde.isDataFlavorSupported(Order.auftragFlavor))
                    {
                        Order a = (Order) tr.getTransferData(Order.auftragFlavor); // Wrong, how do I get this?

                        dtde.acceptDrag(DnDConstants.ACTION_COPY);

                        amount = a.getSteps().size();

                    }
                    else if (dtde.isDataFlavorSupported(Step.arbeitsgangFlavor))
                    {
                        Step ag = (Step) tr.getTransferData(Step.arbeitsgangFlavor);

                        dtde.acceptDrag(DnDConstants.ACTION_COPY);

                        amount = 1;
                    }
                    else
                    {
                        dtde.rejectDrag();
                    }
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                    dtde.rejectDrag();
                }
            }

            @Override
            public void dragOver(DropTargetDragEvent dtde)
            {
                try
                {
                    Transferable tr = dtde.getTransferable();
                    if (dtde.isDataFlavorSupported(Order.auftragFlavor))
                    {
                        Order a = (Order) tr.getTransferData(Order.auftragFlavor); // Wrong, how do I get this?

                        dtde.acceptDrag(DnDConstants.ACTION_COPY);

                        amount = a.getSteps().size();
                    }
                    else if (dtde.isDataFlavorSupported(Step.arbeitsgangFlavor))
                    {
                        Step ag = (Step) tr.getTransferData(Step.arbeitsgangFlavor);

                        dtde.acceptDrag(DnDConstants.ACTION_COPY);

                        amount = 1;
                    }
                    else dtde.rejectDrag();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                    dtde.rejectDrag();
                }
            }
        }, true, null));

        add(list, "cell 0 1,grow");
    }
}

但不是仅仅是字符串的节点

您可以使用

TransferHandler\createTransferable（…）

方法来获取

DefaultMutableTreeNode

import java.awt.*；
导入java.awt.datatransfer.*；
导入java.awt.dnd.*；
导入java.io.*；
导入java.util.*；
导入javax.activation.*；
导入javax.swing.*；
导入javax.swing.tree.*；
公共类Test2{
公共JComponent makeUI（）{
DefaultMutableTreeNode根=新的DefaultMutableTreeNode（“根”）；
DefaultMutableTreeNode字符串1=新的DefaultMutableTreeNode（“字符串1”）；
DefaultMutableTreeNode order1=新的DefaultMutableTreeNode（新的ParentObject（））；
order1.add（新的DefaultMutableTreeNode（新的ChildObject（））；
order1.add（新的DefaultMutableTreeNode（新的ChildObject（））；
string1.add（order1）；
root.add（string1）；
DefaultTreeModel模型=新的DefaultTreeModel（根）；
JTree树=新的JTree（模型）；
tree.setShowsRootHandles（真）；
tree.setRootVisible（false）；
tree.getSelectionModel（）.setSelectionMode（TreeSelectionModel.SINGLE_tree_SELECTION）；
setTransferHandler（新的TreeTransferHandler（））；
tree.setDragEnabled（true）；
DefaultListModel listModel=新的DefaultListModel（）；
JList list=新JList（）；
list.setModel（listModel）；
setDropTarget（新DropTarget（list，TransferHandler.COPY，new DropTargetAdapter（））{
私人作废打印（可转让tr）{
试一试{
对象节点=tr.getTransferData（TreeTransferHandler.FLAVOR）；
System.out.println（节点）；//我想要实际的对象
}捕获（无支持的LavorException | IOException ex）{
例如printStackTrace（）；
}
}
@凌驾
公共作废删除（DropTargetDropEvent dtde）{
if（dtde.isDataFlavorSupported（TreeTransferHandler.FLAVOR））{
打印（dtde.getTransferable（））；
}
}
@重写公共void dragExit（DropTargetEvent dte）{}
@重写公共无效dragEnter（DropTargetDragEvent dtde）{}
@重写公共无效dragOver（DropTargetDragEvent dtde）{}
}，true，null））；
JPanel contentPane=newjpanel（newgridlayout（1,2））；
setboorder（BorderFactory.createEmptyByOrder（5,5,5,5））；
添加（新的JScrollPane（树），BorderLayout.WEST）；
添加（新的JScrollPane（列表），BorderLayout.CENTER）；
返回内容窗格；
}
公共静态void main（字符串[]args）{
invokeLater（新的Runnable（）{
@重写公共无效运行（）{
试一试{
JFrame f=新的JFrame（）；
f、 setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
f、 getContentPane（）.add（新Test2（）.makeUI（））；
f、 立根（100100450300）；
f、 setVisible（真）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
});
}
}
类ParentObject实现可序列化{
公共ArrayList getChildren（）{
返回新的ArrayList（）；
}
@凌驾
公共字符串toString（）{
返回“ParentObject”；
}
}
类ChildObject实现了可序列化{
@凌驾
公共字符串toString（）{
返回“ChildObject”；
}
}
类TreeTransferHandler扩展了TransferHandler{
公共静态最终DataFlavor=新激活DataFlavor(
DefaultMutableTreeNode[]类，
DataFlavor.javaJVMLocalObjectMimeType，
“DefaultMutableTreeNode数组”）；
@覆盖受保护的可转移组件（JComponent c）{
JTree源=（JTree）c；
树路径[]路径=source.getSelectionPath（）；
DefaultMutableTreeNode[]节点=新的DefaultMutableTreeNode[path.length]；
for（int i=0；i

为了更快地获得更好的帮助，请发布一个or。我添加了一个示例。希望这是足够的帮助了很多，谢谢！我读过关于TransferHandler的文章，但不确定，也不知道该怎么做。对不起，我不能再投票了，因为我还有不到15次的重复。@aterai你能帮我吗

public class Test extends JFrame
{
    private static final long serialVersionUID = 1L;
    private JPanel contentPane;

    public static void main(String[] args)
    {
        EventQueue.invokeLater(new Runnable()
        {
            public void run()
            {
                try
                {
                    Test window = new Test();
                    window.setVisible(true);
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            }
        });
    }

    public Test()
    {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 450, 300);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        contentPane.setLayout(new BorderLayout(0, 0));
        setContentPane(contentPane);

        DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");
        DefaultMutableTreeNode string1 = new DefaultMutableTreeNode("String 1");
        DefaultMutableTreeNode order1 = new DefaultMutableTreeNode(new ParentObject());
        order1.add(new DefaultMutableTreeNode(new ChildObject()));
        order1.add(new DefaultMutableTreeNode(new ChildObject()));

        string1.add(order1);

        root.add(string1);

        DefaultTreeModel model = new DefaultTreeModel(root);

        JTree tree = new JTree(model);
        tree.setShowsRootHandles(true);
        tree.setRootVisible(false);
        tree.setDragEnabled(true);
        tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
        contentPane.add(tree, BorderLayout.WEST);

        CustPanel panel = new CustPanel();
        contentPane.add(panel, BorderLayout.CENTER);
    }
}

class CustPanel extends JPanel
{
    private static final long serialVersionUID = 1L;

    public CustPanel()
    {
        super();
        setLayout(new MigLayout("", "[grow]", "[][grow]"));

        JProgressBar progressBar = new JProgressBar();
        add(progressBar, "cell 0 0,growx");

        DefaultListModel<ChildObject> listModel = new DefaultListModel<ChildObject>();

        JList<ChildObject> list = new JList<ChildObject>();
        list.setModel(listModel);

        setDropTarget(new DropTarget(this, TransferHandler.COPY, new DropTargetAdapter()
        {
            @Override
            public void drop(DropTargetDropEvent dtde)
            {
                Transferable tr = dtde.getTransferable();
                if (dtde.isDataFlavorSupported(DataFlavor.stringFlavor))
                {
                    try
                    {
                        System.out.println((String) tr.getTransferData(DataFlavor.stringFlavor)); // I want the actual object
                    }
                    catch (UnsupportedFlavorException | IOException e)
                    {
                        e.printStackTrace();
                    }
                }
            }

            @Override
            public void dragExit(DropTargetEvent dte)
            {

            }

            @Override
            public void dragEnter(DropTargetDragEvent dtde)
            {
                Transferable tr = dtde.getTransferable();
                if (dtde.isDataFlavorSupported(DataFlavor.stringFlavor))
                {
                    try
                    {
                        System.out.println((String) tr.getTransferData(DataFlavor.stringFlavor)); // I want the actual object
                    }
                    catch (UnsupportedFlavorException | IOException e)
                    {
                        e.printStackTrace();
                    }
                }
            }

            @Override
            public void dragOver(DropTargetDragEvent dtde)
            {
                Transferable tr = dtde.getTransferable();
                if (dtde.isDataFlavorSupported(DataFlavor.stringFlavor))
                {
                    try
                    {
                        System.out.println((String) tr.getTransferData(DataFlavor.stringFlavor)); // I want the actual object
                    }
                    catch (UnsupportedFlavorException | IOException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }, true, null));

        add(list, "cell 0 1,grow");
    }
}

class ParentObject implements Serializable
{
    private static final long serialVersionUID = 1279985471254050120L;

    public ArrayList<ChildObject> getChildren()
    {
        return new ArrayList<ChildObject>();
    }

    @Override
    public String toString()
    {
        return "ParentObject";
    }
}

class ChildObject implements Serializable
{
    private static final long serialVersionUID = -5833860202973614790L;

    @Override
    public String toString()
    {
        return "ChildObject";
    }
}

import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.dnd.*;
import java.io.*;
import java.util.*;
import javax.activation.*;
import javax.swing.*;
import javax.swing.tree.*;

public class Test2 {
  public JComponent makeUI() {
    DefaultMutableTreeNode root    = new DefaultMutableTreeNode("root");
    DefaultMutableTreeNode string1 = new DefaultMutableTreeNode("String 1");
    DefaultMutableTreeNode order1  = new DefaultMutableTreeNode(new ParentObject());
    order1.add(new DefaultMutableTreeNode(new ChildObject()));
    order1.add(new DefaultMutableTreeNode(new ChildObject()));
    string1.add(order1);
    root.add(string1);

    DefaultTreeModel model = new DefaultTreeModel(root);
    JTree tree = new JTree(model);
    tree.setShowsRootHandles(true);
    tree.setRootVisible(false);
    tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
    tree.setTransferHandler(new TreeTransferHandler());
    tree.setDragEnabled(true);

    DefaultListModel<ChildObject> listModel = new DefaultListModel<ChildObject>();
    JList<ChildObject> list = new JList<ChildObject>();
    list.setModel(listModel);
    list.setDropTarget(new DropTarget(list, TransferHandler.COPY, new DropTargetAdapter() {
      private void print(Transferable tr) {
        try {
          Object node = tr.getTransferData(TreeTransferHandler.FLAVOR);
          System.out.println(node); // I want the actual object
        } catch (UnsupportedFlavorException | IOException ex) {
          ex.printStackTrace();
        }
      }
      @Override
      public void drop(DropTargetDropEvent dtde) {
        if (dtde.isDataFlavorSupported(TreeTransferHandler.FLAVOR)) {
          print(dtde.getTransferable());
        }
      }
      @Override public void dragExit(DropTargetEvent dte) {}
      @Override public void dragEnter(DropTargetDragEvent dtde) {}
      @Override public void dragOver(DropTargetDragEvent dtde) {}
    }, true, null));

    JPanel contentPane = new JPanel(new GridLayout(1, 2));
    contentPane.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
    contentPane.add(new JScrollPane(tree), BorderLayout.WEST);
    contentPane.add(new JScrollPane(list), BorderLayout.CENTER);

    return contentPane;
  }
  public static void main(String[] args) {
    EventQueue.invokeLater(new Runnable() {
      @Override public void run() {
        try {
          JFrame f = new JFrame();
          f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          f.getContentPane().add(new Test2().makeUI());
          f.setBounds(100, 100, 450, 300);
          f.setVisible(true);
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    });
  }
}

class ParentObject implements Serializable {
  public ArrayList<ChildObject> getChildren() {
    return new ArrayList<ChildObject>();
  }
  @Override
  public String toString() {
    return "ParentObject";
  }
}

class ChildObject implements Serializable {
  @Override
  public String toString() {
    return "ChildObject";
  }
}

class TreeTransferHandler extends TransferHandler {
  public static final DataFlavor FLAVOR = new ActivationDataFlavor(
    DefaultMutableTreeNode[].class,
    DataFlavor.javaJVMLocalObjectMimeType,
    "Array of DefaultMutableTreeNode");
  @Override protected Transferable createTransferable(JComponent c) {
    JTree source = (JTree) c;
    TreePath[] paths = source.getSelectionPaths();
    DefaultMutableTreeNode[] nodes = new DefaultMutableTreeNode[paths.length];
    for (int i = 0; i < paths.length; i++) {
      nodes[i] = (DefaultMutableTreeNode) paths[i].getLastPathComponent();
    }
    return new DataHandler(nodes, FLAVOR.getMimeType());
  }
  @Override public int getSourceActions(JComponent c) {
    return TransferHandler.COPY;
  }
}