Java ILazyContentProvider在每个查看器上更新所有内容。setItemCount（）

亲爱的斯塔克沃夫人，你们好

几个月前，我正在处理一个

ILazyTreeContentProvider

，最后根据

但我面临着与a完全相同的问题，尽管我采取了与树类似的步骤，但我还是不知所措。 在这个表中，我每秒在表中添加大约1000个元素，并每隔100毫秒通过查看器上的

setItemCount（）

触发一次刷新

窗口大小小于100行，因此每次在查看器上调用

setItemCount（）

时，updateElement（）方法不应从第一个索引开始

但不幸的是，确实如此。它每次都从0更新到最后一个索引

代码如下：

package manyelementscontentprovider;

import java.util.List;
import java.util.Vector;
import org.eclipse.jface.viewers.ILazyContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class LargeDataSetTable {
    private class MyContentProvider implements ILazyContentProvider {
        private TableViewer viewer;
        public List<MyEntity> elements;
        private int lastIndex=0;
        public MyContentProvider(TableViewer viewer) {
            this.viewer = viewer;
        }

        public void dispose() {

        }

        @SuppressWarnings("unchecked")
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
            this.elements = (List<MyEntity>) newInput;
        }
        @Override
        public void updateElement(int index) {
            System.out.println(index);
            if (!viewer.isBusy())
                viewer.replace(elements.get(index), index);
        }

    }

    public static class MyEntity {
        public int counter;
        public MyEntity(int counter) {
            this.counter = counter;
        }

        public String toString() {
            return "Item " + this.counter;
        }
    }

    List<MyEntity> model;

    private int counter;
    private Display display;
    private TableViewer v;
    public LargeDataSetTable(Shell shell, Display display) {
        model = createModel();
        this.display=display;
        v= new TableViewer(shell, SWT.VIRTUAL);
        v.setLabelProvider(new LabelProvider());
        v.setContentProvider(new MyContentProvider(v));
        v.setInput(null);
        v.setUseHashlookup(true);
        counter = 0;

        v.setInput(model);
        v.setItemCount(model.size());

        v.getTable().setLinesVisible(true);
    }
    private void startSomeShit() {
        final Runnable gooeiUpdate = new Runnable() {

            @Override
            public void run() {
                long timeA = System.currentTimeMillis();
                v.setItemCount(counter);                            
                v.setSelection( new StructuredSelection( model.get(counter-1) ), true );
                v.setSelection(null);
                long timeB = System.currentTimeMillis();
                System.out.println("Paint lasted:"+(timeB-timeA));
            }

        };

        Runnable addThingsToModel = new Runnable() {

            public void run() {
                long currentTime=System.currentTimeMillis();
                long howManyGotIn =0;
                while (counter<4000000) {
                    for (int i = 0; i< 10; i++){
                        final MyEntity m = new MyEntity(counter);
                        model.add(m);
                        counter++;
                    }

                    if (System.currentTimeMillis()-currentTime>100) {
                        howManyGotIn=counter - howManyGotIn;
                        display.syncExec(gooeiUpdate);
                        currentTime=System.currentTimeMillis();
                        System.out.println("How many got in = "+howManyGotIn);
                        howManyGotIn=counter;
                    }

                    try {
                        Thread.sleep(0,25);
                    } catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        Thread th = new Thread(addThingsToModel);
        th.start();
    }
    private List<MyEntity> createModel() {
        List<MyEntity> list = new Vector<MyEntity>(4000000);
        return list;
    }
    public static void main(String[] args) {
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setLayout(new FillLayout());
        LargeDataSetTable viewerCica = new LargeDataSetTable(shell,display);
        shell.open();
        viewerCica.startSomeShit();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch())
                display.sleep();
        }
        display.dispose();
    }
}

PackageManyelementContentProvider；
导入java.util.List；
导入java.util.Vector；
导入org.eclipse.jface.viewers.ILazyContentProvider；
导入org.eclipse.jface.viewers.LabelProvider；
导入org.eclipse.jface.viewers.StructuredSelection；
导入org.eclipse.jface.viewers.TableViewer；
导入org.eclipse.jface.viewers.Viewer；
导入org.eclipse.swt.swt；
导入org.eclipse.swt.layout.FillLayout；
导入org.eclipse.swt.widgets.Display；
导入org.eclipse.swt.widgets.Shell；
公共类LargeDataSetTable{
私有类MyContentProvider实现ILazyContentProvider{
私人桌面查看器；
公共清单要素；
private int lastIndex=0；
公共MyContentProvider（TableViewer）{
this.viewer=查看器；
}
公共空间处置（）{
}
@抑制警告（“未选中”）
public void inputChanged（查看器、对象oldInput、对象newInput）{
this.elements=（List）newInput；
}
@凌驾
公共void updateElement（int索引）{
系统输出打印项次（索引）；
如果（！viewer.isBusy（））
viewer.replace（elements.get（index），index）；
}
}
公共静态类MyEntity{
公共int计数器；
公共MyEntity（内部计数器）{
this.counter=计数器；
}
公共字符串toString（）{
返回“项目”+此计数器；
}
}
列表模型；
专用int计数器；
私人显示器；
私人桌面查看器v；
公共大型数据设置（外壳、显示器）{
model=createModel（）；
this.display=display；
v=新的TableViewer（shell，SWT.VIRTUAL）；
v、 setLabelProvider（新的LabelProvider（））；
v、 setContentProvider（新的MyContentProvider（v））；
v、 设置输入（空）；
v、 setUseHashlookup（true）；
计数器=0；
v、 设置输入（模型）；
v、 setItemCount（model.size（））；
v、 getTable（）.setLinesVisible（true）；
}
私有void startSomeShit（）{
final Runnable gooeiUpdate=新的Runnable（）{
@凌驾
公开募捐{
long-timeA=System.currentTimeMillis（）；
v、 setItemCount（计数器）；
v、 setSelection（新结构选择（model.get（counter-1）），true）；
v、 设置选择（空）；
long-timeB=System.currentTimeMillis（）；
System.out.println（“绘制持续：+（timeB timeA））；
}
};
Runnable addThingsToModel=new Runnable（）{
公开募捐{
长currentTime=System.currentTimeMillis（）；
long howManyGotIn=0；
while（计数器100）{
howManyGotIn=计数器-howManyGotIn；
display.syncExec（GooeUpdate）；
currentTime=System.currentTimeMillis（）；
System.out.println（“多少人进来了？”+howManyGotIn）；
howManyGotIn=计数器；
}
试一试{
睡眠（0,25）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
}
};
Thread th=新线程（addThingsToModel）；
th.start（）；
}
私有列表createModel（）{
列表=新向量（4000000）；
退货清单；
}
公共静态void main（字符串[]args）{
显示=新显示（）；
外壳=新外壳（显示）；
setLayout（新的FillLayout（））；
LARGEDASETTABLE viewerCica=新的LARGEDASETTABLE（外壳，显示器）；
shell.open（）；
viewerica.startSomeShit（）；
而（！shell.isDisposed（））{
如果（！display.readAndDispatch（））
display.sleep（）；
}
display.dispose（）；
}
}

---

我们非常感谢您的任何建议、意见和选择。你们太棒了

这里是来自

AbstractTableViewer#VirtualSetSelectToWidget（列表列表，布尔显示）

的一些代码片段，当您使用

v.setSelection（new StructuredSelection（model.get（counter-1）），true时调用它：

if（getContentProvider（）实例ILazyContentProvider）{
ILazyContentProvider=（ILazyContentProvider）getContentProvider（）；
//现在再检查一遍，直到一切都结束，否则我们就再也不会这样了
//虚拟的
//这可能会创建所有项目，因此这不是一个好方法
//总的来说，这是一个好主意。
//改用#setSelection（int[]索引，布尔显示）
对于（int i=0；virtualElements.size（）>0&&iif (getContentProvider() instanceof ILazyContentProvider) {
            ILazyContentProvider provider = (ILazyContentProvider) getContentProvider();

            // Now go through it again until all is done or we are no longer
            // virtual
            // This may create all items so it is not a good
            // idea in general.
            // Use #setSelection (int [] indices,boolean reveal) instead
            for (int i = 0; virtualElements.size() > 0 && i < doGetItemCount(); i++) {
                provider.updateElement(i);
                Item item = doGetItem(i);
                if (virtualElements.contains(item.getData())) {
                    indices[count++] = i;
                    virtualElements.remove(item.getData());
                    if (firstItem == null) {
                        firstItem = item;
                    }
                }
            }
        }

TableViewer.setSelection(ISelection selection, boolean reveal)

v.getTable().setSelection(counter - 1);
v.getTable().showSelection();