Java 方法错误-使用迭代器交织列表

我创建了一个方法，该方法应该将两个列表对象交织在一起，并返回新的、交织的列表

i、 e.如果aList是[A，C，e，G]&bList是[B，D，F]，该方法将返回一个包含[A，B，C，D，e，F，G]的列表

没有编译器错误，当我运行程序时，返回的列表为空。我发现程序没有进入for循环，因为在我创建newList时，由于某种原因，它的大小为0

代码如下：

    public static <E> List<E> interweave(List<E> a, List<E> b){
    List<E> newList = new ArrayList<E>(a.size() + b.size());

    Iterator<E> itrA = a.iterator();
    Iterator<E> itrB = b.iterator();

    for(int i = 0; i < newList.size(); i++){
        if(i%2 == 0)
            newList.add(i, itrA.next());
        else
            newList.add(i, itrB.next());
    }

    return newList;
}

公共静态列表交织（列表a、列表b）{
List newList=newarraylist（a.size（）+b.size（））；
迭代器itrA=a.Iterator（）；
迭代器itrB=b.迭代器（）；
对于（int i=0；i

我相信这可以用一种更简单的方法来实现，使用

while（iterator.hasNext（））

习惯用法：

itrA = a.iterator();
itrB = b.iterator(); 

while (itrA.hasNext() || itrB.hasNext()) {
  if (itrA.hasNext())
      newList.add(itrA.next());
  if (itrB.hasNext())
      newList.add(itrB.next());
}

---

可以动态组合列表：

static class InterWeave<T> implements Iterable<T> {

    // The lists to be interwoven.
    final Iterable<T>[] lists;

    public InterWeave(Iterable<T>... lists) {
        this.lists = lists;
    }

    @Override
    public Iterator<T> iterator() {
        return new WeaveIterator();

    }

    private class WeaveIterator implements Iterator<T> {

        // Which list to offer next.
        int whichList = 0;
        // The Iterators of those lists.
        final List<Iterator<T>> iterators = new ArrayList(lists.length);
        // The current iterator.
        Iterator<T> i;
        // The next to deliver - null menas not primed yet.
        T next = null;

        public WeaveIterator() {
            // Take some iterators.
            for (Iterable<T> l : lists) {
                if (l != null) {
                    iterators.add(l.iterator());
                }
            }
        }

        @Override
        public boolean hasNext() {
            // Have we already prepared one?
            if (next == null) {
                // Grab the next iterator and step on.
                i = iterators.get(whichList++);
                // detect that we're back at start.
                Iterator<T> start = i;
                // Cycle around the iterators.
                whichList %= iterators.size();
                while (!i.hasNext()) {
                    // Get next one.
                    i = iterators.get(whichList++);
                    whichList %= iterators.size();
                    if (i == start) {
                        // Stop here if we've gone all the way around.
                        break;
                    }
                }
                if (i.hasNext()) {
                    next = i.next();
                }
            }
            return next != null;
        }

        @Override
        public T next() {
            if (hasNext()) {
                T n = next;
                // Mark it used.
                next = null;
                return n;
            } else {
                throw new NoSuchElementException();
            }
        }

    }

}

public void test() {
    List<String> a = Arrays.asList(new String[]{"A", "C", "E", "G"});
    List<String> b = Arrays.asList(new String[]{"B", "D", "F"});
    for (String s : new InterWeave<String>(a, b)) {
        System.out.println(s);
    }
}

static类交织实现了Iterable{
//这些清单需要相互交织。
最后的清单；
公共交织（Iterable…列表）{
this.lists=列表；
}
@凌驾
公共迭代器迭代器（）{
返回新的weaviterator（）；
}
私有类weaviterator实现迭代器{
//下一个要提供的列表。
int whichList=0；
//这些列表的迭代器。
最终列表迭代器=新的ArrayList（lists.length）；
//当前迭代器。
迭代器i；
//下一个要交付的-null menas尚未启动。
T next=null；
公共福利顾问（）{
//以一些迭代器为例。
用于（ITEL:列表）{
如果（l！=null）{
迭代器.add（l.iterator（））；
}
}
}
@凌驾
公共布尔hasNext（）{
//我们已经准备好了吗？
if（next==null）{
//抓取下一个迭代器并继续。
i=迭代器.get（whichList++）；
//发现我们回到了起点。
迭代器开始=i；
//循环遍历迭代器。
whichList%=迭代器.size（）；
而（！i.hasNext（））{
//下一个。
i=迭代器.get（whichList++）；
whichList%=迭代器.size（）；
如果（i==开始）{
//如果我们走了那么远，就停在这里。
打破
}
}
if（i.hasNext（））{
next=i.next（）；
}
}
返回下一步！=null；
}
@凌驾
公共交通工具{
if（hasNext（））{
T n=下一个；
//标记它已被使用。
next=null；
返回n；
}否则{
抛出新的NoTouchElementException（）；
}
}
}
}
公开无效测试（）{
List a=Arrays.asList（新字符串[]{“a”、“C”、“E”、“G”}）；
listb=Arrays.asList（新字符串[]{“b”、“D”、“F”}）；
用于（字符串s：新交织（a，b））{
系统输出打印项次；
}
}

构造函数

新建数组列表（大小）

会按照您定义的大小分配一个新数组。但是

ArrayList#size

不返回数组的长度，它返回一个变量

size

，该变量在操作

列表后更改。创建新的
阵列列表后，大小仍然为0。谢谢！这正是我需要知道的！因此，当我使用
new ArrayList（）
时，然后在
for
循环中使用
a.size（）+b.size（）
的值，它可以完美地工作。简单且最佳的解决方案+谢谢你，伙计！这是完成工作的更简单的方法。另外，当我使用
new ArrayList（）
时，然后在
for
循环中使用
a.size（）+b.size（）
的值，它工作得非常好。为了简化此解决方案，加上一个值。