Java 8如何从两个集合中筛选不同的实体？

我想使用Java 8流过滤器集合，但我发现所有示例都是一个集合，Java 6是：

public class User {
public Long id;
public String name;

public User(Long id, String name) {
    this.id = id;
    this.name = name;
}

   List<User> usersA = new ArrayList<>();

    usersA.add(new User(1l,"A"));
    usersA.add(new User(2l,"B"));
    usersA.add(new User(3l,"C"));

    List<User> usersB = new ArrayList<>();
    usersB.add(new User(33l,"A"));
    usersB.add(new User(34l,"B"));
    usersB.add(new User(35l,"D"));
    usersB.add(new User(36l,"C"));

    List<User> tempUser = new ArrayList<>();
    tempUser.addAll(usersB);

    for (User user : usersA) {
        for (User user1 : tempUser) {
            System.out.println(user1.getName().equalsIgnoreCase(user.getName()));
            if (user1.getName().equalsIgnoreCase(user.getName())){
                System.out.println("remove:"+user1.getName());
                tempUser.remove(user1);
                break;
            }
        }

    }

    System.out.println("last:"+tempUser);

公共类用户{
公共长id；
公共字符串名称；
公共用户（长id、字符串名称）{
this.id=id；
this.name=名称；
}
List usersA=new ArrayList（）；
添加（新用户（1l，“A”）；
添加（新用户（2l，“B”）；
添加（新用户（3l，“C”）；
List usersB=new ArrayList（）；
用户SB添加（新用户（33l，“A”）；
用户SB添加（新用户（34l，“B”）；
用户SB添加（新用户（35l，“D”）；
用户SB添加（新用户（36l，“C”）；
List tempUser=new ArrayList（）；
tempUser.addAll（usersB）；
for（用户：usersA）{
for（用户user1:tempUser）{
System.out.println（user1.getName（）.equalsIgnoreCase（user.getName（））；
if（user1.getName（）.equalsIgnoreCase（user.getName（）））{
System.out.println（“删除：+user1.getName（））；
tempUser.remove（user1）；
打破
}
}
}
System.out.println（“last:+tempUser”）；

---

Java 8我想使用stream api而不是use foreach，你能举个例子吗？谢谢

所以，如果我理解正确，你想创建一个新列表，包含

usersB

的所有用户，除了那些与

usersA

中的任何用户同名的用户，对吗

首先，我要改变策略：不是先添加所有用户，然后删除一些用户，而是首先添加属于列表的用户

在Java8中，这可以通过

List<User> result = 
    usersB.stream()
          .filter(u -> !userNameIn(u, usersA))
          .collect(Collectors.toList());

如果

usersA

包含大量用户，这将不是很有效。更有效的解决方案是将

usersA

的所有小写名称存储在哈希集中，并用

List<User> result = 
    usersB.stream()
          .filter(u -> !lowercaseNames.contains(u.getName().toLowerCase()))
          .collect(Collectors.toList());

列表结果=
usersB.stream（）
.filter（u->！lowercaseNames.contains（u.getName（）.toLowerCase（）））
.collect（Collectors.toList（））；

在java 8中，这可以在没有任何流的情况下完成，在以前的java版本中甚至更好

允许您删除一个集合中位于另一个集合中的所有项。对于调用者，这是一个一行程序

userB.removeAll（userA）

---

当集合的对象实现

等于
时，这是正确的。您应该避免像处理嵌套循环那样使用线性搜索进行重复查找。当集合增长时，这可能会导致性能灾难

首先，将第一个集合的名称收集到支持所需查找的
集合中：

Set<String> namesInA=usersA.stream().map(User::getName)
    .collect(Collectors.toCollection(() -> new TreeSet<>(String.CASE_INSENSITIVE_ORDER)));

Set namesInA=usersA.stream（）.map（User:：getName）
.collect（collector.toCollection（（）->new TreeSet（String.CASE不区分大小写\顺序））；

然后，您可以使用以下两种方式之一执行操作：

在集合中放置：

List<User> tempUser = new ArrayList<>(usersB);
tempUser.removeIf(u -> namesInA.contains(u.getName()));

List<User> tempUser = usersB.stream()
    .filter(u->!namesInA.contains(u.getName()))
    .collect(Collectors.toList());

List tempUser=newarraylist（usersB）；
tempUser.removeIf（u->namesInA.contains（u.getName（））；

使用流API将匹配元素收集到新集合中：

List<User> tempUser = new ArrayList<>(usersB);
tempUser.removeIf(u -> namesInA.contains(u.getName()));

List<User> tempUser = usersB.stream()
    .filter(u->!namesInA.contains(u.getName()))
    .collect(Collectors.toList());

List tempUser=usersB.stream（）
.filter（u->！namesInA.contains（u.getName（）））
.collect（Collectors.toList（））；

我会这样做：

public static class User {
    public Long id;
    public String name;

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }
}
public static void main(String[] args){


    List<User> usersA = new ArrayList<>();

    usersA.add(new User(1l,"A"));
    usersA.add(new User(2l,"B"));
    usersA.add(new User(3l,"C"));

    List<User> usersB = new ArrayList<>();
    usersB.add(new User(33l,"A"));
    usersB.add(new User(34l,"B"));
    usersB.add(new User(35l,"D"));
    usersB.add(new User(36l,"C"));

    List<User> list = usersB.stream()
                    .filter(userb -> !usersA.stream().
                                    filter(usera -> usera.name.equalsIgnoreCase(userb.name)).findFirst().isPresent())
                    .collect(Collectors.toList());

}

公共静态类用户{
公共长id；
公共字符串名称；
公共用户（长id、字符串名称）{
this.id=id；
this.name=名称；
}
}
公共静态void main（字符串[]args）{
List usersA=new ArrayList（）；
添加（新用户（1l，“A”）；
添加（新用户（2l，“B”）；
添加（新用户（3l，“C”）；
List usersB=new ArrayList（）；
用户SB添加（新用户（33l，“A”）；
用户SB添加（新用户（34l，“B”）；
用户SB添加（新用户（35l，“D”）；
用户SB添加（新用户（36l，“C”）；
List List=usersB.stream（）
.filter（userb->！usersA.stream（）。
过滤器（usera->usera.name.equalsIgnoreCase（userb.name））.findFirst（）.isPresent（））
.collect（Collectors.toList（））；
}