选项1:创建一个实现Comparable的列表,并在每次添加值时使用collections.sort(List l)对其进行排序.选项2:创建一个TreeSet(它始终保持自己的排序).

哪一个会更快？我问这个是因为List给了我ListIterator的选项,在我的情况下我需要它,因为它允许我在迭代时添加一个元素.

我正在阅读之间的不同之处ArrayList并LinkedList指出何时使用LinkedList而不是ArrayList？.我开发了一个小的示例applcation来测试一个主要的优点LinkedList但是我获得的结果没有证实,这LinkedList超过ArrayList了操作的性能:

ListIterator.add(E element)

这是我的代码:

public static void main(String[] args) {

        int number = 100000;

        long startTime1 = System.currentTimeMillis();
        fillLinkedList(number);
        long stopTime1 = System.currentTimeMillis();

        long startTime2 = System.currentTimeMillis();
        fillArrayList(number);
        long stopTime2 = System.currentTimeMillis();

        System.out.println(" LinkedList needed: "+ (stopTime1 - startTime1));
        System.out.println(" ArrayList needed: "+ (stopTime2 - startTime2));

    }


    public static void fillLinkedList(int number){

        LinkedList<Integer> list = new LinkedList<Integer>();
        ListIterator<Integer> it = list.listIterator();
        int i = 0;
        while(i++<number){
            it.add(i);
        } …

我试图for in用来迭代一个TObjectList:

program Project1;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils, Contnrs;

var
    list: TObjectlist;
    o: TObject;
begin
    list := TObjectList.Create;
    for o in list do
    begin
        //nothing
    end;
end.

它无法编译:

[dcc32错误] Project1.dpr(15):E2010不兼容的类型:'TObject'和'Pointer'

似乎Delphi的for in构造不能处理无类型的,未显示的,TObjectList一个可枚举的目标.

我如何枚举一个对象TObjectList？

我现在应该做什么

我目前的代码是:

procedure TfrmCustomerLocator.OnBatchDataAvailable(BatchList: TObjectList);
var
   i: Integer;
   o: TObject;
begin
   for i := 0 to BatchList.Count-1 do
   begin
      o := BatchList.Items[i];

      //...snip...where we do something with (o as TCustomer)
   end;
end;    

没有充分的理由,我希望将其改为:

procedure TfrmCustomerLocator.OnBatchDataAvailable(BatchList: …

我有一个包含大约200K元素的列表.

我能够将此列表的迭代器传递给多个线程并让它们遍历整个批次,而没有任何访问相同的元素吗？

这就是我现在想到的.

主要:

public static void main(String[] args)
{
    // Imagine this list has the 200,000 elements.
    ArrayList<Integer> list = new ArrayList<Integer>();

    // Get the iterator for the list.
    Iterator<Integer> i = list.iterator();

    // Create MyThread, passing in the iterator for the list.
    MyThread threadOne = new MyThread(i);
    MyThread threadTwo = new MyThread(i);
    MyThread threadThree = new MyThread(i);

    // Start the threads.
    threadOne.start();
    threadTwo.start();
    threadThree.start();
}

MyThread的:

public class MyThread extends Thread
{

    Iterator<Integer> i;

    public MyThread(Iterator<Integer> i)
    { …

LinkedList在迭代中添加项目是否安全？

class Worker {

    final LinkedList<Foo> worklist = new LinkedList<>();

    public void work() {

        Iterator<Foo> iterator = worklist.iterator();

        while (iterator.hasNext()) {

            Foo foo = iterator.next();

            doSomethingWith(foo);
        }
    }

    public void doSomethingWith(Foo foo) {

        // do something with foo            

        // and possibly add one (or more) foo's to the worklist
        if (expression) {
            worklist.add(new Foo());
        }
    }
}

如果没有,如何以安全有效的方式实施此行为？

请注意,这不是关于aList,而是关于a LinkedList.如果它不安全,我会问有关替代方案.

ArrayList<String> list = new ArrayList<String>();
list.add("test");

while(list.listIterator().hasNext()) {
    System.out.println(list.listIterator().next());
}

这会产生一个带有"测试"的无限循环线.为什么会发生这种情况以及如何解决？

我的问题非常非常简单,但我在网上发现的一切都告诉我,我正在以正确的方式做到这一点 - 但我显然误解了一些事情.

我有一个简单,简单的Java ListIterator,它在while-hasNext() - 循环中为next()返回一个null.以下是我对调试状态的评论代码:

[...]
ListIterator<Role> rolesIterator = currentUser.getRoles().listIterator();
// rolesIterator is now: java.util.ArrayList$ListItr
while( rolesIterator.hasNext() ) {
        Role roleObject = rolesIterator.next(); // extra step for debugging reasons
        String role = roleObject.getName(); // NullPointerException - roleObject is null
[...]

在我的想法中,如果没有next()对象,则不应输入循环 - 这就是我使用hasNext()检查的原因.我理解错了什么,正确的方法是什么？

例如，假设有一些Collections#reverse(List)使用的操作，ListIterator例如：

var forwardItr = list.listIterator();
var reverseItr = list.listIterator(list.size());
while (forwardItr.nextIndex() < reverseItr.previousIndex()) {
  var forward = forwardItr.next();
  var reverse = reverseItr.previous();
  forwardItr.set(reverse)
  reverseItr.set(forward)
}

是否应该有一些实现ConcurrentModificationException从抛出ListIterator#set？或者更确切地说，是否存在应引起异常抛出的特定类型的修改（即“结构”）？是否暗示某些实现List可能合理地引发上述操作的异常？

我正在尝试使用列表迭代器从列表中删除对象.我已经浏览了网站上的其他解决方案,并没有减轻错误"线程中的异常"主"java.util.ConcurrentModificationException"

这是我的代码没有执行:

void PatronReturn(String bookName) {
//       get to beginning
    while(listIterator.hasPrevious()) {
        listIterator.previous();
    }
    while(listIterator.hasNext()){
        Book b = listIterator.next();
    if (listIterator.next().getBookTitle().equals(bookName)) { 
        //listIterator.next();
        //listIterator.remove();
        books.remove(b);
        //listIterator.next(); //moves to next so iterator can remove previous ?
        //books.remove(listIterator.next());; // TODO see if this is correct

    }
    }

我目前正在尝试学习如何实现自己的ListIterators.除了我对previous()方法感到困惑之外,我已经实现了大部分并准备好了.按照标准惯例,我可以解释一下通常如何解释previous().

即:

             >cursor<
dog     cat    fish     bird     frog    snake

根据Oracles Java Platform 7 API:

E previous()

返回列表中的上一个元素并向后移动光标位置.可以重复调用此方法以向后遍历列表,或者与调用next()混合以来回传递.(请注意,对next和previous的交替调用将重复返回相同的元素.)

我不太明白的是,如果调用previous(),它会返回'fish'或'cat'.

我从两个方面理解它:

1)'鱼'是你以前的目标

2)'cat'是数字上指数'鱼'指数之前的对象

如果之前返回'fish',那么remove()实际上是否删除相同的元素而不管遍历的方向？