将字符串添加到JList，确切地删除它们，而不是在底部 [英] Add String to JList exactly where they're dropped, not at the bottom

问题描述

我有几个JList都可以作为DnD COPY操作的来源和目的地。他们工作正常，但有一件事 - 元素被添加到列表的底部，而不是在我想要的放置目的地行。

由于 Oracle BasicDnD示例包含此功能（事实上​​，这是我通过Google找到的唯一应用程序），我一直在看一下它的源，看看我是否能够适应它。我试图设置TransferHandler对象，这是我猜想我失踪，但没有新的行为出现。那么（其他）可能会丢失/做错了？

EDIT1：下面显示了我用于这些列表的类。

  private class InteractiveJList extends JList implements DragGestureListener，
 DragSourceListener，DropTargetListener {
 
 private final DropTarget dropTarget; 
 private final DragSource dragSource; 
 private final boolean removeElementsOnFail; 
 private int [] selectedOnes; 
 
 @SuppressWarnings（unchecked）
 private InteractiveJList（最终的ListModel模型，
 final boolean _removElementsOnFail）{
 super（model）; 
 this.dragSource = new DragSource（）; 
 this.dragSource 
 .createDefaultDragGestureRecognizer（this，DnDConstants.ACTION_COPY，
 this）; 
 this.dropTarget = new DropTarget（this，this）; 
 this.removeElementsOnFail = _removElementsOnFail; 
} 
 
 @Override 
 public void dragEnter（final DropTargetDragEvent arg0）{
} 
 
 @Override 
 public void dragExit （最终的DropTargetEvent arg0）{
} 
 
 @Override 
 public void dragOver（final DropTargetDragEvent arg0）{
} 
 
 @Override 
 public void drop（final DropTargetDropEvent event）{
 if（！this.removeElementsOnFail）{
 event.rejectDrop（）; 
 return; 
} 
 final可转移可转移= event.getTransferable（）; 
 
 if（transferable.isDataFlavorSupported（DataFlavor.stringFlavor））{
 String all; 
 try {
 all =（String）transferable.getTransferData（DataFlavor.stringFlavor）; 
} catch（final UnsupportedFlavorException | IOException ex）{
 event.rejectDrop（）; 
 return; 
} 
 event.acceptDrop（DnDConstants.ACTION_COPY）; 
 final StringTokenizer tokenizer = new StringTokenizer（all，|）; 
 while（tokenizer.hasMoreTokens（））{
（（StringListModel）this.getModel（））。addElement（tokenizer.nextToken（））; 
} 
 event.getDropTargetContext（）。dropComplete（Boolean.TRUE）; 
} else {
 event.rejectDrop（）; 
} 
} 
 
 @Override 
 public void dropActionChanged（final DropTargetDragEvent event）{
} 
 
 @Override 
 public void dragEnter（final DragSourceDragEvent arg0）{
} 
 
 @Override 
 public void dragExit（final DragSourceEvent arg0）{
} 
 
 @Override 
 public void dragOver（final DragSourceDragEvent arg0）{
} 
 
 @Override 
 public void dropActionChanged（final DragSourceDragEvent dragSourceEvent）{
} 
 
 @Override 
 public void dragGestureRecognized（final DragGestureEvent dragGestureEvent）{
 final Object listSelectedValue = this.getSelectedValue（）; 
 this.selectedOnes = this.getSelectedIndices（）; 
 final StringBuilder bridge = new StringBuilder（）; 
 for（final int x：this.selectedOnes）{
 bridge.append（this.getModel（）。getElementAt（x））。append（|）; 
} 
 if（listSelectedValue！= null）{
 final StringSelection stringTransferable = 
 new StringSelection（bridge.toString（）
 .substring（0，bridge.length ） -  1））; 
 this.dragSource.startDrag（dragGestureEvent，DragSource.DefaultCopyDrop，
 stringTransferable，this）; 
} 
} 
 
 @Override 
 public void dragDropEnd（final DragSourceDropEvent dragSourceDropEvent）{
 if（！dragSourceDropEvent.getDropSuccess（））{
 if（this.removeElementsOnFail）{
 for（final int x：this.selectedOnes）{
（（StringListModel）this.getModel（））。removeElement（x）; 
} 
} 
} 
} 
 
} 
  

使用构造函数中的布尔标志，因为对于其中一个列表，如果删除操作被拒绝，那么该元素必须被删除，而不在另一个列表中。这样我就可以处理了。 StringListModel 是 AbstractListModel 来处理字符串列表。它可以在底部和请求的位置添加元素，清除列表，并删除某些元素。它的东西，触发相应的事件，没有进一步的。

EDIT2：下面显示了我的MadProgrammer建议的实现：

  private static class UserTransferHandler extends TransferHandler {
 
 private final JList list; 
 
 private UserTransferHandler（final JList list）{
 this.list = list; 
} 
 
 @Override 
 public boolean canImport（final TransferSupport support）{
 System.out.println（canImport）; 
 boolean canImport = false; 
 if（support.isDataFlavorSupported（UserTransferable.USER_DATA_FLAVOR））{
 final JList.DropLocation dl = 
（JList.DropLocation）support.getDropLocation（）; 
 if（dl.getIndex（）！= -1）{
 canImport = true; 
} 
} 
 return canImport; 
} 
 
 @Override 
 protected void exportDone（final JComponent source，final Transferable data，
 final int action）{
 System.out.println exportDone）; 
} 
 
 @Override 
 public boolean importData（最终TransferSupport支持）{
 System.out.println（importData）; 
 boolean accepted = false; 
 
 if（support.isDrop（））{
 if（support.isDataFlavorSupported（UserTransferable.USER_DATA_FLAVOR））{
 
 final JList.DropLocation dl = 
（JList.DropLocation）support.getDropLocation（）; 
 final StringListModel model =（StringListModel）this.list.getModel（）; 
 final int index = dl.getIndex（）; 
 final boolean insert = dl.isInsert（）; 
 
 final Transferable t = support.getTransferable（）; 
 try {
 final String dropped =（String）t 
 .getTransferData（UserTransferable.USER_DATA_FLAVOR）; 
 if（insert）{
 if（index> = model.getSize（））{
 model.addElement（dropped）; 
} else {
 model.addElementAt（dropped，index）; 
} 
} else {
 model.addElement（dropped）; 
} 
 
 accepted = true; 
} catch（final Exception e）{
 e.printStackTrace（）; 
} 
} 
} 
返回接受; 
} 
 
 @Override 
 public int getSourceActions（final JComponent c）{
 System.out.println（getSourceActions）; 
 return TransferHandler.COPY_OR_MOVE; 
} 
 
 @Override 
 protected可移植的createTransferable（final JComponent c）{
 System.out.println（createTransferable）; 
 final String value = this.list.getSelectedValue（）。toString（）; 
返回新的UserTransferable（value）; 
} 
 
} 
 
 private static class UserTransferable implements Transferable {
 
 private static final DataFlavor USER_DATA_FLAVOR = 
 new DataFlavor String.class，String）; 
 
 private final String value; 
 
 private UserTransferable（final String value）{
 System.out.println（UserTransferable）; 
 this.value = value; 
} 
 
 @Override 
 public DataFlavor [] getTransferDataFlavors（）{
 System.out.println（getTransferDataFlavors）; 
返回新的DataFlavor [] {UserTransferable.USER_DATA_FLAVOR}; 
} 
 
 @Override 
 public boolean isDataFlavorSupported（final DataFlavor flavor）{
 System.out.println（isDataFlavorSupported）; 
 return UserTransferable.USER_DATA_FLAVOR.equals（flavor）; 
} 
 
 @Override 
 public Object getTransferData（final DataFlavor flavor）throws 
 UnsupportedFlavorException，IOException {
 System.out.println（getTransferData） ; 
 if（！UserTransferable.USER_DATA_FLAVOR.equals（flavor））{
 throw new UnsupportedFlavorException（flavor）; 
} 
 return this.value; 
} 
 
} 
  

打印语句有调用方法时的反馈（即现在从来没有）。

解决方案

这是一个完全正常的例子，它使用（较新）可转让 API。这是基于您链接的示例。

注意，我没有使用 String 因为这只是混淆了人，而是转移对象。

另请注意，我正在使用moveAPI，因此名称将从一个列表到另一个...

  import java.awt。*; 
 import java.awt.event。*; 
 import java.awt.datatransfer。*; 
 import java.io.IOException; 
 import java.util.logging.Level; 
 import java.util.logging.Logger; 
 import javax.swing。*; 
 
 public class ComponentAPIDnD {
 
 public static void main（String [] args）{
 new ComponentAPIDnD（）; 
} 
 
 public ComponentAPIDnD（）{
 EventQueue.invokeLater（new Runnable（）{
 @Override 
 public void run（）{
尝试{
 UIManager.setLookAndFeel（UIManager.getSystemLookAndFeelClassName（））; 
} catch（ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex）{
} 
 
 JFrame框架= new JFrame（Testing）; 
 frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）; 
 frame.setLayout（new BorderLayout（））; 
 frame.add（new TestPane（））; 
 frame.pack（）; 
 frame.setLocationRelativeTo（null）; 
 frame.setVisible（true）; 
} 
}）; 
} 
 
 public class TestPane扩展JPanel {
 
 private JList left; 
 private JList right; 
 
 public TestPane（）{
 setLayout（new GridLayout（0，2））; 
 DefaultListModel< User> model = new DefaultListModel（）; 
 model.addElement（new User（Rai））; 
 model.addElement（new User（Mark））; 
 model.addElement（new User（Han））; 
 model.addElement（new User（Luke））; 
 model.addElement（new User（Ben））; 
 model.addElement（new User（Yoda））; 
 left = new JList（model）; 
 left.setCellRenderer（new UserListCellRenderer（））; 
 right = new JList（new DefaultListModel< User>（））; 
 right.setCellRenderer（new UserListCellRenderer（））; 
 
 left.setName（Left）; 
 right.setName（Right）; 
 
 add（new JScrollPane（left））; 
 add（new JScrollPane（right））; 
 
 left.setTransferHandler（new UserTransferHandler（left））; 
 right.setTransferHandler（new UserTransferHandler（right））; 
 
 left.setDropMode（DropMode.ON_OR_INSERT）; 
 right.setDropMode（DropMode.ON_OR_INSERT）; 
 
 left.setDragEnabled（true）; 
 right.setDragEnabled（true）; 
} 
 
 @Override 
 public Dimension getPreferredSize（）{
 return new Dimension（400，400）; 
} 
} 
 
 public static class UserTransferHandler extends TransferHandler {
 
 private JList list; 
 
 public UserTransferHandler（JList list）{
 this.list = list; 
} 
 
 @Override 
 public boolean canImport（TransferSupport support）{
 boolean canImport = false; 
 if（support.isDataFlavorSupported（UserTransferable.USER_DATA_FLAVOR））{
 JList.DropLocation dl =（JList.DropLocation）support.getDropLocation（）; 
 if（dl.getIndex（）！= -1）{
 canImport = true; 
} 
} 
 return canImport; 
} 
 
 @Override 
 protected void exportDone（JComponent source，Transferable data，int action）{
 try {
 User user =（User）data .getTransferData（UserTransferable.USER_DATA_FLAVOR）; 
（（DefaultListModel< User>）list.getModel（））。removeElement（user）; 
} catch（UnsupportedFlavorException | IOException ex）{
 ex.printStackTrace（）; 
} 
} 
 
 @Override 
 public boolean importData（TransferSupport support）{
 boolean accepted = false; 
 if（support.isDrop（））{
 if（support.isDataFlavorSupported（UserTransferable.USER_DATA_FLAVOR））{
 
 JList.DropLocation dl =（JList.DropLocation）support.getDropLocation （）; 
 DefaultListModel< User> model =（DefaultListModel< User>）list.getModel（）; 
 int index = dl.getIndex（）; 
 boolean insert = dl.isInsert（）; 
 
可转移t = support.getTransferable（）; 
 try {
 User dropped =（User）t.getTransferData（UserTransferable.USER_DATA_FLAVOR）; 
 System.out.println（Drop+ drop +on+ list.getName（））; 
 if（insert）{
 if（index> = model.getSize（））{
 model.addElement（dropped）; 
} else {
 model.add（index，dropped）; 
} 
} else {
 model.addElement（dropped）; 
} 
 
 accepted = true; 
} catch（Exception e）{
 e.printStackTrace（）; 
} 
} 
} 
返回接受; 
} 
 
 @Override 
 public int getSourceActions（JComponent c）{
 return COPY_OR_MOVE; 
} 
 
 @Override 
 protected可传输的createTransferable（JComponent c）{
用户用户=（用户）list.getSelectedValue（）; 
返回新的UserTransferable（user）; 
} 
 
} 
 
 public static class UserTransferable implements Transferable {
 
 public static final DataFlavor USER_DATA_FLAVOR = new DataFlavor（User.class， 用户）; 
 
私人用户用户; 
 
 public UserTransferable（用户用户）{
 this.user = user; 
} 
 
 @Override 
 public DataFlavor [] getTransferDataFlavors（）{
返回新的DataFlavor [] {USER_DATA_FLAVOR}; 
} 
 
 @Override 
 public boolean isDataFlavorSupported（DataFlavor flavor）{
 return USER_DATA_FLAVOR.equals（flavor）; 
} 
 
 @Override 
 public Object getTransferData（DataFlavor flavor）throws UnsupportedFlavorException，IOException {
 Object value = null; 
 if（USER_DATA_FLAVOR.equals（flavor））{
 value = user; 
} else {
 throw new UnsupportedFlavorException（flavor）; 
} 
 return user; 
} 
 
} 
 
 public class User {
 
 private String name; 
 
 public User（String name）{
 this.name = name; 
} 
 
 public String getName（）{
 return name; 
} 
} 
 
 public class UserListCellRenderer extends DefaultListCellRenderer {
 
 @Override 
 public Component getListCellRendererComponent（JList<？> list，Object value，int index，boolean isSelected，boolean cellHasFocus）{
 super.getListCellRendererComponent（list，value，index，isSelected，cellHasFocus）; 
 
 if（value instanceof User）{
 
 setText（（（User）value）.getName（））; 
 
} 
 
返回此; 
} 
} 
} 
  

I've got a couple of JList both being able to be sources and destinations of DnD COPY actions. They work fine, but for one thing - elements are added at the bottom of the lists, instead at the drop destination row, as I'd like.

Since Oracle BasicDnD example includes this feature (and, in fact, it's the only application I've been able to find through Google with it), I've been taking a look at its source to see if I was able to adapt it. I tried to set the TransferHandler object, which is what I guess I'm missing, but no new behavior appeared. So, what (else) may I be missing/doing wrong?

EDIT1: Below is shown the class I use for these lists.

private class InteractiveJList extends JList implements DragGestureListener, 
DragSourceListener, DropTargetListener {

private final DropTarget dropTarget;
private final DragSource dragSource;
private final boolean    removeElementsOnFail;
private int[]            selectedOnes;

@SuppressWarnings("unchecked")
private InteractiveJList(final ListModel model, 
final boolean _removElementsOnFail) {
    super(model);
    this.dragSource = new DragSource();
    this.dragSource
        .createDefaultDragGestureRecognizer(this, DnDConstants.ACTION_COPY,
this);
this.dropTarget = new DropTarget(this, this);
this.removeElementsOnFail = _removElementsOnFail;
}

@Override
public void dragEnter(final DropTargetDragEvent arg0) {
}

@Override
public void dragExit(final DropTargetEvent arg0) {
}

@Override
public void dragOver(final DropTargetDragEvent arg0) {
}

@Override
public void drop(final DropTargetDropEvent event) {
    if (!this.removeElementsOnFail) {
    event.rejectDrop();
    return;
    }
    final Transferable transferable = event.getTransferable();

    if (transferable.isDataFlavorSupported(DataFlavor.stringFlavor)) {
    String all;
    try {
        all = (String) transferable.getTransferData(DataFlavor.stringFlavor);
    } catch (final UnsupportedFlavorException | IOException ex) {
        event.rejectDrop();
        return;
    }
    event.acceptDrop(DnDConstants.ACTION_COPY);
    final StringTokenizer tokenizer = new StringTokenizer(all, "|");
    while (tokenizer.hasMoreTokens()) {
        ((StringListModel) this.getModel()).addElement(tokenizer.nextToken());
    }
    event.getDropTargetContext().dropComplete(Boolean.TRUE);
    } else {
    event.rejectDrop();
    }
}

@Override
public void dropActionChanged(final DropTargetDragEvent event) {
}

@Override
public void dragEnter(final DragSourceDragEvent arg0) {
}

@Override
public void dragExit(final DragSourceEvent arg0) {
}

@Override
public void dragOver(final DragSourceDragEvent arg0) {
}

@Override
public void dropActionChanged(final DragSourceDragEvent dragSourceEvent) {
}

@Override
public void dragGestureRecognized(final DragGestureEvent dragGestureEvent) {
    final Object listSelectedValue = this.getSelectedValue();
    this.selectedOnes = this.getSelectedIndices();
    final StringBuilder bridge = new StringBuilder();
    for (final int x : this.selectedOnes) {
    bridge.append(this.getModel().getElementAt(x)).append("|");
    }
    if (listSelectedValue != null) {
    final StringSelection stringTransferable =
new StringSelection(bridge.toString()
            .substring(0, bridge.length() - 1));
    this.dragSource.startDrag(dragGestureEvent, DragSource.DefaultCopyDrop,
            stringTransferable, this);
    }
}

@Override
public void dragDropEnd(final DragSourceDropEvent dragSourceDropEvent) {
    if (!dragSourceDropEvent.getDropSuccess()) {
    if (this.removeElementsOnFail) {
        for (final int x : this.selectedOnes) {
        ((StringListModel) this.getModel()).removeElement(x);
        }
    }
    }
}

}

The boolean flag in the constructor is used because, for one of the lists, if the drop action if rejected, the element must be removed, but not in the another. This way I can handle that. StringListModel is an extension of AbstractListModel to handle list of Strings. It is able to add elements both at bottom and at a requested position, clears the list, and remove certain elements. It does its stuff, fires the corresponding events and nothing further.

EDIT2: Below is shown my implementation of MadProgrammer's suggestion:

   private static class UserTransferHandler extends TransferHandler {

private final JList list;

private UserTransferHandler(final JList list) {
    this.list = list;
}

@Override
public boolean canImport(final TransferSupport support) {
    System.out.println("canImport");
    boolean canImport = false;
    if (support.isDataFlavorSupported(UserTransferable.USER_DATA_FLAVOR)) {
    final JList.DropLocation dl = 
(JList.DropLocation) support.getDropLocation();
    if (dl.getIndex() != -1) {
        canImport = true;
    }
    }
    return canImport;
}

@Override
protected void exportDone(final JComponent source, final Transferable data,
final int action) {
    System.out.println("exportDone");
}

@Override
public boolean importData(final TransferSupport support) {
    System.out.println("importData");
    boolean accepted = false;

    if (support.isDrop()) {
    if (support.isDataFlavorSupported(UserTransferable.USER_DATA_FLAVOR)) {

        final JList.DropLocation dl = 
(JList.DropLocation) support.getDropLocation();
        final StringListModel model = (StringListModel) this.list.getModel();
        final int index = dl.getIndex();
        final boolean insert = dl.isInsert();

        final Transferable t = support.getTransferable();
        try {
        final String dropped = (String) t
                .getTransferData(UserTransferable.USER_DATA_FLAVOR);
        if (insert) {
            if (index >= model.getSize()) {
            model.addElement(dropped);
            } else {
            model.addElementAt(dropped, index);
            }
        } else {
            model.addElement(dropped);
        }

        accepted = true;
        } catch (final Exception e) {
        e.printStackTrace();
        }
    }
    }
    return accepted;
}

@Override
public int getSourceActions(final JComponent c) {
    System.out.println("getSourceActions");
    return TransferHandler.COPY_OR_MOVE;
}

@Override
protected Transferable createTransferable(final JComponent c) {
    System.out.println("createTransferable");
    final String value = this.list.getSelectedValue().toString();
    return new UserTransferable(value);
}

}

private static class UserTransferable implements Transferable {

private static final DataFlavor USER_DATA_FLAVOR = 
new DataFlavor(String.class, "String");

private final String            value;

private UserTransferable(final String value) {
    System.out.println("UserTransferable");
    this.value = value;
}

@Override
public DataFlavor[] getTransferDataFlavors() {
    System.out.println("getTransferDataFlavors");
    return new DataFlavor[] { UserTransferable.USER_DATA_FLAVOR };
}

@Override
public boolean isDataFlavorSupported(final DataFlavor flavor) {
    System.out.println("isDataFlavorSupported");
    return UserTransferable.USER_DATA_FLAVOR.equals(flavor);
}

@Override
public Object getTransferData(final DataFlavor flavor) throws 
UnsupportedFlavorException, IOException {
    System.out.println("getTransferData");
    if (!UserTransferable.USER_DATA_FLAVOR.equals(flavor)) {
    throw new UnsupportedFlavorException(flavor);
    }
    return this.value;
}

}

The print statements are there to get feedback when the methods are called (which is, right now, never).

解决方案

This is a fully working example that uses the (newer) Transferable API. This is based on the example you have linked.

Note, I've not bothered with using Strings, as this just confuses people, instead, I'm transferring objects.

Also note, that I'm using a "move" API, so names will be moved from one list to the other...

import java.awt.*;
import java.awt.event.*;
import java.awt.datatransfer.*;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.*;

public class ComponentAPIDnD {

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

    public ComponentAPIDnD() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new BorderLayout());
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        private JList left;
        private JList right;

        public TestPane() {
            setLayout(new GridLayout(0, 2));
            DefaultListModel<User> model = new DefaultListModel<>();
            model.addElement(new User("Rai"));
            model.addElement(new User("Mark"));
            model.addElement(new User("Han"));
            model.addElement(new User("Luke"));
            model.addElement(new User("Ben"));
            model.addElement(new User("Yoda"));
            left = new JList(model);
            left.setCellRenderer(new UserListCellRenderer());
            right = new JList(new DefaultListModel<User>());
            right.setCellRenderer(new UserListCellRenderer());

            left.setName("Left");
            right.setName("Right");

            add(new JScrollPane(left));
            add(new JScrollPane(right));

            left.setTransferHandler(new UserTransferHandler(left));
            right.setTransferHandler(new UserTransferHandler(right));

            left.setDropMode(DropMode.ON_OR_INSERT);
            right.setDropMode(DropMode.ON_OR_INSERT);

            left.setDragEnabled(true);
            right.setDragEnabled(true);
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(400, 400);
        }
    }

    public static class UserTransferHandler extends TransferHandler {

        private JList list;

        public UserTransferHandler(JList list) {
            this.list = list;
        }

        @Override
        public boolean canImport(TransferSupport support) {
            boolean canImport = false;
            if (support.isDataFlavorSupported(UserTransferable.USER_DATA_FLAVOR)) {
                JList.DropLocation dl = (JList.DropLocation) support.getDropLocation();
                if (dl.getIndex() != -1) {
                    canImport = true;
                }
            }
            return canImport;
        }

        @Override
        protected void exportDone(JComponent source, Transferable data, int action) {
            try {
                User user = (User) data.getTransferData(UserTransferable.USER_DATA_FLAVOR);
                ((DefaultListModel<User>)list.getModel()).removeElement(user);
            } catch (UnsupportedFlavorException | IOException ex) {
                ex.printStackTrace();
            }
        }

        @Override
        public boolean importData(TransferSupport support) {
            boolean accepted = false;
            if (support.isDrop()) {
                if (support.isDataFlavorSupported(UserTransferable.USER_DATA_FLAVOR)) {

                    JList.DropLocation dl = (JList.DropLocation)support.getDropLocation();
                    DefaultListModel<User> model = (DefaultListModel<User>) list.getModel();
                    int index = dl.getIndex();
                    boolean insert = dl.isInsert();

                    Transferable t = support.getTransferable();
                    try {
                        User dropped = (User) t.getTransferData(UserTransferable.USER_DATA_FLAVOR);
                        System.out.println("Drop " + dropped + " on " + list.getName());
                        if (insert) {
                            if (index >= model.getSize()) {
                                model.addElement(dropped);
                            } else {
                                model.add(index, dropped);
                            }
                        } else {
                            model.addElement(dropped);
                        }

                        accepted = true;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
            return accepted;
        }

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

        @Override
        protected Transferable createTransferable(JComponent c) {
            User user = (User) list.getSelectedValue();
            return new UserTransferable(user);
        }

    }

    public static class UserTransferable implements Transferable {

        public static final DataFlavor USER_DATA_FLAVOR = new DataFlavor(User.class, "User");

        private User user;

        public UserTransferable(User user) {
            this.user = user;
        }

        @Override
        public DataFlavor[] getTransferDataFlavors() {
            return new DataFlavor[] {USER_DATA_FLAVOR};
        }

        @Override
        public boolean isDataFlavorSupported(DataFlavor flavor) {
            return USER_DATA_FLAVOR.equals(flavor);
        }

        @Override
        public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
            Object value = null;
            if (USER_DATA_FLAVOR.equals(flavor)) {
                value = user;
            } else {
                throw new UnsupportedFlavorException(flavor);
            }
            return user;
        }

    }

    public class User {

        private String name;

        public User(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }

    public class UserListCellRenderer extends DefaultListCellRenderer {

        @Override
        public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
            super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

            if (value instanceof User) {

                setText(((User) value).getName());

            }

            return this;
        }
    }
}

这篇关于将字符串添加到JList，确切地删除它们，而不是在底部的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！