Finden element matching in 2 Listen, die mit java 8 stream

Einen einfachen Weg, das zu tun, ist das überschreiben equals und hashCode. Da ich davon ausgehe das die Gleichstellung von Person müssen auch berücksichtigen, die id Feld, können Sie wickeln Sie diese Instanz in eine PersonWrapper die Umsetzung der richtigen equals und hashCode (d.h. nur die name und age Felder):

class PersonWrapper {

    private Person person;

    private PersonWrapper(Person person) {
        this.person = person;
    }

    public static PersonWrapper wrap(Person person) {
        return new PersonWrapper(person);
    }

    public Person unwrap() {
        return person;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        PersonWrapper other = (PersonWrapper) obj;
        return person.name.equals(other.person.name) && person.age.equals(other.person.age);
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + person.name.hashCode();
        result = prime * result + person.age.hashCode();
        return result;
    }

}

Mit einer solchen Klasse können Sie dann die folgenden:

Set<PersonWrapper> set2 = list2.stream().map(PersonWrapper::wrap).collect(toSet());

boolean exists =
    list1.stream()
         .map(PersonWrapper::wrap)
         .filter(set2::contains)
         .findFirst()
         .isPresent();

System.out.println(exists);

Dieser code wandelt die list2 in eine Set des umschlossenen Personen. Das Ziel eines Set ist, um eine Konstante-time contains Betrieb für eine bessere Leistung.

Dann, die list1 gefiltert wird. Jedes element gefunden in set2 gehalten wird und wenn es ein element Links (das heißt, wenn findFirst() gibt eine nicht leere Optional), es bedeutet, dass ein element gefunden wurde.

Gut, wenn Sie nicht über die Pflege der id Feld, dann können Sie die equals Methode, um dieses Problem zu lösen.

Hier ist die Person Klasse code

public class Person {
  private String id ;
  private String name;
  private String age;

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    Person sample = (Person) o;

    if (!name.equals(sample.name)) return false;
    return age.equals(sample.age);

  }

  @Override
  public int hashCode() {
    int result = name.hashCode();
    result = 31 * result + age.hashCode();
    return result;
  }
}

Jetzt können Sie stream, um die Kreuzung so gerne. common enthält alle Person Objekte, wo name und age sind die gleichen.

List<Person> common = list1
      .stream()
      .filter(list2::contains)
      .collect(Collectors.toList());

Dieser funktionieren würde:

class PresentOrNot {boolean isPresent = false;};
final PresentOrNot isPresent = new PresentOrNot ();
l1.stream().forEach(p -> {
    isPresent.isPresent = isPresent.isPresent || l2.stream()
        .filter(p1 -> p.name.equals(p1.name) && p.age.equals(p1.age))
        .findFirst()
        .isPresent();
});
System.err.println(isPresent.isPresent);

Seit forEach() nimmt der Verbraucher, haben wir keine Möglichkeit der Rückkehr und PresentOrNot {} ist ein workaround.
Beiseite: Wo didi bekommen Sie ein solches Erfordernis 🙂

public static void main(String[] args) {
    OTSQuestions ots = new OTSQuestions();

    List<Attr> attrs = ots.getAttrs();
    List<String> ids = new ArrayList<>();
    ids.add("101");
    ids.add("104");
    ids.add("102");

    List<Attr> finalList = attrs.stream().filter(
            attr -> ids.contains(attr.getId()))
            .collect(Collectors.toList());
}

public class Attr {
    private String id;
    private String name;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

private List<Attr> getAttrs() {
    List<Attr> attrs = new ArrayList<>();
    Attr attr = new Attr();
    attr.setId("100");
    attr.setName("Yoga");
    attrs.add(attr);

    Attr attr1 = new Attr();
    attr1.setId("101");
    attr1.setName("Yoga1");
    attrs.add(attr1);

    Attr attr2 = new Attr();
    attr2.setId("102");
    attr2.setName("Yoga2");
    attrs.add(attr2);

    Attr attr3 = new Attr();
    attr3.setId("103");
    attr3.setName("Yoga3");
    attrs.add(attr3);

    Attr attr4 = new Attr();
    attr4.setId("104");
    attr4.setName("Yoga4");
    attrs.add(attr4);

    return attrs;
}