Java8 利用stream求两个LIst<Object>的交集并赋值

Question

有两个LIst<Bean>,
比如Bean1中包含prjId,prjManagerName,prjStatus,Bean2中包含prjId,prjManagerName,prjStatus
求LIst1<Bean1>中prjId和List2<Bean2>中prjId相同的，并把Bean2中的prjManagerName,prjStatus赋给Bean1
我自己想了想，不想用双重for循环，这样太麻烦了，时间复杂度太高，打算用stream来处理，但是这个流处理我用的很少，综合了一下百度出来的结果，目前代码是：
 list.stream().filter(Bean1-> find(Bean1.getPrjId(), list2) > -1)
.map(这个里面怎么写不太懂了)
.collect(Collectors.toList());
自己实现了一个find方法如下：private int find(String prjId, List<Bean2> list){
    int res = -1;
    for(int i = 0; i < list.size(); i ++){
        if (prjId.equals(list.get(i).getPrjId())){
        res = i;
        break;
        }
    }
    return res;
}求各位大佬给个答案，不胜感激

Answer 1

换工具类又不会降低复杂度，你缺的是算法。
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;public class Test93 {

public static void main(String[] args) {
List<Test93Bean> l1 = new ArrayList();
l1.add(new Test93Bean("1", "a1"));
l1.add(new Test93Bean("2", "a2"));

List<Test93Bean> l2 = new ArrayList();
l2.add(new Test93Bean("1", "b1"));
l2.add(new Test93Bean("3", "b2"));

Map<String, Test93Bean> map = new HashMap();
for(Test93Bean temp: l1){
map.put(temp.a, temp);
}

for(Test93Bean temp: l2){
if(map.containsKey(temp.a)){
Test93Bean ta = map.get(temp.a);
ta.b = temp.b;
}
}

System.out.println(new ArrayList(map.values()));
}

static class Test93Bean{

public Test93Bean(String a, String b) {
super();
this.a = a;
this.b = b;
}
private String a;
private String b;
@Override
public String toString() {
return "Test93Bean [a=" + a + ", b=" + b + "]";
}

}

}
复杂度 n+m

Answer 2

你这个算法我考虑过，用map的特性做缓存，以前我也这么实现过，可是针对id不唯一的情况，这种方法并不是太好。我觉得用stream肯定是可以最快最简单的实现的可是现在我还没成功所以特意来求问

Answer 3

这样？  class User {    public User(Integer id, String name) {        this.id = id;
        this.name = name;
    }    private Integer id;    private String name;    public Integer getId() {
        return id;
    }    public void setId(Integer id) {
        this.id = id;
    }    public String getName() {
        return name;
    }    public void setName(String name) {
        this.name = name;
    }
}public class Demo {
    private static User find(Integer id, List<User> list){
     
        for(int i = 0; i < list.size(); i ++){
            if (id.equals(list.get(i).getId())){
                return list.get(i);
            }
        }
    }    public static void main(String[] args) {
        List<User> list1 = Arrays.asList(new User(1, "小明"), new User(2, "小花"), new User(3, "小华"));        List<User> list2 = Arrays.asList(new User(1, "小明2"), new User(2, "小花2"), new User(3, "小华2"));        List<User> result = list1.stream().map(user ->{
           
            User u = find(user.getId(), list2);
            user.setName(u.getName());
            return user;
        }).collect(Collectors.toList());
      
    }
    
}
这也挺垃圾的啊

Answer 4

class User {    public User(Integer id, String name) {        this.id = id;
        this.name = name;
    }    private Integer id;    private String name;    public Integer getId() {
        return id;
    }    public void setId(Integer id) {
        this.id = id;
    }    public String getName() {
        return name;
    }    public void setName(String name) {
        this.name = name;
    }
}public class Demo {
    private static User find(Integer id, List<User> list) {        User user = null;
        
        for (int i = 0; i < list.size(); i++) {
            if (id.equals(list.get(i).getId())) {
                user = list.get(i);
            }
        }
        return user;
    }    public static void main(String[] args) {
        List<User> list1 = Arrays.asList(new User(1, "小明"), new User(2, "小花"), new User(3, "小华"));        List<User> list2 = Arrays.asList(new User(1, "小明2"), new User(2, "小花2"), new User(3, "小华2"));        List<User> result = list1.stream().map(user ->{            User u = find(user.getId(), list2);
            if(null != u){
                user.setName(u.getName());
            }
            return user;
        }).collect(Collectors.toList());    }}
上边的有问题

Answer 5

class User {    public User(Integer id, String name) {        this.id = id;
        this.name = name;
    }    private Integer id;    private String name;    public Integer getId() {
        return id;
    }    public void setId(Integer id) {
        this.id = id;
    }    public String getName() {
        return name;
    }    public void setName(String name) {
        this.name = name;
    }    @Override
    public String toString() {
        return "id =" + id + ", name = " + name;
    }
}public class Demo {
    private static User find(Integer id, List<User> list) {        User user = null;        for (int i = 0; i < list.size(); i++) {
            if (id.equals(list.get(i).getId())) {
                user = list.get(i);
            }
        }
        return user;
    }    public static void main(String[] args) {
        List<User> list1 = Arrays.asList(new User(1, "小明"), new User(2, "小花"), new User(3, "小华"), new User(4, "小东"));        List<User> list2 = Arrays.asList(new User(1, "小明2"), new User(2, "小花2"), new User(3, "小华2"));        List<User> result = list1.parallelStream().map( user ->{            User user1 = list2.stream().filter(u -> u.getId().equals(user.getId())).findFirst().orElse(null);
            if(null != user1){
                user.setName(user1.getName());
            }
            return user;
        }).collect(Collectors.toList());        System.out.println(result);
    }}这样也ok

Answer 6

LIst1<Bean1> bean1List=new ArrayList<Bean1>();
LIst1<Bean2> bean2List=new ArrayList<Bean2>();
 Map<String, List<Bean2>> stringListMap = bean2List.stream().collect(Collectors.groupingBy(bean2List::getPrjId));//把prjId分组
        bean1List.stream().forEach(e -> {
//加你想加的判断
            Bean2 item = stringListMap.get(e.getPrjId()).get(0);
            e.setBean2(item);        });

Answer 7

   
public void test1(){
        List<Integer> list1=new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);        List<Integer> list2=new ArrayList<>();
        list2.add(3);
        list2.add(4);
        list2.add(5);        System.out.println("====求交集===");        List<Integer> list=list1.stream().filter(t->list2.contains(t)).collect(Collectors.toList());
        list.stream().forEach(System.out::println);
        System.out.println("====求差集===");
        list=list1.stream().filter(t-> !list2.contains(t)).collect(Collectors.toList());
        list.stream().forEach(System.out::println);
        System.out.println("====求并集===");        list.addAll(list1);
        list.addAll(list2);
        list=list.stream().distinct().collect(Collectors.toList());
        list.stream().forEach(System.out::println);
    }来源于：https://www.cnblogs.com/sword-successful/archive/2017/12/05/7989035.html

Answer 8

map.get(temp.a)实际上里面的实现就是一个for循环，所以你这个复杂度还是nm。

Answer 9

map.get(temp.a)实际上里面的实现就是一个for循环，所以你这个复杂度还是nm。HashMap源码
    final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }        int hash = (key == null) ? 0 : hash(key);
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }
最坏情况确实相当于循环，最好是n+m，实际上是比较接近n+m的。但是你算复杂度总不能用最坏情况吧