Java 8 在java中，如何通过迭代列表过滤记录而不删除重复项？

我正试图根据firstName，lastName获取记录。两者都不是强制性参数

若firstName存在且匹配，则添加到列表中；同样，lastName存在且匹配（20条记录），则添加到列表中。如果firstName和lastName都匹配，则获取它们的组合（理想情况下小于30）

现在，下面的代码得到了记录的笛卡尔积。我们如何避免这种情况，只获取firstname和lastName的组合

 List<Person> filteredPersonDetailsList = new ArrayList<Person>();
            if(CollectionUtils.isNotEmpty(listOfPersonDetails)) {
                if(StringUtils.isNotBlank(firstName)) {
                    List<Person> filteredFirstNameList = listOfPersonDetails
                        .stream()
                        .filter(Objects::nonNull)
                        .filter(Person -> StringUtils.isNotBlank(Person.getFirstName())
                                && Person.getFirstName().equalsIgnoreCase(firstName))
                        .collect(Collectors.toList());
                    filteredPersonDetailsList.addAll(filteredFirstNameList);
                    }
                if(CollectionUtils.isNotEmpty(filteredPersonDetailsList)&&  
StringUtils.isNotBlank(lastName)) {
                    List<Person> filteredLastNameList = listOfPersonDetails
                        .stream()
                        .filter(Objects::nonNull)
                        .filter(Person -> StringUtils.isNotBlank(Person.getLastName()) 
                                && Person.getLastName().equalsIgnoreCase(lastName))
                        .collect(Collectors.toList());
                    filteredPersonDetailsList.addAll(filteredLastNameList);
                    }
                }

List-filteredPersonDetailsList=new-ArrayList（）；
if（CollectionUtils.isNotEmpty（PersonDetails列表））{
if（StringUtils.isNotBlank（firstName））{
List filteredFirstNameList=listOfPersonDetails
.stream（）
.filter（对象：：非空）
.filter（Person->StringUtils.isNotBlank（Person.getFirstName（））
&&Person.getFirstName（）.equalsIgnoreCase（firstName））
.collect（Collectors.toList（））；
filteredPersonDetailsList.addAll（filteredFirstNameList）；
}
if（CollectionUtils.isNotEmpty（filteredPersonDetailsList）和
StringUtils.isNotBlank（lastName））{
List filteredLastNameList=listOfPersonDetails
.stream（）
.filter（对象：：非空）
.filter（Person->StringUtils.isNotBlank（Person.getLastName（））
&&Person.getLastName（）.equalsIgnoreCase（lastName））
.collect（Collectors.toList（））；
filteredPersonDetailsList.addAll（filteredlastname列表）；
}
}

我想你做的检查太多了。这个怎么样：

// defaults as the immutable empty list (can be also mutable ArrayList - up to you)
List<Person> filteredFirstNameList = Collections.emptyList();     

// does it make sense to search for the first/last names?
if (StringUtils.isNotBlank(firstName) && StringUtils.isNotBlank(lastName)) {
    filteredFirstNameList = listOfPersonDetails
        .stream()
        .filter(Objects::nonNull)
        .filter(p->                                          // something to compare?
             StringUtils.isNotBlank(p.getFirstName()) && 
             StringUtils.isNotBlank(p.getLastName()))
        .filter(p->                                          // the actual comparison
             p.getFirstName().equalsIgnoreCase(firstName) && 
             p.getLastName().equalsIgnoreCase(lastName))
        .collect(Collectors.toList());
}

//默认为不可变的空列表（也可以是可变的ArrayList-由您决定）
List-filteredFirstNameList=Collections.emptyList（）；
//搜索名字/姓氏有意义吗？
if（StringUtils.isNotBlank（firstName）和&StringUtils.isNotBlank（lastName））{
filteredFirstNameList=listOfPersonDetails
.stream（）
.filter（对象：：非空）
.filter（p->//要比较的内容？
StringUtils.isNotBlank（p.getFirstName（））&&
StringUtils.isNotBlank（p.getLastName（））
.filter（p->//实际比较
p、 getFirstName（）.equalsIgnoreCase（firstName）&&
p、 getLastName（）.equalsIgnoreCase（lastName））
.collect（Collectors.toList（））；
}

这对我来说似乎很有效：

List<Person> persons = new ArrayList<>();
        persons.add(new Person("first1", "last1"));
        persons.add(new Person(null, "last2"));
        persons.add(new Person("first1", null));
        persons.add(new Person("first2", "last2"));
        persons.add(new Person("first3", "last3"));
        persons.add(new Person(null, null));
        persons.add(null);

List<Person> filteredPersons = persons.stream().filter(Objects::nonNull).filter(getFirstNamePredicate("first1")).collect(Collectors.toList());
        filteredPersons.addAll(persons.stream().filter(Objects::nonNull).filter(getLastNamePredicate("last2")).collect(Collectors.toList()));


// firstName Prdicate
public static Predicate<Person> getFirstNamePredicate(String firstName){
      return (person) -> Objects.nonNull(person.getFirstName()) && 
                         person.getFirstName().equalsIgnoreCase(firstName);
}

// lastName predicate
public static Predicate<Person> getLastNamePredicate(String lastName){
      return (person) -> Objects.nonNull(person.getLastName()) && 
                         person.getLastName().equalsIgnoreCase(lastName);
}

---

嗨，谢哈。。我只需要在firstName和LastName都匹配的情况下，过滤到列表。我的意思是，这应该是类似的标准在mongodbCan u请回复这个帖子？

[Person{firstName=first1, lastName=last1}, Person{firstName=first1, lastName=null}, Person{firstName=null, lastName=last2}, Person{firstName=first2, lastName=last2}]