Grouper les éléments d'une liste et additionner tous les autres champs Android, afficher le résultat dans la vue recyclerview

Question

J'ai une base de données Firebase qui a la structure suivante

{
  "foo" : {
    "data" : {
      "2019-12-01" : [ {
        "item1" : 8,
        "item2" : 16,
        "name" : "user1"
      }, {
        "item1" : 9,
        "item2" : 18,
        "name" : "user2"
      } ],
      "2019-12-02" : [ {
        "item1" : 2,
        "item2" : 26,
        "name" : "user1"
      }, {
        "item1" : 6,
        "item2" : 6,
        "name" : "user2"
      } ]
    }
  }
}

Je remplis un recyclerviewer dans l'activité principale de manière très simple :

public class MainActivity extends AppCompatActivity {

    RecyclerView recyclerView;

    private RecyclerView.LayoutManager layoutManager;
    private Adapter adapter;

    final List<Model> tempList = new ArrayList<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        recyclerView = findViewById(R.id.simpleRecycler);

        layoutManager = new LinearLayoutManager(this);
        recyclerView.setLayoutManager(layoutManager);
        recyclerView.setHasFixedSize(true);

        Query statsRef = FirebaseDatabase.getInstance()
                .getReference("foo")
                .child("data")
                .orderByKey()
                .startAt("2019-12-01")
                .endAt("2019-12-02");

        // Read from the database
        statsRef.addValueEventListener(new ValueEventListener() {
            @RequiresApi(api = Build.VERSION_CODES.N)
            @Override
            public void onDataChange(@NonNull DataSnapshot dataSnapshot) {

                for (DataSnapshot itemSnapshot : dataSnapshot.getChildren()){
                    for (int i = 0; i < 2; i++) {
                        Model model = itemSnapshot.child(String.valueOf(i)).getValue(Model.class);
                        tempList.add(model);
                    }
                }

                adapter = new Adapter(tempList);
                recyclerView.setAdapter(adapter);
            }

            @Override
            public void onCancelled(@NonNull DatabaseError databaseError) {
            }
        });
    }
}

Et l'adaptateur est :

public class Adapter extends RecyclerView.Adapter {

    List<Model> models;

    public Adapter(List<Model> models) {
        this.models = models;
    }

    @NonNull
    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        View itemView = LayoutInflater.from(parent.getContext()).inflate(R.layout.simple_row, parent, false);

        return new ViewHolder(itemView);
    }

    @Override
    public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
        ViewHolder vh = (ViewHolder)holder;

        vh.name.setText(models.get(position).getName());
        vh.item1.setText(String.valueOf(models.get(position).getItem1()));
        vh.item2.setText(String.valueOf(models.get(position).getItem2()));
    }

    @Override
    public int getItemCount() {
        return models.size();
    }
}

Le résultat est un tableau comme celui-ci :

+-------+---+----+
| user1 | 8 | 16 |
+-------+---+----+
| user2 | 9 | 18 |
+-------+---+----+
| user1 | 2 | 26 |
+-------+---+----+
| user2 | 6 |  6 |
+-------+---+----+

Le problème est que je veux grouper la liste par le nom et ensuite faire la somme de tous les autres champs relatifs comme ci-dessous

+-------+----+----+
| user1 | 10 | 42 |
+-------+----+----+
| user2 | 15 | 24 |
+-------+----+----+

J'ai essayé sans succès :

tempList.stream().collect(Collectors.groupingBy(Model::getName))
                    .entrySet().stream()
                    .collect(Collectors.toMap(x -> {
                        int item1 = x.getValue().stream().mapToInt(Model::getItem1).sum();
                        int item2 = x.getValue().stream().mapToInt(Model::getItem2).sum();

                        return new Model(x.getKey(), item1, item2);

                    }, Map.Entry::getValue));

J'ai ajouté le code ci-dessus avant de définir l'adaptateur pour le visualiseur de recyclage.

De l'aide, s'il vous plaît ?

Answer 1

Vous pouvez utiliser un Collectors.toMap à l'aide d'un mergeFunction définie pour effectuer l'agrégation, comme par exemple :

List<Model> output = new ArrayList<>(tempList.stream()
        .collect(Collectors.toMap(Model::getName, Function.identity(),
                Model::mergeSimilarNames))
        .values()); // interested in merged output 

où la fonction de fusion pourrait être définie à l'intérieur de Model classe en tant que :

static Model mergeSimilarNames(Model one, Model two) {
    return new Model(one.getName(), one.getItem1() + two.getItem1(), one.getItem2() + two.getItem2());
}

---

Pour faire le lien avec votre approche existante, vous devez effectuer une opération de réduction après avoir regroupé les éléments, par exemple :

Map<String, Optional<Model>> grouping = tempList.stream()
        .collect(Collectors.groupingBy(Model::getName,
                Collectors.reducing(Model::mergeSimilarNames)));

Mais dans ce cas, vous n'êtes intéressé que par l'obtention de la vue finale, comme le montre le tableau de bord. List<Model> parmi la valeur de ci-dessus Map Dans ce cas, votre code résultant sera donc :

List<Model> output = tempList.stream()
        .collect(Collectors.groupingBy(Model::getName,
                Collectors.reducing(Model::mergeSimilarNames)))
        .values().stream()
        .filter(Optional::isPresent)
        .map(Optional::get)
        .collect(Collectors.toList());

Mais attention, toMap(f1,f2,f3) est préféré à groupingBy(f1, reducing(f2,f3)) .