Groovy Carte de Listes dans la Liste des Cartes

Donc, essentiellement, j'ai quelque chose comme ceci:

[a: ["c","d"], b: ["e","f"]]

Le nombre d'éléments dans chaque liste est arbitraire. Si il y a un seul élément de la liste n'est plus une liste et c'est une chaîne.

Je veux le transformer en:

[ [a:"c", b:"e"], [a:"d",b:"f"] ]

Je ne m'en soucie pas vraiment si la solution utilise Groovy méthodes ou non. Merci pour votre aide!

Partager le code que vous avez essayé jusqu'à présent...
Je n'ai pas de code parce que je suis perplexe sur une belle façon de le faire. J'espérais qu'il y avait quelques intégré dans les méthodes à utiliser.

OriginalL'auteur James Kleeh | 2013-03-22

  1. 8

    Voici une autre façon de faire, qui je pense est moins obscur, tout en restant assez concis:

    def ml = [a: ["c","d"], b: ["e","f"]]

//Create an empty list that creates empty maps as needed
def lm = [].withDefault{ [:] }

ml.each{ k, values ->
    [values].flatten().eachWithIndex { value, index ->
        lm[index][k] = value
    }
}

assert lm == [[a:"c", b:"e"], [a:"d", b:"f"]]

    Si vous ne voulez pas ou ne pouvez pas utiliser withDefault (parce que vous ne voulez pas la liste de croître automatiquement), puis cela fonctionne:

    def ml = [a: ["c","d"], b: ["e","f"]]

def lm = []

ml.each{ k, values ->
    [values].flatten().eachWithIndex { value, index ->
        lm[index] = lm[index] ?: [:]
        lm[index][k] = value
    }
}

assert lm == [[a:"c", b:"e"], [a:"d", b:"f"]]

    Modifier: Ajout de code pour gérer les chaînes de caractères ne figurant pas dans une liste.

    Note, le truc ([values].flatten().eachWithIndex{...}) n'est pas forcément très efficace. Si la vitesse est essentielle, puis à l'aide ce serait un peu plus rapide au détriment de la lisibilité:

    (values instanceof List ? values : [values]).eachWithIndex{...}
    Ok le withDefault est ce qui me manquait. Ce ne marche pas encore gérer le cas de la valeur à une chaîne, voici donc la udpated code: "si (les valeurs instanceof ArrayList) { valeurs.eachWithIndex { valeur, index -> lm[index][k] = valeur } } else { lm[0][k] = valeurs }`
    OK, c'était un peu enterré à votre question initiale, mais je le vois maintenant. Juste un avis: vous auriez mieux fait d'utiliser values instanceof List, car il est plus souple si vous avez besoin de modifier la Liste à une date ultérieure.

    OriginalL'auteur OverZealous

  2. 7

    One-liner, en supposant que x = [a: ["c","d"], b: ["e","f"]] ou x = [a: "b", c: "d"]:

    [x*.key, x*.value].transpose()*.combinations().transpose()*.flatten()*.toSpreadMap()

    Comment cela fonctionne:

    D'abord, diviser les clés et valeurs:

    [x*.key, x*.value] = [[a, b], [[c, d], [e, f]]]

    Les transposer à la paire de clés et de valeurs:

    [[a, b], [[c, d], [e, f]]].transpose() = [[a, [c, d]], [b, [e, f]]]

    Utilisation combinations de mettre la clé avec ses valeurs (la propagation de l'opérateur utilisé ici pour l'appliquer à chaque élément de la liste). Notez que les combinaisons ne traitent à la fois de [a:b] ou [a:[b,c]] correctement:

    [[a, [c, d]], [b, [e, f]]]*.combinations() = [[[a, c], [a, d]], [[b, e], [b, f]]]

    Transposer les listes de sorte que nous nous retrouvons avec abab au lieu de l'aabb (si imbriquée un peu):

    [[[a, c], [a, d]], [[b, e], [b, f]]].transpose() = [[[a, c], [b, e]], [[a, d], [b, f]]]

    Aplatir les listes imbriquées (à l'aide d'étaler à nouveau pour aplatir listes imbriquées,mais pas toute la liste):

    [[[a, c], [b, e]], [[a, d], [b, f]]]*.flatten() = [[a, c, b, e], [a, d, b, f]]

    Propagation toSpreadMap pour convertir cette liste dans une liste de cartes.

    [[a, c, b, e], [a, d, b, f]]*.toSpreadMap() = [*:[b:e, a:c], *:[b:f, a:d]]

    OriginalL'auteur slipheed

  3. 2

    Définir quelques fonctions:

    //call a 2-element list a "pair"

//convert a map entry (where entry.value can be 
//a single string or a list of strings) into a list of pairs
def pairs(entry) {
  if (entry.value instanceof String)
    return [[entry.key, entry.value]]
  entry.value.collect { [entry.key, it]}
}

//convert list of pairs to a map
def toMap(pairs) {
  pairs.inject([:]){ m,i -> m[i[0]] = i[1]; m }
}

//kind of like transpose but doesn't stop with shortest list. 
//(would like to find a less ugly way of doing this)
def mytranspose(lists) {
  def retval = []
  def mx = lists.inject(0){x, i -> i.size() > x ? i.size() : x}
  for (int i = 0; i < mx; i++) {
    def row = []
    lists.each { lst ->
      if (lst.size() > i) row << lst[i]
    }
    retval << row
  }
  retval
}

    puis de les assembler et de tester:

    groovy:000> m = [a: ["c","d"], b: ["e","f"]]
groovy:000> mytranspose(m.entrySet().collect{pairs(it)}).collect{toMap(it)}
===> [{a=c, b=e}, {a=d, b=f}]

    La carte les entrées qui sont des chaînes de caractères, et la carte d'entrée d'une liste de différentes longueurs:

    groovy:000> m['g'] = 'h'
===> h
groovy:000> m['x'] = ['s', 't', 'u', 'v']
===> [s, t, u, v]
groovy:000> m
===> {a=[c, d], b=[e, f], g=h, x=[s, t, u, v]}
groovy:000> mytranspose(m.entrySet().collect{pairs(it)}).collect{toMap(it)}
===> [{a=c, b=e, g=h, x=s}, {a=d, b=f, x=t}, {x=u}, {x=v}]
    Malheureusement cela ne peut pas gérer le cas lorsque la valeur n'est pas une Carte, mais est une Chaîne de caractères. "Si il y a un seul élément de la liste n'est plus une liste et c'est une chaîne." Aussi, Votre exemple de résultats dans [[[a:c], [b:e]], [[a:d], [b:f]]]. Cela devrait être [ [a:"c", b:"e"], [a:"d",b:"f"] ]

    OriginalL'auteur Nathan Hughes

  4. 1

    Voici ce que j'ai fait. Si quelqu'un a une meilleure solution, laissez-moi savoir et je vais l'accepter comme réponse.

      Map xyz = [a: ["c","d"], b: ["e","f"]]

  List result = []

    Closure updateMap = { list, index, key, value ->
        if ( !(list[index] instanceof Map) ) {
            list[index] = [:]
        }
        list[index]."$key" = value
    }

    xyz.each { k, v ->
        if (v instanceof ArrayList) {
            v.eachWithIndex { val, idx ->
                updateMap(result, idx, k, val)
            }
        }
        else {
            updateMap(result, 0, k, v)
        }
    }

    OriginalL'auteur James Kleeh