Discussion :

[boboss123]

bonjour,

Je voudrais créer une classe qui possède une methode add pour ajouter un élément à sa propre liste dynamique. Chaque élément est issu d'une même classe qui possède plusieurs attributs.

Je voudrais que lorsque j'ajoute un élément via la methode add, que celui-ci soit automatiquement trié par orde croissant en fonction de l'un de ses attributs (un int => nous appellerons cet attribut myAttr).
=> je veux le trier pour accélérer mes méthodes de recherche d'élément : je veux récupérer le plus rapidement possible le premier élément de la liste où myAttr est inférieur à une valeur donnée.

Ne connaissant pas trop tous les types de liste sous Java, pouvez-vous me conseillez quelle est la meilleure méthode à utiliser ?
=> a priori il semblerait que les TreeMap soit bien adapté à ce genre d'application...

[cdefranoux]

Je peux comprendre ta demande de deux façons :
- tu souhaites stocker les éléments dans une liste (concrètement, une collection qui implémente java.util.List<E>). Les éléments doivent être ordonnés suivant un critère que tu définis. Il est possible de définir la manière d'ordonner les éléments en leur faisant implémenter java.lang.Comparable<E> et en triant la liste grâce à java.util.Collections.sort().
- tu souhaites stocker les éléments dans une collection non ordonnée qui te permet de retrouver rapidement un élément à partir d'une clé. Si tu utilises une collection qui implément java.util.Map<K,V>, ça devrait faire ce que tu souhaites.

Si ces conseils ne te suffisent pas, essaie de préciser ta demande.

Bon courage !

[boboss123]

En gros mes éléments représentent des zones mémoires tampons désignées par une plage d'adresse

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
public class MemoryZoneStruct {
 
   ByteArrayOutputStream bos = new ByteArrayOutputStream();
   int currentAddr;    
 
  public void write(int val){...} // écrit dans bos 
  public void jumpTo(int addr){...} // saut d'adresse (remplit bos avec une valeur "vide" jusqu'a arriver a l'adresse désirée) => le saut ne peut être que positif
 
   ...
   ...
 
   // permet de savoir sur quelle plage d'adresse on travaille
   public int getFirstAddr(){...}
   public int getSize(){...}
}

Je voudrais donc créer une liste de plusieurs de ces éléments

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
28
	class ClassList{
 
		List myList = new List()l;
		int myAddr = 0;
 
		public void add(MemoryZoneStruct mz){
			list.add(mz);
		}
 
		public void write(int val){
			// recherche de l'élément correspondant à l'adresse
			MemoryZoneStruct mz = .... ????? ;
 
			mz.write(val)
			myAddr++;
		}
 
		// saut d'adresse                
		public void jumpTo(int addr){
			myAddr  = addr;
 
			// recherche de l'élément correspondant à l'adresse
			MemoryZoneStruct mz = .... ????? ;
 
			mz.jumpTo(myAddr);
		}
 
	}

=> le but étant que mes méthodes .write() et .jumpTo() soient éxécutées le plus rapidement possible.

Le but de mon application est d'écrire des valeurs dans une zone mémoire virtuelle dont je défini différentes zones qui ne se suivent pas forcément => peut-être que je suis parti sans une mauvaise direction sur l'architecture de mon projet...
Donc j'ai deux méthodes pour le remplissage de ma zone mémoire
- .write(int val) : écrit à l'emplacement mémoire sélectionné (puis pointe automatiquement sur l'élément suivant)
- .jumpTo(int addr) : déplace le pointeur d'adresse

[cdefranoux]

Le plus simple dans ce cas est d'utiliser une Hashtable<int, MemoryZoneStruct> qui associera à une position mémoire (l'entier) un objet MemoryZoneStruct :

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
28
29
 
	class ClassList{
 
		Hashtable<int,MemoryZoneStruct> myList = new Hashtable<int,MemoryZoneStruct>();
		int myAddr = 0;
 
		public void add(MemoryZoneStruct mz){
			list.put(mz.getFirstAddr(), mz); // Range mz en l'associant à une adresse pour le retrouver plus tard.
		}
 
		public void write(int val){
			// recherche de l'élément correspondant à l'adresse
			MemoryZoneStruct mz = myList.get(val);
 
			mz.write(val)
			myAddr++;
		}
 
		// saut d'adresse                
		public void jumpTo(int addr){
			myAddr  = addr;
 
			// recherche de l'élément correspondant à l'adresse
			MemoryZoneStruct mz = myList.get(val);
 
			mz.jumpTo(myAddr);
		}
 
	}

[boboss123]

merci pour ta réponse

mais il y a un petit problème me semble t-il :

la zone d'adresse est défini avec deux paramètres

Code :

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

1
2
   public int getFirstAddr(){...}
   public int getSize(){...}

Donc il n'y pas une seule valeur d'adresse à gérer mais plusieurs pour un élément donc ceci ne fonctionnera pas me semble t-il :

Code :

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

myList.get(val);

.

Ensuite il me semblait judicieux de trier par ordre croissante la liste car ça permettrait d'éviter de reparcourir complétement la liste à chaque fois => je pensais sauvegarder à chaque fois la position du dernier élément lu et de repartir de celui-ci lors de la prochaine recherche : mais je ne vois pas comment faire pour parcourir une liste en repartant d'un élément donné...

Remarque : Lors de la phase de remplissage de mes buffers, j'écris toujours en partant de l'adresse la plus petite et les sauts d'adresse sont toujours positifs.

[cdefranoux]

Je croyais avoir compris que tu souhaitais retrouver rapidement un MemoryZoneStruct à partir de son adresse de début. Si ce n'est pas le cas, l'utilisation d'une map ne convient pas.

Tu évoques ensuite la possibilité d'ordonner par adresses de début croissantes les MemoryZoneStruct. L'idée est bonne mais elle n'a aucun sens avec une map, encore une fois.
Peux-tu décrire clairement la requête que tu souhaites que la méthode write effectue ? Si tu veux retourner le MemoryZoneStruct qui "contient" l'adresse donnée, alors range tes MemoryZoneStruct dans une simple liste ordonnée. Implémente Comparator<E> sur MemoryZoneStruct et utilise Collections.sort.