Question

我的情况是：

.wrapper {
    width: 100%;
    display: inline-block;
    position: relative;
}
.wrapper:after {
    padding-top: 70%;
    display: block;
    content: '';
}
.main {
    position: absolute;
    top: 0;
    bottom: 0;
    right: 0;
    left: 0;
    font-size: 0;
}
#left,
#right {
    font-family: serif;
    line-height: 150%;
    font-size: 2.2vw;
    display: inline-flex;
    width: 40%;
    height: 90%;
    background-color: #edeeeb;
    padding: 5%;
}

我想知道class Person { String id ; String name; String age; } List<Person> list1 = {p1,p2, p3}; List<Person> list2 = {p4,p5, p6};中是否有人list1中的姓名和年龄相同，但不介意list2。

什么是最好，最快的方式？

Answer 1

一种简单的方法是覆盖int和equals。由于我假设hashCode之间的相等也必须考虑Person字段，因此您可以将此实例包装到id中，该PersonWrapper将实现正确的equals和hashCode （即只检查name和age字段）：

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

}

通过这样的课程，您可以拥有以下内容：

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

此代码将list2转换为包裹人员Set。拥有Set的目标是进行恒定时间contains操作以获得更好的性能。

然后，过滤list1。保留set2中的每个元素，如果剩下一个元素（也就是说，如果findFirst()返回非空Optional），则表示找到了一个元素。

Answer 2

定义一个关键对象，用于保存和比较所需的属性。在这个简单的情况下，您可以使用一个小列表，而每个索引对应一个属性。对于更复杂的情况，您可以使用Map（使用属性名称作为键）或专用类：

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

具有这样的映射功能。你可以使用简单的解决方案：

list1.stream().map(toKey)
     .flatMap(key -> list2.stream().map(toKey).filter(key::equals))
     .forEach(key -> System.out.println("{name="+key.get(0)+", age="+key.get(1)+"}"));

如果您有相当大的列表，可能会导致性能不佳。如果您有大型列表（或无法预测其大小），则应使用中间Set来加速查找（将任务的时间复杂度从O(n²)更改为O(n)）：< / p>

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

Answer 3

蛮力，但纯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用于连接2个列表。使用limit因为我们只对第一场比赛感兴趣，在这种情况下，我们不需要进一步遍历。

Answer 4

如果您不关心id字段，那么您可以使用equals方法来解决此问题。

这是Person类代码

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

现在，您可以使用流来获取交集。 common将包含Person和name相同的所有age个对象。

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

Answer 5

<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/

Answer 6

这样可行：

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 {}是一种解决方法。旁白：你在哪里得到这样的要求：）

Answer 7

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

POST /path/service.cfm HTTP/1.0
From: example@example.com
User-Agent: whatever/1.0
Content-Type: application/xml
Content-Length: 155

<?xml version="1.0"?>
<methodCall>
  <methodName>examples.getStateName</methodName>
  <params>
    <param>
        <value><i4>40</i4></value>
    </param>
  </params>
</methodCall>

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

使用java 8 stream在2个列表中查找元素匹配

8 个答案: