0

赤、青、黄、緑のアイテムのリストを表示するJcomboboxがあります。文字列xが300文字を超える場合はjcomboxに赤と青のみを表示し、文字列xがそれ以上の場合は黄色と緑のみを表示します500文字以上。Javaでそれを行うにはどうすればよいですか。ありがとう

4

2 に答える 2

1

x が 300 を超え 500 未満の場合は、jcombobox に赤と青のアイテムを入力し、それ以外の場合は 500 を超えてから、緑と黄色のアイテムを入力します。 http://www.exampledepot.com/egs/javax.swing/combobox_CbAddItems.html Java で jcombo ボックスに追加および削除する簡単な例を次に示します。この助けを願っています。

于 2012-10-14T19:44:49.807 に答える
0

結果をリアルタイムでフィルタリングできるプロキシ コンボ ボックス モデルを使用できます。プロキシ モデルは既存のモデルを使用して結果をフィルタリングし、コンボ ボックスにはフィルタリングされた結果のみが表示されるようにします...

ListModelこれは、この目的で使用するの実装です...

public class FilteredListModel extends AbstractListModel implements ListDataListener {

    private ListModel peer;
    private List<Integer> lstFilteredIndicies;
    private IFilterable filter;

    public FilteredListModel() {
        lstFilteredIndicies = new ArrayList<Integer>(25);
    }

    public FilteredListModel(ListModel model) {
        this();
        setModel(model);
    }

    public FilteredListModel(ListModel model, IFilterable filter) {
        this();

        setModel(model);
        setFilter(filter);
    }

    public void setModel(ListModel parent) {
        if (peer == null || !peer.equals(parent)) {
            if (peer != null) {
                fireIntervalRemoved(this, 0, peer.getSize() - 1);
                peer.removeListDataListener(this);
            }
            peer = parent;
            lstFilteredIndicies.clear();
            if (peer != null) {
                peer.addListDataListener(this);
            }
            filterModel();
        }
    }

    public ListModel getModel() {
        return peer;
    }

    public int getSize() {
        IFilterable filter = getFilter();
        return filter == null ? getModel() == null ? 0 : getModel().getSize() : lstFilteredIndicies.size();
    }

    public Object getElementAt(int index) {
        IFilterable filter = getFilter();
        ListModel model = getModel();
        return filter == null ? model == null ? null : model.getElementAt(index) : model.getElementAt(lstFilteredIndicies.get(index));
    }

    public int indexOf(Object value) {
        int index = -1;
        for (int loop = 0; loop < getSize(); loop++) {
            Object at = getElementAt(loop);
            if (at == value) {
                index = loop;
                break;
            }
        }
        return index;
    }

    public void intervalAdded(ListDataEvent e) {
        IFilterable filter = getFilter();
        ListModel model = getModel();

        if (model != null) {
            if (filter != null) {
                int startIndex = Math.min(e.getIndex0(), e.getIndex1());
                int endIndex = Math.max(e.getIndex0(), e.getIndex1());
                for (int index = startIndex; index <= endIndex; index++) {
                    Object value = model.getElementAt(index);
                    if (filter.include(value)) {
                        lstFilteredIndicies.add(index);
                        int modelIndex = lstFilteredIndicies.indexOf(index);
                        fireIntervalAdded(this, modelIndex, modelIndex);
                    }
                }
            } else {
                fireIntervalAdded(this, e.getIndex0(), e.getIndex1());
            }
        }
    }

    public void intervalRemoved(ListDataEvent e) {
        IFilterable filter = getFilter();
        ListModel model = getModel();

        if (model != null) {
            if (filter != null) {
                int startIndex = Math.min(e.getIndex0(), e.getIndex1());
                int endIndex = Math.max(e.getIndex0(), e.getIndex1());
                for (int index = startIndex; index <= endIndex; index++) {
                    if (lstFilteredIndicies.contains(index)) {
                        int filterIndex = lstFilteredIndicies.indexOf(index);
                        lstFilteredIndicies.remove(filterIndex);
                        fireIntervalRemoved(this, filterIndex, filterIndex);
                    }
                }
            } else {
                fireIntervalRemoved(this, e.getIndex0(), e.getIndex1());
            }
        }
    }

    public void contentsChanged(ListDataEvent e) {
        filterModel();
    }

    public void setFilter(IFilterable value) {
        if (filter == null || !filter.equals(value)) {
            filter = value;
            if (getModel() != null) {
                fireIntervalRemoved(this, 0, getModel().getSize() - 1);
            }
            filterModel();
        }
    }

    public IFilterable getFilter() {
        return filter;
    }

    protected void filterModel() {
        if (getSize() > 0) {
            fireIntervalRemoved(this, 0, getSize() - 1);
        }
        lstFilteredIndicies.clear();

        IFilterable filter = getFilter();
        ListModel model = getModel();
        if (filter != null && model != null) {
            for (int index = 0; index < model.getSize(); index++) {
                Object value = model.getElementAt(index);
                if (filter.include(value)) {
                    lstFilteredIndicies.add(index);
                    fireIntervalAdded(this, getSize() - 1, getSize() - 1);
                }
            }
        }
    }

    public void updateFilter() {

        IFilterable filter = getFilter();
        ListModel model = getModel();

        if (filter != null && model != null) {
            for (int index = 0; index < model.getSize(); index++) {
                Object value = model.getElementAt(index);
                if (filter.include(value)) {
                    if (!lstFilteredIndicies.contains(index)) {
                        lstFilteredIndicies.add(index);
                        fireIntervalAdded(this, getSize() - 1, getSize() - 1);
                    }
                } else if (lstFilteredIndicies.contains(index)) {
                    int oldIndex = lstFilteredIndicies.indexOf(index);
                    lstFilteredIndicies.remove(oldIndex);
                    fireIntervalRemoved(this, oldIndex, oldIndex);
                }
            }
        }
    }
}

フィルタリング可能なインターフェース

public interface IFilterable<O> {
    public boolean include(O value);    
}

そしてComboBoxModel実装…

public class FilterableComboBoxModel extends FilteredListModel implements ComboBoxModel {

    private FilterableComboBoxModel(ComboBoxModel model) {
        super(model);
    }

    public ComboBoxModel getComboBoxModel() {
        return (ComboBoxModel) getModel();
    }

    public void setSelectedItem(Object anItem) {
        getComboBoxModel().setSelectedItem(anItem);
    }

    public Object getSelectedItem() {
        return getComboBoxModel().getSelectedItem();
    }

}

基本的に、必要なのは、フィルター処理されたモデルでモデルをラップすることだけです...

ComboBoxModel originalModel = ...;
FilterableComboBoxModel filteredModel = new FilterableComboBoxModel(origialModel);
comboBox.setModel(filteredModel(originalModel));

そこから、IFilterable必要なロジックを備えた のインターフェースの実装を提供し、それをfilteredModelに提供するだけです。

モデルを再フィルタリングする必要がある状況が発生した場合は、単純に呼び出すことができますFilterableComboBoxModel#updateFilter

于 2012-10-14T22:40:50.110 に答える