如何在 Groovy 中“切片”集合

Question

我有一组对象，我想将它们分解为一组集合，其中每个连续的 3 个元素组都在一个集合中。 例如，如果我有

def l = [1,4,2,4,5,9]

我想把它变成：

def r = [[1,4,2], [4,5,9]]

我现在通过迭代集合并将其分解来做到这一点。但是我需要将这些“组”传递给处理它们的并行函数。消除这个 O(n) 会很好预处理工作，然后说类似

l.slice(3).collectParallel { subC -> process(subC) }

我在 Range 类上找到了 step 方法，但它看起来只对索引起作用。有什么聪明的主意吗？

更新： 我不认为这是引用链接的副本，尽管它非常接近。正如下面所建议的，它更像是我正在寻找的迭代器类型的东西.. 然后子集合将被传递到 GPars collectParallel 中。理想情况下，我不需要分配整个新集合。

Answer 1

查看 groovy 1.8.6。 List 上有一个新的 collat​​e 方法。

def list = [1, 2, 3, 4]
assert list.collate(4) == [[1, 2, 3, 4]] // gets you everything   
assert list.collate(2) == [[1, 2], [3, 4]] //splits evenly
assert list.collate(3) == [[1, 2, 3], [4]] // won't split evenly, remainder in last list.

查看Groovy List documentation 了解更多信息，因为还有一些其他参数可以为您提供一些其他选项，包括删除其余部分。

就您的并行处理而言，您可以使用gpars 浏览列表。

def list = [1, 2, 3, 4, 5]
GParsPool.withPool {
  list.collate(2).eachParallel {
     println it
  }
}

Answer 2

如果我理解正确，您当前正在将原始集合中的元素复制到子集合中。有关这些方面的更多建议，请查看以下问题的答案：Split collection into sub collections in Groovy

听起来您正在寻找的是一种让子集合有效地成为原始集合视图的方法。如果是这种情况，请查看List.subList() method。您可以以 3 为增量（或您选择的任何切片大小）循环从 0 到 size() 的索引，或者您可以变得更漂亮并构建一个 Iterable/List 来隐藏调用者的详细信息。这是后者的一个实现，灵感来自Ted's answer。

class Slicer implements Iterator {
  private List backingList
  private int sliceSize
  private int index

  Slicer(List backingList, int sliceSize) {
    this.backingList = backingList
    this.sliceSize = sliceSize
  }

  Object next() {
    if (!hasNext()) {
      throw new NoSuchElementException()
    }

    def ret
    if (index + sliceSize <= backingList.size()) {
      ret = backingList.subList(index, index+sliceSize)
    } else if (hasNext()) {
      ret = backingList.subList(index, backingList.size())
    }
    index += sliceSize
    return ret
  }

  boolean hasNext() {
    return index < backingList.size()
  }

  void remove() {
    throw new UnsupportedOperationException() //I'm lazy ;)
  }
}

Answer 3

我喜欢这两种解决方案，但这里是我非常喜欢的第一个解决方案的略微改进版本：

class Slicer implements Iterator {
private List backingList
private int sliceSize
private int index

Slicer(List backingList, int sliceSize) {
  this.backingList = backingList;
  int ss = sliceSize;

  // negitive sliceSize = -N means, split the list into N equal (or near equal) pieces  
  if( sliceSize < 0) {
      ss = -sliceSize;
      ss = (int)((backingList.size()+ss-1)/ss);
  }
  this.sliceSize = ss
}

Object next() {
  if (!hasNext()) {
    throw new NoSuchElementException()
  }

  def ret = backingList.subList(index, Math.min(index+sliceSize , backingList.size()) );
  index += sliceSize
  return ret
  }

  boolean hasNext() {
    return index < backingList.size() - 1
  }

  void remove() {
    throw new UnsupportedOperationException() //I'm lazy ;)
  }

  List asList() {
    this.collect { new ArrayList(it) }
  }

  List flatten() {
    backingList.asImmutable()
  }

}

// ======== TESTS

    def a = [1,2,3,4,5,6,7,8];
    assert  [1,2,3,4,5,6,7,8] == a;
    assert [[1, 2], [3, 4], [5, 6], [7, 8]] ==  new Slicer(a,2).asList(); 
    assert [[1,2,3], [4,5,6], [7,8]] == (new Slicer(a,3)).collect { it } // alternative to asList but inner items are subList
    assert [3, 2, 1, 6, 5, 4, 8, 7] == ((new Slicer(a,3)).collect { it.reverse() } ).flatten()

    // show flatten iterator
    //new Slicer(a,2).flattenEach { print it }
    //println ""

    // negetive slice into N pieces, in this example we split it into 2 pieces
    assert [[1, 2, 3, 4], [5, 6, 7, 8]] ==  new Slicer(a,-2).collect { it as List }  // same asList
    assert [[1, 2, 3], [4, 5, 6], [7, 8]] == new Slicer(a,-3).asList()
    //assert a == (new Slicer(a,3)).flattenCollect { it } 
    assert [9..10, 19..20, 29..30] == ( (new Slicer(1..30,2)).findAll { slice -> !(slice[1] % 10) } )
    assert [[9, 10], [19, 20], [29, 30]] == ( (new Slicer(1..30,2)).findAll { slice -> !(slice[1] % 10) }.collect { it.flatten() } )

    println( (new Slicer(1..30,2)).findAll { slice -> !(slice[1] % 10) } )
    println( (new Slicer(1..30,2)).findAll { slice -> !(slice[1] % 10) }.collect { it.flatten() } )

Answer 4

没有任何内置功能可以完全按照您的要求进行操作，但是如果我们 @Delegate 调用本机列表的迭代器，我们可以编写自己的类，该类的工作方式与返回您正在查找的块的迭代器一样为：

class Slicer {
    protected Integer sliceSize 
    @Delegate Iterator iterator

    Slicer(objectWithIterator, Integer sliceSize) {
        this.iterator = objectWithIterator.iterator()
        this.sliceSize = sliceSize
    }

    Object next() {
        List currentSlice = []
        while(hasNext() && currentSlice.size() < sliceSize) {
            currentSlice << this.iterator.next()
        }
        return currentSlice
    }
}

assert [[1,4,2], [4,5,9]] == new Slicer([1,4,2,4,5,9], 3).collect { it }

因为它具有普通迭代器所具有的所有方法，所以您可以免费获得 groovy 语法糖方法，并对任何具有 iterator() 方法的东西（例如范围）进行惰性求值：

assert [5,6] == new Slicer(1..100, 2).find { slice -> slice.first() == 5 }

assert [[9, 10], [19, 20], [29, 30]] == new Slicer(1..30, 2).findAll { slice -> !(slice[1] % 10) }