1
votes

Besoin d'une carte de la liste à partir du tableau d'objets

Je reçois une liste de tableaux d'objets de @NamedQuery (JPA)

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

Le tableau d'objets contenant deux valeurs Long exemple: Object [] = {12345L, 34533L}

je veux regrouper la liste (restinctionList) en fonction de la clé Object [0] comme

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

6 - 10100   102273

7 - 10100   
8 - 10124

Comment puis-je écrire le "restinctionList.stream (). collect (Collectors.groupingBy (restinctionList.toArray ()));"

pour que je puisse obtenir un résultat correct

Les données brutes qui ont été attribuées au tableau Object sont

Map<Long, List<Long>> groupList = restinctionList.stream().collect(Collectors.groupingBy());

Je veux que le résultat soit

List<Object[]> restinctionList = (List<Object[]> ) 
em.createNamedQuery("DocqryRestriction.getAllAdmnAndER").getResultList();

java arrays jpa java-8 grouping

7 commentaires

Il n'est pas clair d'après votre question ce que vous voulez comme clé dans votre carte?

Pouvez-vous donner quelques exemples de vos données et comment vous vous attendez à ce que la Carte en résulte?

Dans votre question, vous avez dit Object [0] mais ici vous dites Object [1] . Que se passe-t-il également si 2 tableaux ont la même première valeur? Le reste des nombres sera-t-il en quelque sorte regroupé?

Oh, j'ai manqué que vous ayez mentionné une clé dans votre question. Je pense que vous feriez mieux de clarifier votre question avec quelques exemples de données et le résultat attendu.

Y a-t-il une chance que vous souhaitiez que vous aplatissiez votre liste?

oui L'objet [0] est la clé, par erreur j'ai écrit Object [1] comme clé

L'objet [0] est la clé, sur la base de l'objet [0] je veux regrouper la liste à mapper

4 Réponses :

2
votes

pourquoi n'utilisez-vous pas un forEach

{10080=[null], 10068=[null], 10100=[null, 102912, 102273], 10069=[null], 10070=[null], 10124=[null]}

Réponse:

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

2 commentaires

tmpArrayList.set (0, null); n'est pas obligatoire, si nous ajoutons alors le résultat sera {10080 = [null, null], 10068 = [null, null], 10100 = [null, null, 10124],

Je ne vois pas pourquoi ça devrait. Le "set" remplace simplement la valeur à l'index 0 par null

2
votes

Voici une version utilisant une seule instruction stream

10080=[null]
10100=[null, 102912, 102273]
10068=[null]
10069=[null]
10070=[null]
10124=[null]

qui donne en sortie

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

0 commentaires

1
votes

J'ai trouvé la réponse à ma question sous la forme

{42627=[42627, 5678698, 1000], 42628=[42628, 567898], 426238=[426238, 5674898], 42621=[2621, 5678498]}

Sortie sur console

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

2 commentaires

J'ai utilisé une partie du code de M. Novy. Merci Novy

Dans votre question, vous avez mentionné que vous vouliez avoir null dans le résultat.

2
votes

Eh bien, si vous souhaitez utiliser groupingBy , vous pouvez le faire:

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

Si vous êtes plutôt destiné à obtenir le résultat, et non à utiliser groupingBy () , vous pouvez faire comme ceci:

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

Si vous imprimez la carte , vous obtenez quelque chose comme ceci:

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

Votre liste de saisie doit ressembler à ceci:

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

0 commentaires