Java 使用多个JComboxes和一个公共数据源

我希望能够使用多个JComboxes和一个公共数据源。我希望组合框能够显示该列表中的项目或空白项目，最重要的是，如果某个项目当前被另一个组合框选中，我希望组合框不显示该项目（但如果该项目未选中，则显示该项目）

我一直试图通过调用removeDuplicates（）方法来实现这一点，该方法应将当前选定的所有项目添加到列表中，从主列表中删除该项目，然后将其设置为组合框的列表

这给了我一些有趣的问题。在我的程序中，主列表中的任何选项都不会显示，即使是在最初，但如果我去掉代码以删除重复项（初始化测试正常），它们也会显示

此外，即使它们是可编辑的组合框，我也无法将所选项目写入其中，但只要按enter按钮，它就会被删除

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Arrays;
import javax.swing.BoxLayout;
import javax.swing.JComboBox;
import javax.swing.JFrame;

@SuppressWarnings("serial")
public class Main extends JFrame implements ActionListener
{
    ArrayList<String> commonItemList = new ArrayList<String>(Arrays.asList("Dog", "Cat", "Fish", "Bear", "Lion"));
    ArrayList<JComboBox<Object>> comboBoxes = new ArrayList<>();

    public Main()
    {
        this.setSize(new Dimension(500, 150));
        this.setLayout(new BoxLayout(getContentPane(), BoxLayout.Y_AXIS));

        JComboBox<Object> comboBox1 = new JComboBox<Object>(commonItemList.toArray());
        comboBox1.setEditable(true);
        comboBox1.addActionListener(this);

        JComboBox<Object> comboBox2 = new JComboBox<Object>(commonItemList.toArray());
        comboBox2.setEditable(true);
        comboBox2.addActionListener(this);

        JComboBox<Object> comboBox3 = new JComboBox<Object>(commonItemList.toArray());
        comboBox3.setEditable(true);
        comboBox3.addActionListener(this);

        this.add(comboBox1);
        comboBoxes.add(comboBox1);
        this.add(comboBox2);
        comboBoxes.add(comboBox2);
        this.add(comboBox3);
        comboBoxes.add(comboBox3);
    }

    public static void main(String[] args)
    {
        Main main = new Main();
        main.setVisible(true);
    }

    @Override
    public void actionPerformed(ActionEvent arg0)
    {
        removeDuplicates();
    }

    private void removeDuplicates()
    {
        ArrayList<String> currentlyUsedItems = new ArrayList<>();
        ArrayList<String> availableItems = commonItemList;

        // Add all currently selected items to usedItems list
        for (JComboBox<Object> comboBox : comboBoxes)
        {
            currentlyUsedItems.add((String) comboBox.getSelectedItem());
        }

        // For every string in currentlyUsedItems remove it from availableItems
        for (String string : currentlyUsedItems)
        {
            availableItems.remove(string);
        }

        // Remove all items from combobox, then add back all available Items, while disabling actionListener
        for (JComboBox<Object> comboBox : comboBoxes)
        {
            comboBox.removeActionListener(this);

            comboBox.removeAllItems();

            for (String string : availableItems)
            {
                comboBox.addItem(string);
            }

            comboBox.addActionListener(this);
        }
    }
}

导入java.awt.Dimension；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.util.ArrayList；
导入java.util.array；
导入javax.swing.BoxLayout；
导入javax.swing.JComboBox；
导入javax.swing.JFrame；
@抑制警告（“串行”）
公共类Main扩展JFrame实现ActionListener
{
ArrayList commonItemList=新的ArrayList（Arrays.asList（“狗”、“猫”、“鱼”、“熊”、“狮子”））；
ArrayList组合框=新建ArrayList（）；
公用干管（）
{
此设置尺寸（新尺寸（500150））；
this.setLayout（新的BoxLayout（getContentPane（），BoxLayout.Y_轴））；
JComboBox comboBox1=新的JComboBox（commonItemList.toArray（））；
comboBox1.setEditable（真）；
comboBox1.addActionListener（此）；
JComboBox comboBox2=新的JComboBox（commonItemList.toArray（））；
comboBox2.setEditable（真）；
comboBox2.addActionListener（此）；
JComboBox comboBox3=新的JComboBox（commonItemList.toArray（））；
comboBox3.setEditable（真）；
comboBox3.addActionListener（此）；
添加（comboBox1）；
combobox.add（comboBox1）；
添加（comboBox2）；
combobox.add（comboBox2）；
添加（comboBox3）；
combobox.add（comboBox3）；
}
公共静态void main（字符串[]args）
{
Main Main=新Main（）；
main.setVisible（true）；
}
@凌驾
已执行的公共无效操作（操作事件arg0）
{
移除重复项（）；
}
私有无效删除副本（）
{
ArrayList currentlyUsedItems=新的ArrayList（）；
ArrayList availableItems=commonItemList；
//将当前选定的所有项目添加到usedItems列表
for（JComboBox组合框：组合框）
{
currentlyUsedItems.add（（字符串）comboBox.getSelectedItem（））；
}
//对于currentlyUsedItems中的每个字符串，将其从availableItems中删除
for（字符串：currentlyUsedItems）
{
可用项。删除（字符串）；
}
//从组合框中删除所有项目，然后添加回所有可用项目，同时禁用actionListener
for（JComboBox组合框：组合框）
{
comboBox.removeActionListener（此）；
comboBox.removeAllItems（）；
for（字符串：availableItems）
{
comboBox.addItem（字符串）；
}
comboBox.addActionListener（这个）；
}
}
}

---

上面我发布了一个SSCCE，它没有和我的问题完全相同的问题，但不管怎样它仍然存在错误，并且使用了我用来解决问题的相同方法。是否有我遗漏的东西，或者这只是一种糟糕的解决方案？

如图所示，操作模型而不是视图。在这种情况下，完全不同的模型可以共享对了解模型的公共数据源的访问。

一种方法是简单地“禁用”组合下拉列表中的项目（即，使其不可选择），如果它们已经在另一个组合框中被选中

以下是禁用

JComboBox

中的项目的一种方法（使用金属）：

import java.awt.*；
导入java.awt.event.*；
导入javax.swing.*；
导入javax.swing.plaf.basic.*；
导入javax.swing.plaf.metal.*；
公共类JComboxDisabledItemsDemo实现ItemListener，Runnable
{
私有静态最终字符串项[]=
{“黑色”、“蓝色”、“绿色”、“橙色”、“紫色”、“红色”、“白色”、“黄色”}；
私人JCOMBOX jCombo；
私有JCheckBox[]复选框=新的JCheckBox[ITEMS.length]；
私有布尔值[]enabledFlags=新布尔值[ITEMS.length]；
公共静态void main（字符串参数[]）
{
invokeLater（新的jcomboxDisabledItemsDemo（））；
}
@抑制警告（“未选中”）
公开募捐
{
JPanel pnlEnablers=新的JPanel（新的网格布局（0,1））；
pnlEnablers.setboorder（BorderFactory.createTitledBorder（“已启用项”）；
对于（int i=0；iimport java.awt.*;
import java.awt.event.*;

import javax.swing.*;
import javax.swing.plaf.basic.*;
import javax.swing.plaf.metal.*;

public class JComboBoxDisabledItemsDemo implements ItemListener, Runnable
{
  private static final String ITEMS[] =
    { "Black", "Blue", "Green", "Orange", "Purple", "Red", "White", "Yellow"};

  private JComboBox jCombo;
  private JCheckBox[] checkBoxes = new JCheckBox[ITEMS.length];
  private boolean[] enabledFlags = new boolean[ITEMS.length];

  public static void main(String args[])
  {
    SwingUtilities.invokeLater(new JComboBoxDisabledItemsDemo()); 
  }

  @SuppressWarnings("unchecked")
  public void run()
  {
    JPanel pnlEnablers = new JPanel(new GridLayout(0,1));
    pnlEnablers.setBorder(BorderFactory.createTitledBorder("Enabled Items"));

    for (int i = 0; i < ITEMS.length; i++)
    {
      checkBoxes[i] = new JCheckBox(ITEMS[i]);
      checkBoxes[i].setSelected(true);
      checkBoxes[i].addItemListener(this);
      enabledFlags[i] = true;
      pnlEnablers.add(checkBoxes[i]);
    }

    jCombo = new JComboBox(ITEMS);

    jCombo.setUI(new MetalComboBoxUI()
    {
      @Override
      protected ComboPopup createPopup()
      {
        ComboPopup cp = new BasicComboPopup( comboBox )
        {
          @Override
          protected void configureList()
          {
            super.configureList();
            list.setSelectionModel(new DisabledItemSelectionModel());
          }
        };
        return cp;
      }
    });
    jCombo.setRenderer(new DisabledItemListCellRenderer());

    JFrame f = new JFrame("Colors");
    Container contentPane = f.getContentPane();
    contentPane.setLayout(new BorderLayout());
    contentPane.add(pnlEnablers, BorderLayout.CENTER);
    contentPane.add(jCombo, BorderLayout.SOUTH);

    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    f.setSize(240, 280);
    f.setLocationRelativeTo(null);
    f.setVisible(true);
  }

  public void itemStateChanged(ItemEvent event)
  {
    JCheckBox checkBox = (JCheckBox) event.getSource();
    int index = -1;
    int selectedComboIndex = jCombo.getSelectedIndex();

    for (int i = 0; i < ITEMS.length; i++)
    {
      if (ITEMS[i].equals(checkBox.getText()))
      {
        index = i;
        break;
      }
    }

    if (index != -1)
    {
      enabledFlags[index] = checkBox.isSelected();
      jCombo.repaint();

      if (index == selectedComboIndex)
      {
        jCombo.setSelectedIndex(-1);
      }
    }
  }

  public class DisabledItemListCellRenderer extends DefaultListCellRenderer
  {
    @Override
    public Component getListCellRendererComponent(JList list, Object value,
                           int index, boolean isSelected, boolean cellHasFocus)
    {
      if (index < 0 || enabledFlags[index])
      {
        return super.getListCellRendererComponent(list, value, index,
                                                  isSelected, cellHasFocus);
      }

      Component comp = super.getListCellRendererComponent(list, value, index,
                                                          false, false);
      comp.setEnabled(false);
      return comp;
    }
  }

  public class DisabledItemSelectionModel extends DefaultListSelectionModel
  {
    /**
     * No need to override addSelectionInterval(int index0, int index1)
     * since we're using SINGLE_SELECTION mode for this demo.
     */

    @Override
    public void setSelectionInterval(int index0, int index1)
    {
      if (enabledFlags[index0])
      {
        super.setSelectionInterval(index0, index0);
      }
      else
      {
        /*
         * The previously selected index is before this one,
         * so walk forward to find the next selectable item.
         */
        if (getAnchorSelectionIndex() < index0)
        {
          for (int i = index0; i < enabledFlags.length; i++)
          {
            if (enabledFlags[i])
            {
              super.setSelectionInterval(i, i);
              return;
            }
          }
        }
        /*
         * Otherwise, walk backward to find the next selectable item.
         */
        else
        {
          for (int i = index0; i >= 0; i--)
          {
            if (enabledFlags[i])
            {
              super.setSelectionInterval(i, i);
              return;
            }
          }
        }
      }
    }
  }
}