【问题标题】:Java - how to obtain an interleaved iterator/collectionJava - 如何获得交错的迭代器/集合
【发布时间】:2016-12-24 07:14:08
【问题描述】:

假设我们异步接收来自 3 个生产者的字符串。一旦收到一定数量的这些对象,我想以交错的方式迭代它们,也就是说,如果接收到以下字符串:

"a1" received from A,
"a2" received from A,
"c1" received from C,
"a3" received from A,
"b1" received from B,
"b2" received from B,

我希望“交错”迭代器返回字符串,就像我们正在迭代以下列表一样:

List<String> interleavedList = {"a1", "b1", "c1", "a2", "c2", "a3"},

到目前为止,我已经为每个生产者创建了一个 List&lt;String&gt;,然后我通过使用 3 个列表迭代器(使用 List&lt;Iterator&lt;String&gt;&gt;)来“迭代”所有字符串。这很好,但我认为有一种更简单的方法......也许通过在接收字符串时直接构造交错列表?但我看不出要使用哪个Collection 或哪个Comparator...

请注意,我对为每个生产者创建一个列表,然后将这 3 个列表合并到第 4 个交错列表中并不是很感兴趣,因为这可能不省时。

【问题讨论】:

  • 您能告诉我们更多关于效率的信息吗?例如。使用CyclicBarrier 可以实现这一点,但是,这会减慢生产者的速度。另一方面,使用您提到的列表是完全省时的。它会占用一些内存。
  • 您可以继承 java.util.Iterator 来实现这一点。另见stackoverflow.com/questions/3610261/…
  • 如果使用 java 8,您是否尝试过在流中交错字符串?
  • 制作人会在某个时候完成他们的工作吗?你能等到迭代最终结果吗?

标签: java collections


【解决方案1】:

您似乎希望对列表进行排序,数字首先确定排序,字母第二。 Java 没有排序列表,因为列表的本质是它们没有排序。但是,您可以使用带有自定义比较器的排序集:

SortedSet<String> sortedset = new TreeSet<String>(
        new Comparator<String>() {
            @Override
            public int compare(String e1, String e2) {
                int num1 = Integer.parseInt(e1.replaceAll("[^\\d.]", ""));
                int num2 = Integer.parseInt(e2.replaceAll("[^\\d.]", ""));
                if (num1 > num2) {
                    return 1;
                }
                else if (num1 < num2) {
                    return -1;
                }
                else {
                    String let1 = e1.replaceAll("[0-9]", "");
                    String let2 = e2.replaceAll("[0-9]", "");
                    return let1.compareTo(let2);
                }
            }
        });

当你遍历这个集合时,你会得到你在问题中描述的顺序。

【讨论】:

    【解决方案2】:

    一种选择是根据它们到达的生产者特定索引将所有对象转储到PriorityBlockingQueue:

    class Message {
       String data;
       long index;
    }
    
    PriorityBlockingQueue<Message> queue = new PriorityBlockingQueue<Message>(
      10,
      Comparator.comparing(m -> m.index)
    ); 
    
    List<String> batch = new ArrayList<>(BATCH_SIZE);
    for (;;) {
       for (int i = 0; i < BATCH_SIZE; i++) {
          batch.add(queue.take().data);
       }
       handleBatch(batch);
       batch.clear();
    }
    

    请注意,这假设一个无限队列;如果队列不是无限的,则必须添加一些逻辑来处理最后一批。

    【讨论】:

      【解决方案3】:

      您可以使用自定义Comparator 将字符串添加到PriorityQueue&lt;String&gt;。在这种情况下,您的元素将在您添加它们时自动排序。 这是useful example。

      【讨论】:

        【解决方案4】:

        我最近遇到了类似的问题,这是我想出的(只是依次从每个迭代器中取出,直到它们全部耗尽,没有排序):

        import java.util.Collection;
        import java.util.Iterator;
        
        public class InterleavedIterator<T> implements Iterator<T> {
        
          static class Node<K> {
            Node<K> next;
            Node<K> prev;
            final K value;
        
            Node(K value) {
              this.value = value;
            }
        
            public void setNext(Node<K> next) {
              this.next = next;
            }
        
            public void setPrev(Node<K> prev) {
              this.prev = prev;
            }
          }
        
          private Node<Iterator<T>> node;
        
          public InterleavedIterator(Collection<Iterator<T>> iterators) {
            Node<Iterator<T>> prev = null;
            for (Iterator<T> iterator : iterators) {
              if (!iterator.hasNext()) {
                continue;
              }
              Node<Iterator<T>> current = new Node<>(iterator);
              if (prev != null) {
                prev.setNext(current);
                current.setPrev(prev);
              } else {
                node = current;
              }
              prev = current;
            }
            if (prev != null) {
              prev.setNext(node);
              node.setPrev(prev);
            }
          }
        
          @Override
          public boolean hasNext() {
            return node.value.hasNext();
          }
        
          @Override
          public T next() {
            T res = node.value.next();
            updateNode();
            return res;
          }
        
          private void updateNode() {
            Node<Iterator<T>> nextNode = node.next;
            if (node.value.hasNext()) {
              node = nextNode;
            } else if (node != nextNode) {
              node.prev.next = nextNode;
              nextNode.prev = node.prev;
              node = nextNode;
            }
          }
        }
        

        【讨论】:

          猜你喜欢
          • 2021-12-14
          • 2011-04-25
          • 2022-01-02
          • 1970-01-01
          • 2015-08-17
          • 1970-01-01
          • 1970-01-01
          • 1970-01-01
          • 1970-01-01
          相关资源
          最近更新 更多