Java 8: Bardziej efektywny sposób porównywania list różnych typów?

Question

W teście jednostkowym chcę sprawdzić, czy dwie listy zawierają te same elementy. Lista do przetestowania jest zbudowana z listy obiektów Person, z których wypakowywane jest jedno pole typu String. Druga lista zawiera literały String.

Często stwierdza następujący fragment kodu do wykonania tego zadania (patrz this answer):

List<Person> people = getPeopleFromDatabasePseudoMethod(); 
List<String> expectedValues = Arrays.asList("john", "joe", "bill"); 

assertTrue(people.stream().map(person -> person.getName()).collect(Collectors.toList()).containsAll(expectedValues)); 

Klasa Person jest zdefiniowana w:

public class Person { 

    private String name; 
    private int age; 

    public String getName() { 
     return name; 
    } 

    public void setName(final String name) { 
     this.name = name; 
    } 

    // other getters and setters 
} 

w powyższym przykładzie, do wykazu osób (lub ludzie) jest przekształcana na listę Ciągów przy użyciu technik Java 8, a porównanie odbywa się w staromodny sposób.

Teraz zastanawiam się, czy istnieje bardziej bezpośredni lub bardziej efektywny sposób porównania za pomocą innych instrukcji Java 8, na przykład allMatch() lub niektóre Predicate<T> lub coś innego.

Answer 1

Kod Twojego pytania nie odzwierciedla tego, co opisujesz w komentarzach. W komentarzach mówisz, że wszystkie nazwiska powinny być obecne, a rozmiar powinien się zgadzać, innymi słowy, tylko kolejność może być inna.

Twój kod jest

List<Person> people = getPeopleFromDatabasePseudoMethod(); 
List<String> expectedValues = Arrays.asList("john", "joe", "bill"); 

assertTrue(people.stream().map(person -> person.getName()) 
       .collect(Collectors.toList()).containsAll(expectedValues)); 

których brakuje test wielkości people, innymi słowy pozwala duplikaty. Ponadto, używając containsAll, łącząc dwie bardzo nieefektywne. Jest o wiele lepiej, jeśli używasz typu kolekcji, która odzwierciedla ty zamiar, czyli nie ma duplikatów, nie dba o porządku i ma sprawną odnośnika:

Set<String> expectedNames=new HashSet<>(expectedValues); 
assertTrue(people.stream().map(Person::getName) 
       .collect(Collectors.toSet()).equals(expectedNames)); 

Dzięki takiemu rozwiązaniu nie trzeba przetestować dla rozmiar ręcznie, jest już dorozumiany, że zestawy mają ten sam rozmiar, jeśli pasują, tylko kolejność może być inna.

Jest to rozwiązanie, które nie wymaga gromadzenia nazwisk persons:

Set<String> expectedNames=new HashSet<>(expectedValues); 
assertTrue(people.stream().allMatch(p->expectedNames.remove(p.getName())) 
      && expectedNames.isEmpty()); 

ale działa tylko wtedy, gdy expectedNames jest tymczasowy zestaw stworzony z statycznego kolekcji oczekiwanych nazwisk. Gdy tylko zdecydujesz się zastąpić kolekcję statyczną przez Set, pierwsze rozwiązanie nie wymaga zestawu tymczasowego, a drugie nie ma nad nim żadnej przewagi.

Answer 2

Jeżeli liczba elementów musi być taka sama, to byłoby lepiej, aby porównać zestawach:

List<Person> people = getPeopleFromDatabasePseudoMethod(); 
Set<String> expectedValues = new HashSet<>(Arrays.asList("john", "joe", "bill")); 
assertEquals(expectedValues, 
    people.stream().map(Person::getName).collect(Collectors.toSet())); 

equals sposób prawidłowo realizowanych zestawów powinny móc porównać różne rodzaje zestawów: liczy się tylko czy zawartość jest taka sama (ignorując kolejność oczywiście).

Korzystanie z assertEquals jest wygodniejsze, ponieważ w przypadku awarii komunikat o błędzie będzie zawierał ciąg znaków w twoim zestawie.