Discussion :

[Misaki43]

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 :



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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[Kazh Du]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Misaki43]

@ 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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[Kazh Du]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Misaki43]

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