Discussion :

[Malawi]

Bonjour,

J ai un probleme de genericite que je n arrive pas a resoudre.
J ai dans un fichier des donnees (de type non connu). Je veux copier ces donnees dans un tableau. Je teste donc le type de donnee :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public Class getType(Variable var) { // var est l object de la variable dont les donnees sont dans le fichier
        try {
            for (String data : getAllData(var)) {
                Integer.parseInt(data);
            }
            return Integer.class;
        } catch (NumberFormatException ex) {
        }
 
        try {
            for (String data : getAllData(var)) {
                Float.parseFloat(data);
            }
            return Float.class;
        } catch (NumberFormatException ex) {
        }
 
        try {
            for (String data : getAllData(var)) {
                Double.parseDouble(data);
            }
            return Double.class;
        } catch (NumberFormatException ex) {
        }
 
        return String.class;
    }

Comment alors creer un tableau de ce type:
ArrayList<quoi mettre ici> array = newArrayList<quoi mettre ici>();

Je peux bien sur faire un tableau ArrayList<?> array = newArrayList<?>(); mais j aurai aime preciser le type car j ai besoin de le connaitre plus tard.

Pour le moment j ai une variable ou lutilisateur dit si c est numerique (que je met alors double pour etre sur) ou text (String).

Merci pour vos reponses

[Malawi]

Je viens de tomber sur un article parlant de "reflexion". Ca a l air de faire ce que je veux, mais ca a la ir aussi bien complique (en tout cas sur le site de Sun)

Est ce la solution a adopter pour moi? Et si oui, ets il possible d avoir un example?

Merci

[gifffftane]

Il n'est pas possible de renseigner, par la reflexivité, le quoi mettre ici.

Ce quoi mettre ici est forcément du niveau déclaratif, c'est à dire placé quelque part dans le source pour préciser les variables que tu utilises.

La difficulté est que tu explores, au runtime, un ensemble de données, que tu en déduis leur type est que tu voudrais fabriquer leur classe générique, tout cela au runtime. Tel que ce n'est pas possible, ou super-tiré par les cheveux.

Moi je pense qu'il vaut mieux :
- pour la phase de génération au runtime, oublier les génériques, ne procéder qu'avec des ArrayList simples, des casts, instanceof et autres.
- pour les portions de code spécifique à un générique donné, que tu connais donc précisément lorsque tu écris ton code, tu passes en générique ; et tu fais l'interface entre les deux à l'aide de méthodes bien précises protégées par des @SuppressWarnings("unchecked") : ceci me semble justifié, puisque tu passes consciemment d'un monde à l'autre.

Hugh.

[Malawi]

Merci pour ta reponse,
Je suis pas sur d avoir bien tout compris ta solution cependant

Pour savoir si ca correspond a la solution dont tu parles, je vais expliquer ce que j ai fait:

Je dois donc charger des fichiers csv avec des informations dedans, dont je ne connais pas le type a prioris. Pour le moment, l utilisateur renseigne si la variable (une colonne dans le csv) est numerique ou text.

J ai donc un generic "Variable" (abstract) et 2 sous types "VariableNumeric<T extends Number>" et "VariableText". Je construis pour le moment mon "VariableNumeric" comme "VariableNumeric<Double>" pour etre sur d avoir une presision assez bonne pour couvrir la majorite des types de donnees numerique possible (souvent c est des Integer ou des nombres aves quelques chiffres apres la virgules).
Je copie donc les donnees de ces variables dans 1ere base de donnee virtuelle (des ArrayList<String>), et ensuite dans une seconde base de donnees virtuelle (basiquement une structure a base de Map et ArrayList) pour un acces plus rapide ensuite. Je ne me sers apres plus de la 1ere base (Elle est seulement gardee tout ou en partie par la JVM car elle ne recopie pas vraiment les donnees de la 1ere base dans la 2e, mais fait seulement des liens)
Tout ceci marche tres bien.

Mon probleme est que mon programme utilise BEAUCOUP de memoire des que les fichiers de donnees deviennent un peu grand, et j arrive vite a un "OUt of Memory" (meme avec l option -Xmx).
Pour exemple, avec un fichier de 25Mo environ, j ai besoin de 500Mo de Ram. Je voudrais donc optimiser l espace memoire en allouant pas a chaque fois un Double pour tout type numerique, mais par exemple un Integer si la donnee en est un. Cela pourrait me faire gagner pas mal de place.

1) Merci de m avoir lu jusque ici.
2) Je crois donc rentrer dans la description que tu as donne, a moins que je n ai pas bien compris...
Si c est deja ce que je fais, comment optimiser l espace memoire de mon programme? (simplement une idee, car je sais que que ce n est pas forcement evident sans le code, mais il est tres long...)

Merci encore

[gifffftane]

Pour exemple, avec un fichier de 25Mo environ, j ai besoin de 500Mo de Ram. Je voudrais donc optimiser l espace memoire en allouant pas a chaque fois un Double pour tout type numerique, mais par exemple un Integer si la donnee en est un. Cela pourrait me faire gagner pas mal de place.

Selon tes explications, je ne vois rien qui explique un pareil quota ! Quasi 20 fois la place pour une donnée d'origine, même pour java cela fait beaucoup !

Je te suggère premièrement de rechercher d'où sort ce besoin de mémoire.

Pour répondre à ton problème, si je résume d'abord : il me semble que tu souhaites un type générique de famille numérique de façon à optimiser l'espace mémoire.

Au départ c'est dans un fichier csv, puis à la suite de x manipulations, tu voudrais un VariableNumeric<Double>, ou VariableNumeric<Integer>, ou n'importe quoi d'autre.

Mais après, nous dérivons vers un problème de mémoire ?...

Enfin bref, au niveau des génériques, il faut bien comprendre que c'est uniquement une forme d'écriture, forme qui exprime une certaine logique.

Il ne s'agit pas de nouvelles classes. Il faut bien faire la différence entre par exemple, ton VariableNumeric<Double>, et une classe qui s'appellerait VariableNumericDouble.

La première est une classe VariableNumeric, que quelque chose d'extérieur déclare se rapporter à un Double, mais dont rien du fonctionnement interne concerne Double, tandis que la deuxième est une variable qui se comporte spécifiquement selon les propriétés d'un Double, que l'extérieur le veuille ou pas, l'extérieur pouvant même l'ignorer.

(en supposant bien sûr que Double veuille dire ce à quoi tout le monde s'attend ! )

Donc tu choisiras VariableNumeric<TrucMuche> si tu veux stipuler qu'un usage donné de VariableNumeric concerne un TrucMuche, mais c'est seulement une facilité d'écriture à usage extérieur.

Tu choisiras VariableNumericTrucMuche si tu veux dire que VariableNumericTrucMuche existe par lui même.

J'ai l'impression que plus j'explique, plus c'est confus...

Bon, j'en rajoute une couche.

La difficulté pour comprendre vient sans doute du nom : VariableNumeric<Double> ; VariableNumeric tend à dire que nous sommes en présence d'un numérique, qui se comporte donc comme un numérique, tandis que <Double> tends à dire notre classe se rapporte à un Double, mais sans se comporter comme un Double.

Nous avons donc quelque chose qui se comporte comme un numérique, mais sans être un double. Pas forcément facile à séparer les concepts...

C'est clair, non ?

[Malawi]

Merci encore pour ta reponse, et merci d y passer tant de temps,

J avais compris le principe que tu mas explique, la n est pas le pb. J ai pas du etre tres clair dans le message precedent.
Mon probleme initial est bien un probleme de memoire. Je regarde depuis plusieurs jours avec un profiler et tout me parait venir de ces recopies de donnees que je fait.

Laissons tomber le pb des VariableNumeric, ca n a fait que embrouiller la chose!


En gros, avec un exemple simple qui donne une idee de mon pb:
- j ai des donnees dans un fichier csv :
- pour chaque variable (colonne du fichier), je lis les donnees une par une: "String value"
- je met les donnees de chaque variable dans une premiere base de donnee (un ArrayList<String> par variable)
- je mets cette donnee dans l ArrayList correspondant
- je fais des traitements
- je transforme la base de donnees 1 en base de donnees 2 pour une lecture plus rapide:
Cette base est une TreeMap<Double, HashMap<Object, ArrayList<Object>>>, que j appelle une TreeMultiHashMap<Double, Object, Object>. Les "Object" sont les valeurs de mon fichier (donc numerique ou String). J utilise pour cela le MultiHashMap de Apache.
Ainsi pour chaque variable, je rajoute ses donnees selon le type de la variable:
- numerique : base2.put( key1, key2, Double.parseDouble( value ))
- text : base2.put( key1, key2, value )
- je fais d autres traitements


Quand je fais un profiler, j ai donc majoritairement en memoire (ordre decroissant):

- des char, qui proviennent de la lecture du fichier lors de la copie en base 1
(j imagine qu ils sont gardes en memoire par la JVM et que des liens sont faits de "base" vers "String" vers "char", char etant de type primitif)
- des Object[], qui proviennent de la creation de la base 2
- des String, qui proviennent de la lecture du fichier lors de la copie en base 1
puis en moindre mesure:
- HashMap$Entry, pour la base
- ArrayList, pour la base
- Double, representant les valeurs numerique de mon fichier
- le reste, qui n est pas significatif


Et je ne vois pas comment reduire la memoire utilisee...
En esperant avoir ete clair cette fois...

[gifffftane]

Est-il imaginable que, au lieu d'employer des classes du paquetage des collections, tu emploies une base de données ? Ces composants savent gérer plus vite que le vent les accés aux données, particulièrement lorsque ces données sont plus grosses que la mémoire disponible.

Pour ce qui est de la mémoire est de la méthode actuelle, à te lire, je ne vois rien qui explique son usage faramineux, donc je peux pas te donner une solution.

Concernant toujours cette mémoire, s'il est bon de connaître sa répartition, cela ne permet pas de détecter facilement une anomalie. Pour détecter une anomalie, il faut regarder l'évolution de la consommation mémoire. Une consommation normale augmente au départ, puis reste stable, ou évolue en dents de scie horizontalement ; si ta consomation mémoire est ainsi, tu ne peux pas faire grand chose, à part quantité de combines, combines qui sont déjà présentes dans toutes les bases de données de france et de navarre. Si la consommation ne cesse pas d'augmenter, alors c'est qu'il y a quelque part une fuite mémoire, qu'il faut bien sûr résoudre.

Tu peux également réfléchir - je n'aime pas beaucoup le mot optimiser - à la façon dont tu traites le problème. Pourquoi es-tu obligé de conserver la base 1 ? Normalement, si la base 2 est dans un format plus adapté au traitement, alors tu devrais pouvoir te passer complètement de la base 1. Et si la base 2 n'est pas suffisamment bien adapté au traitement, alors à quoi sert-elle vraiment ?

[Malawi]

Est-il imaginable que, au lieu d'employer des classes du paquetage des collections, tu emploies une base de données ? Ces composants savent gérer plus vite que le vent les accés aux données, particulièrement lorsque ces données sont plus grosses que la mémoire disponible.

Par base de donnees, tu entends base de type SQL?
Je n ai pas voulu utiliser cette solution pour avoir un acces tres rapide aux donnees. Mon programme est un programme de visualisation qui affiche beaucoup de donnees en meme temps, et lors de la lecture, j ai besoin d un acces rapide aux donnees. Je pensais q une telle base etait plutot lente, qu entends tu par "plus vite que le vent"? Je vais etudier plus profondement cette solution. De plus je n ai pas "tellement" de donnees: souvent qqs megas, jusqu a qqs dizaines de megas. Et j avoue que moi aussi je ne comprend pas pourquoi j ai autant de memoire prise a la fin.

Concernant toujours cette mémoire, s'il est bon de connaître sa répartition, cela ne permet pas de détecter facilement une anomalie. Pour détecter une anomalie, il faut regarder l'évolution de la consommation mémoire. Une consommation normale augmente au départ, puis reste stable, ou évolue en dents de scie horizontalement ; si ta consomation mémoire est ainsi, tu ne peux pas faire grand chose, à part quantité de combines, combines qui sont déjà présentes dans toutes les bases de données de france et de navarre. Si la consommation ne cesse pas d'augmenter, alors c'est qu'il y a quelque part une fuite mémoire, qu'il faut bien sûr résoudre.

J ai deja verifier, et je ne vois pas de fuite.

Tu peux également réfléchir - je n'aime pas beaucoup le mot optimiser - à la façon dont tu traites le problème. Pourquoi es-tu obligé de conserver la base 1 ? Normalement, si la base 2 est dans un format plus adapté au traitement, alors tu devrais pouvoir te passer complètement de la base 1. Et si la base 2 n'est pas suffisamment bien adapté au traitement, alors à quoi sert-elle vraiment ?

Seule la base 2 m est utile. Je ne conserve pas la base 1, qui ne me sers que d intermediaire pour faire sans erreur:
fichier -> base 1 -> base 2
La base 1 est une recopie pure et simple des variables (colonnes) utilisees des fichiers. J accede ensuite a cette base 1 pour construire la base 2, elle optimisee pour mes acces futurs. Je ne remplis pas directement la base 2 a partir des fichiers pour avoir un systeme plus simple a comprendre pour le debuggage.

Je laisse la JVM gerer le recopiage dans la base 2, donc a ce que j ai compris, les valeurs de type primaires (Double) y sont recopiees, mais pas les valeurs de type String (non primaire), qui sont accedees par leur lien. Je suppose ainsi que les c est de la que viennent les char et String dont j ai parle dans mon message precedent: ils ne sont pas reellement en base 2, mais seulement un lien pointe vers eux. Du coup je ne me sers pas de la base 1, mais je ne sais pas bien si elle est bien supprimee, ou laissee active par la JVM pour les acces aux String et char. Je dois avoir un pb quelque part, mais je ne vois pas ou.



En tout cas, je vais voir du cote des bases de donnees pour plus d infos.
Merci pour ta reponse encore une fois.

[Malawi]

Je viens de tomber sur le terme de "base de donnees embarquee", que je ne connaissais pas. Cela me semble etre adapte, sachant que mes fichiers font en gros:
- de qqs megas a qqs dizaines de megas
- entre 15 000 et 150 000 lignes environ

et sachant que j ai un acces repete mais par petits morceaux a mes donnees.
Je vais voir plus loin de ce cote, si c est pas trop dur a mettre en place et surtout a integrer dans ce que j ai deja fait.

[gifffftane]

Oui, il existe des bases de données qui s'intègrent très facilement à une appli.

Moi j'utilise surtout Derby pour cela, qui est paraît-il dans le JDK, mais je n'ai jamais trouvé où, ce qui est tout de même un comble.

J'ai également utilisé HSQLDB.

Les deux sont bien, et même très bien. Avec les deux, tu as des systèmes d'import automatiques de fichiers CSV

Pour vérifier si la base 1 est bien libérable de la mémoire, il faut réaliser un exercice intellectuel, et répondre à la question suivante : Est-ce que, d'un point quelconque de l'application, je peux accéder à cette base ? Si oui, elle n'est pas libérable, et te prend de la place en mémoire. Il faut que tu la rendes innateignable. Le problème des String qui étaient dans cette base 1 et qui sont utilisés par la base 2 ne sont pas un problème ; il suffit de vérifier pour la base 1.

[Malawi]

Pour la base 1, j ai deja verifier "intellectuellement". Et elle n est pas accessible car seulement construite dans une fonction, et donc detruite a la fin de cette fonction. Je l ai construite pour ne pas etre "enregistree".
Mais je cherche tous les scenarios possible pour comprendre d ou vient cette utilisation memoire.

Je vais je crois chercher a bien repondre a cette question avant d essayer toute optimisation supplementaire. Et en meme temps je vais voir du cote des bases de donnees embarquees.

PS: j ai trouve ca, si ca peut aider:

Java DB is based on Apache Derby and is Sun's redistribution of this last one.
[...]
You will find the distribution of Java DB under the 'db' directory of the main JDK install.

[bouye]

Juste pour info (j'ignore si cela aidera), il est impossible de retrouver un type generique (pour le moment, cela sera peut-etre possible dans Java7) mais tu peux le stocker a la creation et le retourner par la suite. Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class Truc<T extends Number> {
  private List<T> list;
  private Class<T> type;
 
  public Truc(Class<T> type) {
     this.type = type;
  }
 
  public class<T> getType() {
    return type;
  }
}

Code :

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

1
2
Truc<Integer> iTruc = new Truc<Integer>(Integer.class);
Truc<Float> fTruc = new Truc<Float>(Float.class);

[Malawi]

Merci,

J utilise un procede similaire aussi pour le moment. Ma question initiale etait de savoir comment creer un nouvel object plus tard dans le programme avec pour parametre ce type enregistre:

Pour continuer ton exemple, quelque chose du style:

Code :

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

1
2
3
4
Truc<Integer> iTruc = new Truc<Integer>(Integer.class);
Truc<Float> fTruc = new Truc<Float>(Float.class);
...
Machin<iTruc.getType()> iMachin = new Truc<iTruc.getType()>();

... bien que je sais que mon exemple ne marche pas (c est pour donner l idee).


Mais en fait, c etait au depart pour essayer de gagner de l espace memoire en allouant seulement des "Integer" si mes variables sont des "Integer" par exemple au lieu de tout transformer en "Double" (car je ne connais pas le type).

Je vais essyaer de voir encore un peu dans mon code pour alleger l utilsation memoire...