Parcourt de listes imbriquées

Bonjour,

je ne sais pas quels mot clefs chercher, j'espère que la question n'a pas déjà été posée (désolé sinon).
J'aurais besoin de votre aide, parce que j’ai le problème suivant :
Je veux enregistrer des informations structurés de cette manière :
- pour chaque identifiant (ex : id_client), j’ai une liste d’un type d’information (ex : td = l’horodatage de la première action du client), et pour chacune de ces premières actions, j’ai une nouvelle liste d’information (ex : tf = horodatage de la dernière action du client).

Pour chaque id_client, j’ai un/plusieurs horodatage de début td et pour chaque td, j’ai un/plusieurs horodatage de fin tf :
Pièce jointe 508790


Pour coder ça, j’avais au début créé trois listes distinctes

Code:

---

1 2 3

List<Integer> id_cl ; List<List<Double>> td ; List<List<List<Double>>> tf.

---

Mais c’était pas super pratique pour traiter les cas par exemple, où je veux supprimer un client (faut détecter quelles td correspondent à l’id_cl etc.
à la place, j’ai créé deux objets Client et TimeInfo, avec :

Code:

---

1 2	List<Client> clients ; avec*: Client{int id_cl ; List<TimeInfo> time} ; avec : TimeInfo{double td ; List<Double> tf}

---

Le problème que j’ai maintenant est le suivant : comment traiter efficacement les listes, par exemple pour avoir des choses comme :
⇒ liste des "tf" pour un client particulier ;
⇒ liste des "tf" de tous les clients ;
A chaque fois, je fais des boucles « for » mais je pense que c’est très cher en calcul.
Par exemple je fais :
⇒ liste des tf pour un client particulier id_cl = 1 :

Code:

---

1 2 3 4 5 6 7 8 9

List<Double> tf_list = new Arraylist<Double>() ; for (int ti = 0; ti< clients.get(id_cl).getTimeInfo().size() ; ti++) { for (int tfi = 0:tfi<clients.get(id_cl).getTimeInfo().get(ti).getTFinal().size();tfi ++) { tf.add(clients.get(id_cl).getTimeInfo().get(ti).getTFinal().get(tfi)); } } }

---

Une solution que je n’aime pas, serait de créer à la fois les listes et les objets :

Code:

---

1 2 3 4

List<Client> id_cl; List<List<Double>> td; List<List<List<Double>>> tf. Client{int id_cl ; List<TimeInfo> time}, avec : TimeInfo{double td ; List<Double> tf}

---

Et où les listes td/tf seraient mis à jour à chaque insertion et recréé à chaque délétion, mais je ne suis pas convaincue de ce qui est le mieux (listes + objets = cher en mémoire ; objets seuls = cher en parcourt de listes).

Auriez vous des recommandations ?
Y a t’il un autre moyen ? Notamment, je cherche quelque chose du type :

Code:

---

clients.get(:).getTimeInfo().get(:).getFinalTime()

---

, où « : » traiterait tous les cas, sans avoir besoin de tout reparcourir par une boucle.

Merci!



[EDIT] : j'ai trouvé les lambda expressions pour avoir par exemple :

Code:

---

list.forEach(System.out::println);

---

mais même si c'est plus agréable à lire, il me semble que c'est tout aussi cher en calcul qu'une boucle, non ?

:salut:
Mon conseil est d'utiliser des Stream (à partir de Java 8) :

Code:

---

List<Double> tf_list = clients.stream().flatmap(Client::getTimeInfos).flatmap(TimeInfo::getTFilnals).collect(Collectors.toList());

---

@ Kazh Du : merci pour ta réponse, c'est quelque chose comme ça que je cherchais !
Par contre j'ai encore un problème, si je fais :

Code:

---

1 2	List<List<List<Double>>> deg_list = ti.stream().map(t->t.getDegrees()).collect(Collectors.toList()); avec List<List<Double>> getDegrees() une fonction de la classe timeInfo

---

ça fonctionne, mais je veux "applatir" le résultat en mettant tout dans une même liste. J'ai donc testé :

Code:

---

1 2 3

List<List<Double>> deg_list = ti.stream().flatmap(t->t.getDegrees()).collect(Collectors.toList()); ou List<List<Double>> deg_list = ti.stream().flatmap(timeInfo::getDegrees).collect(Collectors.toList());

---

mais les erreurs suivantes apparaissent :

Citation:

---

The method flatmap((<no type> t) -> {}) is undefined for the type Stream<timeInfo>
The method flatmap(timeInfo::getDegrees) is undefined for the type Stream<timeInfo>

---

Je n'arrive pas à bien comprendre comment flatmap fonctionne (je pensais que c'était comme "map" mais avec un aplatissement des données, mais vu les erreurs ci-dessus c'est pas le cas).
j'ai réussi à avoir le résultat voulu en faisant :

Code:

---

1 2	List<List<List<Double>>> deg_list = ti.stream().map(t->t.getDegrees()).collect(Collectors.toList()); List<List<Double>> deg_list2 =deg_list.stream().flatMap(Collection::stream).collect(Collectors.toList());

---

mais j'imagine qu'on peut le faire en une étape de manière moins couteuse en mémoire ?

C'est une erreur de ma part, flatMap ne fonctionne que sur les Stream de Stream. il faut transformer les listes en stream et donc faire quelque chose du style :

Code:

---

List<Double> tf_list = clients.stream().map(Client::getTimeInfos).flatMap(List::stream).map(TimeInfo::getTFilnals).flatMap(List::stream).collect(Collectors.toList());

---

ou

Code:

---

List<Double> tf_list = clients.stream()flatMap(c -> c.getTimeInfos().stream()).flatMap(t -> t.getTFilnals().stream()).collect(Collectors.toList());

---

ah oui c'est bien ça et je comprend l'idée, merci beaucoup!