使用Java8流在2个列表中查找元素匹配

我的情况是：

class Person {
    String id ;
    String name;
    String age;
}
List<Person> list1 = {p1,p2, p3};
List<Person> list2 = {p4,p5, p6}; 

班级人员{
字符串id；
字符串名；
弦年龄；
}
列表1={p1，p2，p3}；
列表2={p4，p5，p6}；

我想知道

list1

中是否有人与

list2

中的姓名和年龄相同，但不介意

id

---

什么是最好、最快的方法？

您需要迭代这两个列表并比较两个列表

for(Person person1 : list1) {
    for(Person person2 : list2) {
        if(person1.getName().equals(person2.getName()) && 
                person1.getAge().equals(person2.getAge())) {
            //your code
        }
    }
}

---

一种简单的方法是重写

equals

和

hashCode

。由于我假定<>代码>人>代码>还必须考虑<代码> id 字段，您可以将此实例打包为<代码>人手包装器< /C> >，它将实现正确的<代码>等值和<代码> HASCODE < /代码>（即只检查<代码>名称<代码>和<代码>年龄< /代码>字段）：

使用这样一个类，您可以获得以下内容：

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);

Set set2=list2.stream（）.map（PersonWrapper:：wrap）.collect（toSet（））；
布尔存在=
列表1.stream（）
.map（PersonWrapper:：wrap）
.filter（set2:：contains）
.findFirst（）
.isPresent（）；
System.out.println（存在）；

此代码将

list2

转换为包装人员的

Set

。设置

的目标是使
包含的
操作具有恒定的时间，以获得更好的性能

然后，过滤
列表1
。在
set2
中找到的每个元素都会被保留，如果还有一个元素（也就是说，如果
findFirst（）
返回一个非空的
可选的
），则表示找到了一个元素。
如果您不关心
id
字段，那么您可以使用
equals
方法来解决这个问题

这是
个人
课程代码

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;
  }
}

现在，您可以使用stream获得这样的交叉点
common
将包含所有
Person
对象，其中
name
和
age
是相同的

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

List common=list1
.stream（）
.filter（列表2:：包含）
.collect（Collectors.toList（））；
这将起作用：

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);

由于
forEach（）
接受消费者，因此我们无法返回，
PresentOrNot{}
是一种解决方法

旁白：你从哪里得到这样的要求的？：）
 蛮力，但纯java 8解决方案将是：

boolean present = list1
        .stream()
        .flatMap(x -> list2
            .stream()
            .filter(y -> x.getName().equals(y.getName()))
            .filter(y -> x.getAge().equals(y.getAge()))
            .limit(1))
        .findFirst()
        .isPresent();

这里，flatmap用于连接两个列表<使用代码>限制
是因为我们只对第一个匹配感兴趣，在这种情况下，我们不需要进一步遍历。
定义一个关键对象，用于保存和比较所需的属性。在这个简单的例子中，您可以使用一个小列表，而每个索引对应一个属性。对于更复杂的情况，可以使用
映射
（使用属性名称作为键）或专用类：

Function<Person,List<Object>> toKey=p -> Arrays.asList(p.getName(), p.getAge());

当您有相当大的列表时，这可能会导致性能不佳。当您有较大的列表（或无法预测其大小）时，您应该使用中间的
集合来加速查找（将任务的时间复杂度从
O（n²）
更改为
O（n）
）：

在上面的示例中，每个匹配项都会打印出来。如果您只对是否存在此类匹配感兴趣，您可以使用：

boolean exists=list1.stream().map(toKey)
     .anyMatch(key -> list2.stream().map(toKey).anyMatch(key::equals));

或

使用java 8查找传递数组字符串的对象列表？
[法伊兹阿克兰][1]
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;
}

公立班学生{
私有字符串名称；
私人整数年龄；
公立学生（字符串名称，整数年龄）{
超级（）；
this.name=名称；
这个。年龄=年龄；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
公共整数getAge（）{
回归年龄；
}
公共无效设置（整数期限）{
这个。年龄=年龄；
}
}
//主类
导入java.util.ArrayList；
导入java.util.array；
导入java.util.List；
导入java.util.stream.collector；
公共类JavaLamda{
公共静态void main（字符串[]k）
{
列表螺柱=新的ArrayList（）；
添加（新学生（“Faiz”，1））；
增加（新学生（“迪拜”，2））；
增加（新学生（“阿克兰”，5））；
添加（新学生（“Rahul”，3））；
字符串[]名称={“Faiz”，“Akram”}；
列表显示=数组。asList（名称）
.stream（）
.flatMap（x->螺柱
.stream（）
.filter（y->x.equalsIgnoreCase（y.getName（）））
.collect（Collectors.toList（））；
系统输出打印项次（当前）；
}
}
输出//[Student@404b9385, Student@6d311334]
[1]: http://faizakram.com/blog/find-list-object-passing-string-array-using-java-8/
公共静态void main（字符串[]args）{
OTSQuestions ots=新的OTSQuestions（）；
List attrs=ots.getAttrs（）；
列表ID=新的ArrayList（）；
同上，添加（“101”）；
同上，添加（“104”）；
同上，添加（“102”）；
List finalList=attrs.stream（）.filter(
attr->ids.contains（attr.getId（）））
.collect（Collectors.toList（））；
}
公共类属性{
私有字符串id；
私有字符串名称；
公共字符串getId（）{
返回id；
}
公共无效集合id（字符串id）{
this.id=id；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
}
私有列表getAttrs（）{
List attrs=new ArrayList（）；
Attr Attr=新Attr（）；
属性设置ID（“100”）；
属性设置名称（“瑜伽”）；
属性添加（attr）；
Attr attr1=新Attr（）；
属性1.setId（“101”）；
属性1.设置名称（“Yoga1”）；
属性添加（属性1）；
Attr attr2=新Attr（）；
属性2.setId（“102”）；
属性2.设置名称（“Yoga2”）；
属性添加（属性2）；
Attr attr3=新Attr（）；
属性3.setId（“103”）；
属性3.集合名（“Yoga3”）；
属性添加（属性3）；
Attr attr4=n
list2.stream().map(toKey)
     .filter(list1.stream().map(toKey).collect(Collectors.toSet())::contains)
     .forEach(key -> System.out.println("{name="+key.get(0)+", age="+key.get(1)+"}"));

boolean exists=list1.stream().map(toKey)
     .anyMatch(key -> list2.stream().map(toKey).anyMatch(key::equals));

boolean exists=list2.stream().map(toKey)
     .anyMatch(list1.stream().map(toKey).collect(Collectors.toSet())::contains);

<h3>Find List of Object passing String of Array Using java 8?</h3>
[Faiz Akram][1]
    <pre>
    public class Student {
        private String name;
        private Integer age;
        public Student(String name, Integer age) {
            super();
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public Integer getAge() {
            return age;
        }
        public void setAge(Integer age) {
            this.age = age;
        }
    }
    </pre>
    // Main Class
    <pre>
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    public class JavaLamda {
        public static void main(String[] k)
        {
        List<Student> stud = new ArrayList<Student>();  
        stud.add(new Student("Faiz", 1));
        stud.add(new Student("Dubai", 2));
        stud.add(new Student("Akram", 5));
        stud.add(new Student("Rahul", 3));
        String[] name= {"Faiz", "Akram"};
        List<Student> present = Arrays.asList(name)
                .stream()
                .flatMap(x -> stud
                    .stream()
                    .filter(y -> x.equalsIgnoreCase(y.getName())))
                .collect(Collectors.toList());
        System.out.println(present);
        }
    }
    </pre>
    OutPut //[Student@404b9385, Student@6d311334]


  [1]: http://faizakram.com/blog/find-list-object-passing-string-array-using-java-8/

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;
}