Java 需要对象数组列表中的映射

我从@NamedQuery JPA获得了一个对象数组列表

如何编写restinctionList.stream.collectCollectors.groupingByrestinctionList.toArray

这样我才能得到正确的结果

已分配给对象数组的原始数据为

1 - 10068   
2 - 10069   
3 - 10070   
4 - 10080   
5 - 10100   102912

6 - 10100   102273

7 - 10100   
8 - 10124   

我希望结果是一样的

Key 10068 value null
Key 10069 value null
...
...
key - 10100 value [null, 102912,102273]
....

---

你为什么不用餐车呢

List<List<Long>>   restinctionList =  Arrays.asList(Arrays.asList(10068L),
            Arrays.asList(10069L),
            Arrays.asList(10070L),
            Arrays.asList(10080L),
            Arrays.asList(10100L,102912L),
            Arrays.asList(10100L,102273L),
            Arrays.asList(10100L),
            Arrays.asList(10124L));

    Map< Long,List<Long>> countingrestinctionList =  new HashMap<>();
    restinctionList.forEach(list->{ 
        List<Long> tmpArrayList =   new ArrayList<>(list);
        if(countingrestinctionList.get(list.get(0))!=null) {
            List<Long> resultList=countingrestinctionList.get(list.get(0));
            tmpArrayList.remove(0);
            resultList.addAll(tmpArrayList);
        }else {
            tmpArrayList.set(0, null);
            countingrestinctionList.put(list.get(0),tmpArrayList ); 
        }
    });
    System.out.println(countingrestinctionList); 

---

你为什么不用餐车呢

List<List<Long>>   restinctionList =  Arrays.asList(Arrays.asList(10068L),
            Arrays.asList(10069L),
            Arrays.asList(10070L),
            Arrays.asList(10080L),
            Arrays.asList(10100L,102912L),
            Arrays.asList(10100L,102273L),
            Arrays.asList(10100L),
            Arrays.asList(10124L));

    Map< Long,List<Long>> countingrestinctionList =  new HashMap<>();
    restinctionList.forEach(list->{ 
        List<Long> tmpArrayList =   new ArrayList<>(list);
        if(countingrestinctionList.get(list.get(0))!=null) {
            List<Long> resultList=countingrestinctionList.get(list.get(0));
            tmpArrayList.remove(0);
            resultList.addAll(tmpArrayList);
        }else {
            tmpArrayList.set(0, null);
            countingrestinctionList.put(list.get(0),tmpArrayList ); 
        }
    });
    System.out.println(countingrestinctionList); 

---

下面是一个使用单流语句的版本

    public static void main(String[] args) {
        List<Object[]> restinctionList = Arrays.asList(
                new Object[]{10068L},
                new Object[]{10069L},
                new Object[]{10070L},
                new Object[]{10080L},
                new Object[]{10100L, 102912L},
                new Object[]{10100L, 102273L},
                new Object[]{10100L},
                new Object[]{10124L}
                );
        Map<Object, ArrayList<Object>> result = restinctionList
                .stream()
                .collect(Collectors.groupingBy(
                        (Object[] e) -> e[0],
                        Collector.of(
                                () -> {ArrayList<Object> e = new ArrayList<>(); e.add(null); return e;},
                                (ArrayList<Object> l, Object[] e) -> {if(e.length > 1){l.add(e[1]);}},
                                (ArrayList<Object> a, ArrayList<Object> b) -> {a.addAll(b); return a;})
                ))
                ;

        result.entrySet().stream().forEach(System.out::println);
    }

---

下面是一个使用单流语句的版本

    public static void main(String[] args) {
        List<Object[]> restinctionList = Arrays.asList(
                new Object[]{10068L},
                new Object[]{10069L},
                new Object[]{10070L},
                new Object[]{10080L},
                new Object[]{10100L, 102912L},
                new Object[]{10100L, 102273L},
                new Object[]{10100L},
                new Object[]{10124L}
                );
        Map<Object, ArrayList<Object>> result = restinctionList
                .stream()
                .collect(Collectors.groupingBy(
                        (Object[] e) -> e[0],
                        Collector.of(
                                () -> {ArrayList<Object> e = new ArrayList<>(); e.add(null); return e;},
                                (ArrayList<Object> l, Object[] e) -> {if(e.length > 1){l.add(e[1]);}},
                                (ArrayList<Object> a, ArrayList<Object> b) -> {a.addAll(b); return a;})
                ))
                ;

        result.entrySet().stream().forEach(System.out::println);
    }

---

我找到了我问题的答案

package test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestListObjectArray {

public static void main(String[] args) {
    Object[] obj = { 42628, 567898 };
    Object[] obj1 = { 426238, 5674898 };
    Object[] obj2 = { 42621, 5678498 };
    Object[] obj3 = { 42627, 5678698 };
    Object[] obj4 = { 42627, };
    Object[] obj5 = { 42627, 1000 };

    List<Object[]> listObjectArr = new ArrayList<>();
    listObjectArr.add(obj);
    listObjectArr.add(obj1);
    listObjectArr.add(obj2);
    listObjectArr.add(obj3);
    listObjectArr.add(obj4);
    listObjectArr.add(obj5);

    Map<Object, List<Object>> ObjectMap = new HashMap<>();
    List<Object[]> restinctionList = new ArrayList<>();

    List<List<?>> restinctionDummyList = new ArrayList<>();
    for (Object[] resArr : listObjectArr) {
        List<Object> targetList = Arrays.asList(resArr);
        restinctionDummyList.add(targetList);
    }
    restinctionDummyList.forEach(list -> {
        List<Object> tmpArrayList = new ArrayList<>(list);
        if (ObjectMap.get(list.get(0)) != null) {
            List<Object> resultList = ObjectMap.get(list.get(0));
            tmpArrayList.remove(0);
            resultList.addAll(tmpArrayList);
        } else {
            ObjectMap.put(list.get(0), tmpArrayList);           
        }
    });

    System.out.println(ObjectMap);
}
}

---

我找到了我问题的答案

package test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestListObjectArray {

public static void main(String[] args) {
    Object[] obj = { 42628, 567898 };
    Object[] obj1 = { 426238, 5674898 };
    Object[] obj2 = { 42621, 5678498 };
    Object[] obj3 = { 42627, 5678698 };
    Object[] obj4 = { 42627, };
    Object[] obj5 = { 42627, 1000 };

    List<Object[]> listObjectArr = new ArrayList<>();
    listObjectArr.add(obj);
    listObjectArr.add(obj1);
    listObjectArr.add(obj2);
    listObjectArr.add(obj3);
    listObjectArr.add(obj4);
    listObjectArr.add(obj5);

    Map<Object, List<Object>> ObjectMap = new HashMap<>();
    List<Object[]> restinctionList = new ArrayList<>();

    List<List<?>> restinctionDummyList = new ArrayList<>();
    for (Object[] resArr : listObjectArr) {
        List<Object> targetList = Arrays.asList(resArr);
        restinctionDummyList.add(targetList);
    }
    restinctionDummyList.forEach(list -> {
        List<Object> tmpArrayList = new ArrayList<>(list);
        if (ObjectMap.get(list.get(0)) != null) {
            List<Object> resultList = ObjectMap.get(list.get(0));
            tmpArrayList.remove(0);
            resultList.addAll(tmpArrayList);
        } else {
            ObjectMap.put(list.get(0), tmpArrayList);           
        }
    });

    System.out.println(ObjectMap);
}
}

如果您想使用groupingBy，可以这样做：

private Map<Long, List<Long>> getMapGroupingBy(List<Object[]> list) {
    Map<Long, List<Long>> map2 = new HashMap<>();
    map2 = list.stream().collect(Collectors.groupingBy(obs -> (Long)obs[0], Collectors.mapping(obs -> (obs.length>1?(Long)obs[1]:null), Collectors.toList())));
    return map2;
}

如果打印地图，您会得到如下结果：

{1234=[123, null, 678], 1223=[null], 1225=[345]}

您的输入列表应如下所示：

private Map<Long, List<Long>> getMapForEach(List<Object[]> list) {
    Map<Long, List<Long>> map = new HashMap<>();
    list.stream().forEach(obs -> {
        map.computeIfAbsent((Long)obs[0], a -> new ArrayList<Long>()).add(obs.length>1?(Long)obs[1]:null);
    });
    return map;
}

List<Object[]> list = new ArrayList<>();
list.add(new Object[] {1234l,123l});
list.add(new Object[] {1234l});
list.add(new Object[] {1234l,678l});
list.add(new Object[] {1223l});
list.add(new Object[] {1225l,345l});

如果您想使用groupingBy，可以这样做：

private Map<Long, List<Long>> getMapGroupingBy(List<Object[]> list) {
    Map<Long, List<Long>> map2 = new HashMap<>();
    map2 = list.stream().collect(Collectors.groupingBy(obs -> (Long)obs[0], Collectors.mapping(obs -> (obs.length>1?(Long)obs[1]:null), Collectors.toList())));
    return map2;
}

如果打印地图，您会得到如下结果：

{1234=[123, null, 678], 1223=[null], 1225=[345]}

您的输入列表应如下所示：

private Map<Long, List<Long>> getMapForEach(List<Object[]> list) {
    Map<Long, List<Long>> map = new HashMap<>();
    list.stream().forEach(obs -> {
        map.computeIfAbsent((Long)obs[0], a -> new ArrayList<Long>()).add(obs.length>1?(Long)obs[1]:null);
    });
    return map;
}

List<Object[]> list = new ArrayList<>();
list.add(new Object[] {1234l,123l});
list.add(new Object[] {1234l});
list.add(new Object[] {1234l,678l});
list.add(new Object[] {1223l});
list.add(new Object[] {1225l,345l});

---

您的问题不清楚您想要什么作为地图中的键？在您的问题中，您说的是对象[0]，但这里您说的是对象[1]。另外，如果两个数组的第一个值相同，会发生什么情况？其他数字是否会以某种方式组合在一起？您是否希望将列表展平？是的，对象[0]是关键，我错把对象[1]写成了关键对象，因为在对象[0]的基础上，关键对象[0]是关键我想将列表分组到mapIt您的问题中不清楚您想要什么作为地图中的键？在您的问题中，您说的是对象[0]，但这里您说的是对象[1]。另外，如果两个数组的第一个值相同，会发生什么情况？其他数字是否会以某种方式组合在一起？您是否希望将列表展平？是的，对象[0]是键，由于错误，我已将对象[1]写入键对象[0]，因为键对象[0]是键，基于对象[0]，我希望将列表分组到maptmpArrayList.set0，null；不是必需的，如果我们添加，那么结果将是{10080=[null，null]，10068=[null，null]，10100=[null，null，10124]，我不明白为什么应该这样做。集合只是用nulltmpArrayList.set0，null替换索引0处的值；不是必需的，如果我们添加，那么结果将是{10080=[null，null]，10068=[null，null]，10100=[null，null，10124]，我不明白为什么会这样。集合只是用null替换索引0处的值。我使用了Novy先生的部分代码。感谢Novy在你的问题中提到，你希望在结果中使用null。我使用了Novy先生的部分代码。感谢Novy在你的问题中提到，你希望在结果中使用null。