Comment «couper» une collection dans Groovy

J'ai une collection d'objets que j'ai envie de casser vers le haut dans une collection de collections, où chaque séquence de groupe de 3 éléments est en une collection.
Par exemple, si j'ai

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

Je veux en faire:

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

Je le fais maintenant par itération sur la collecte et la rupture vers le haut.. mais je puis avoir besoin de passer ces "groupes" dans un parallélisée fonction qui traite.. Il serait bon d'éliminer cette O(n) pré-traitement et de juste dire quelque chose comme

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

J'ai trouvé la méthode pas à pas sur la Gamme de la classe, mais il semble que ce n'agit que sur les indices. Toutes les idées intelligentes?

Mise à jour:
Je ne pense pas que c'est un doublon du lien référencé, même si c'est très proche. Comme indiqué ci-dessous, c'est plus de l'itérateur de type chose, je suis à la recherche de.. la sous-collections seront ensuite passés dans un GPars collectParallel. Idéalement, je n'aurais pas besoin d'allouer une toute nouvelle collection.

source d'informationauteur Bobby

groovy

Découvrez groovy 1.8.6. Il y a un nouveau rassembler méthode sur la Liste.

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.

Prendre un coup d'oeil à la Groovy Liste de la documentation pour plus d'info, car il ya un couple d'autres paramètres que vous donner quelques autres options, y compris en laissant tomber le reste.

En ce qui concerne votre traitement en parallèle, vous pouvez faire une croisière à travers les listes avec gpars.

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

Si je vous comprends bien, vous êtes en train de copier les éléments de la collection d'origine dans le sous-collections. Pour plus de suggestions long de ces lignes, la caisse de l'réponses à la question suivante: Diviser la collecte en sous-collections en Groovy

Il semble que vous vous êtes plutôt à la recherche d'un moyen pour les sous-collections effectivement être vue dans la collection d'origine. Si c'est le cas, consultez la Liste.sous-liste() la méthode. Vous pouvez soit en boucle sur les indices de 0 à taille() par incréments de 3 (ou quelle que soit la taille de la tranche de votre choix) ou vous pouvez obtenir de l'amateur et de construire un objet iterable/la Liste qui permettrait de masquer les détails de l'appelant. Voici une implémentation de ce dernier, inspiré par Ted répondre.

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 ;)
  }
}

J'aime bien les deux solutions, mais voici une version légèrement améliorée de la première solution que j'aime beaucoup:

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() } )

Il n'y a pas quelque chose de construit dans, de faire exactement ce que vous voulez, mais si nous @Delegate appels pour le natif des listes de l'itérateur, nous pouvons écrire notre propre classe, qui fonctionne exactement comme un Itérateur qui retourne les morceaux que vous cherchez:

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 }

Parce qu'il possède toutes les méthodes que l'Itérateur n', vous obtenez le groovy sucre syntaxique méthodes pour gratuit avec lazy evaluation sur tout ce qui a un iterator() méthode, comme une plage:

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) }

Vous devez vous connecter pour publier un commentaire.