比较列表值并从一个列表中删除 - Groovy/Java

Question

I'm writing some tests in groovy using spock where I need to check that the values in two equally sized lists with are correctly mapped to each other and that no duplicate values exist in one of the lists. I'm currently doing the following:

I find a given value in list1 then I search for its corresponding value in list2. If I find that corresponding value in list2 I want to remove it. I repeat this to for every position on the list (list1) and at the end I want to verify that list2 is empty. If list2 is not empty at the end it indicates there were some unexpected values or duplicates which were not removed.

I'm doing the following

def list1 = ["a", "b", "c", "d"]
def list2 = ["dog", "goat", "wolf", "fox"]

list1.size() == list2.(size)

list1.size().times() {
 if (list1.contains("a")) {
  if (list2.contains("dog")) {
   println(it + " found dog.... removing")
   list2.remove("dog")
   println(list2)
  }
  if (list1.contains("b")) {
   if (list2.contains("goat")) {
    println(it + " found goat.... removing")
    list2.remove("goat")
    println(list2)
   }
  }
  if (list1.contains("c")) {
   if (list2.contains("wolf")) {
    println(it + " found wolf.... removing")
    list2.remove("wolf")
    println(list2)
   }
  }

  if (list1.contains("d")) {
  if (list2.contains("fox")) {
    println(it + " found fox.... removing")
    list2.remove("fox")
    println(list2)
   }
  }
 }
 }
list2.isEmpty()

This seems to work but im wondering if there is there a more effective way of doing this in groovy?

Answer 1

Your approach is very complicated.

The good thing about Spock is, you can split the assertions in multiple parts.

First check for correct mappings.
And then check for no additional mappings in the remaining lists.

then: 'correct mapping'
list1.remove("a") == list2.remove("dog")
list1.remove("b") == list2.remove("goat")
list1.remove("c") == list2.remove("wolf")
list1.remove("d") == list2.remove("fox")

and: 'no additional mapping'
list1.isEmpty()
list2.isEmpty()

Answer 2

It is actually even easier than described by Sven, just one line of code if you use the Groovy default method transpose(List) which actually maps to GroovyCollections.transpose(List) :

package de.scrum_master.stackoverflow.q61859270

import spock.lang.Specification

class ListMappingTest extends Specification {
  static class UnderTest {
    List<String> getFirstList() {
      ["a", "b", "c", "d"]
    }

    List<String> getSecondList() {
      ["dog", "goat", "wolf", "fox"]
    }
  }

  def "lists in matching order"() {
    given:
    def underTest = new UnderTest()
    def list1 = underTest.getFirstList()
    def list2 = underTest.getSecondList()

    expect: "one way to do it: list of lists"
    [list1, list2].transpose() ==
      [["a", "dog"], ["b", "goat"], ["c", "wolf"], ["d", "fox"]]

    and: "another way to do it: map"
    [list1, list2].transpose().collectEntries { [it[0], it[1]] } ==
      [a: "dog", b: "goat", c: "wolf", d: "fox"]
  }

  def "lists in non-matching order"() {
    given:
    def underTest = new UnderTest()
    def list1 = underTest.getFirstList().swap(0, 3)
    def list2 = underTest.getSecondList().swap(1, 2)
    def set1 = list1.toSet()
    def set2 = list2.toSet()

    expect:
    list1.size() == set1.size()
    list2.size() == set2.size()
    set1 == ["a", "b", "c", "d"].toSet()
    set2 == ["dog", "goat", "wolf", "fox"].toSet()
  }
}