Java 8：从2个列表中迭代并创建映射

Question

我有一个a类和B类的列表，没有重复的元素。“代码”属性在A类和B类中都是相同的。我想将它们转换为Map

public class A {
    private String code;
    private boolean status;
    field 3...
    field 4..

 
}

public class B {
    private String code;
    private String location;
    field 5...
    field 5..
}

public class C {
    private String location;
    private boolean status;
}

List1 : [A(code=NY, status=false), A(code=NJ, status=true),A(code=TX, status=true), A(code=NM, status=false)]

List2 : [B(code=NY, location=NewYork), B(code=NJ, location=NewJersey),B( code=TX, location=Texas), B(code=NM, location=NewMexico)]

Map =  map{NY=C(location=NewYork, status=false), NJ=C(location=NewJersey, status=true), TX=C(location=Texas, status=true),NM=C(location=NewMexico, status=false)}

最终映射的顺序应与列表1中的元素相同

~A

更新：我将代码更新到下面，但它不是编译的。你知道怎么了吗？

package test;

import java.util.*;
import java.util.stream.Collectors;

public class Test {

    static void main(String[] args){


        new Test().testFunction();

    }

      void testFunction(){


        System.out.println("Hello World");



        List<A> listA = Arrays.asList(new A("NY", false), new A("NJ", true), new A("TX", false), new A("AZ", true));
        List<B> listB = Arrays.asList(new B("NY", "New York"), new B("NJ", "New Jersey"),
                new B("TX", "Texas"), new B("NM", "New Mexico"));


        Map<String, B> mapB = listB
                .stream()
                .collect(Collectors.toMap(B::getCode, b -> b, (b1, b2) -> b1));

        Map<String, C> innerJoin = listA
                .stream()
                .filter(a -> mapB.containsKey(a.getCode())) // make sure a B instance exists with the code
                .map(a -> Map.entry(a.getCode(), new C(mapB.get(a.getCode()).getLocation(), a.getStatus())))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (c1, c2) -> c1, HashMap::new));

        innerJoin.forEach((code, c) -> System.out.println(code + " -> " + c));

    }

}


     class A {
        private String code;
        private boolean status;

         public A(String code, boolean status) {
             this.code = code;
             this.status = status;
         }
         public String getCode() {
             return this.code;
         }
         public boolean getStatus() {
             return this.status;
         }
     }

     class B {
        private String code;
        private String location;

         public B(String code, String location) {
             this.code = code;
             this.location = location;
         }

         public String getCode() {
             return this.code;
         }
         public String getLocation() {
             return this.location;
         }
     }

     class C {
        private String location;
        private boolean status;

         public C(String location, boolean status) {
             this.location = location;
             this.status = status;
         }
         public String getLocation() {
             return this.location;
         }
         public boolean getStatus() {
             return this.status;
         }
    }

Answer 1

这个任务似乎是通过一个键属性连接两个对象列表。考虑到需求，它应该像内连接一样借助从listB创建的临时映射。

Map<String, B> mapB = listB
        .stream()
        .(Collectors.toMap(B::getCode, b -> b, (b1, b2) -> b1)); // use merge function as a defense measure

Map<String, C> innerJoin = listA
        .stream()
        .filter(a -> mapB.containsKey(a.getCode())) // make sure a B instance exists with the code
        .map(a -> Map.entry(a.getCode(), new C(mapB.get(a.getCode()).getLocation(), a.isStatus())))
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (c1, c2) -> c1, LinkedHashMap::new));

测试：

List<A> listA = Arrays.asList(new A("NY", false), new A("NJ", true), new A("TX", false), new A("AZ", true));
List<B> listB = Arrays.asList(new B("NY", "New York"), new B("NJ", "New Jersey"), new B("TX", "Texas"), new B("NM", "New Mexico"));

// ...
innerJoin.forEach((code, c) -> System.out.println(code + " -> " + c));

输出：

NY -> C(location=New York, status=false)
NJ -> C(location=New Jersey, status=true)
TX -> C(location=Texas, status=false)

“最简单”的解决方案可能基于这样的假设，即两个列表中的项目由相同的code字段“排序”，那么不需要临时映射：

Map<String, C> simple = IntStream
        .range(0, listA.size())
        .mapToObj(i -> Map.entry(listA.get(i).getCode(), new C(listB.get(i).getLocation(), listA.get(i).isStatus())))
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (c1, c2) -> c1, LinkedHashMap::new));

然而，这样的解决方案太脆弱了。

Answer 2

java prettyprint-override">Map<String, C> map = IntStream.range(0, list1.size())
    .mapToObj(i -> new CodeIndex(list1.get(i).code(), i))
    .collect(Collectors.toMap(
        CodeIndex::code,
        ci -> new C(list2.get(ci.index()).location(), list1.get(ci.index()).status()),
        (a, b) -> a,
        LinkedHashMap::new
    ));

我们首先获取两个列表的所有有效索引，然后映射到一个（自定义）容器类，其中包含索引和代码。（我称之为CodeIndex，但您也可以使用Map.Entry或一些Pair类。）

最后，我们将其收集到一个LinkedHashMap（因为它保留了插入顺序），将键映射到简单的CodeIndex:：code，并将值映射到新的C（«location\u from_list2»，«status\u from_list1»）。

请注意，此代码遍历列表一次。

当然，这是假设：

• 两个列表具有相同的代码；
• list1和list2的所有代码顺序相同。

请注意，我使用了记录样式的getter，即与相应字段名同名的getter。例如，location（）而不是getLocation（）。

Answer 3

你应该使用这样的东西：

Map<String, B> mapList2 = list2.stream().collect(Collectors.toMap(B::getCode, 
    Function.identity()); // create temporary map

Map<String,B> result = list1.stream().collect(
            LinkedHashMap::new,
            (map, a) -> map.put(
                   a.getCode(), // get code from A
                   new C(
                           mapList2.get(a.getCode()).getLocation() // get location from B
                           a.getStatus() // get status from A
                   ),  
             Map::putAll); // use LinkedHashMap to keep order