J'ai besoin d'une classe un peu bizarre.
- elle doit permettre de stocker des objets (comme une collection),
- elle ressemblerait à une Hashtable dans le sens où on pourrait
interroger un élément par sa clé,
- mais en plus à partir d'un nombre d'éléments décidé au départ, le
plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non).
Sur lequel m'appuyer pour que l'implémentation soit la plus simple
possible ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Cédric Olmanst
Bonjour à tous,
J'ai besoin d'une classe un peu bizarre. - elle doit permettre de stocker des objets (comme une collection), - elle ressemblerait à une Hashtable dans le sens où on pourrait interroger un élément par sa clé, - mais en plus à partir d'un nombre d'éléments décidé au départ, le plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non). Sur lequel m'appuyer pour que l'implémentation soit la plus simple possible ?
Merci d'avance à tous.
Ca m'étonnerait que le type de Collection que tu demandes existe, mais tu peux le créer très facilement en à peine quelques minutes, en faisant une classe qui hérite de HashMap.
Tu y stockes le nombre d'éléments, et tu redéfinis la méthode put :
if (nombreDElements == tailleMax) { supprimer le plus ancien } appeler le put du parent
Le seul problème serait de trouver lequel est le plus ancien, par contre. Euh... ben réfléchis :op
Ced
Bonjour à tous,
J'ai besoin d'une classe un peu bizarre.
- elle doit permettre de stocker des objets (comme une collection),
- elle ressemblerait à une Hashtable dans le sens où on pourrait
interroger un élément par sa clé,
- mais en plus à partir d'un nombre d'éléments décidé au départ, le
plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non).
Sur lequel m'appuyer pour que l'implémentation soit la plus simple
possible ?
Merci d'avance à tous.
Ca m'étonnerait que le type de Collection que tu demandes existe, mais
tu peux le créer très facilement en à peine quelques minutes, en faisant
une classe qui hérite de HashMap.
Tu y stockes le nombre d'éléments, et tu redéfinis la méthode put :
if (nombreDElements == tailleMax) {
supprimer le plus ancien
}
appeler le put du parent
Le seul problème serait de trouver lequel est le plus ancien, par
contre. Euh... ben réfléchis :op
J'ai besoin d'une classe un peu bizarre. - elle doit permettre de stocker des objets (comme une collection), - elle ressemblerait à une Hashtable dans le sens où on pourrait interroger un élément par sa clé, - mais en plus à partir d'un nombre d'éléments décidé au départ, le plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non). Sur lequel m'appuyer pour que l'implémentation soit la plus simple possible ?
Merci d'avance à tous.
Ca m'étonnerait que le type de Collection que tu demandes existe, mais tu peux le créer très facilement en à peine quelques minutes, en faisant une classe qui hérite de HashMap.
Tu y stockes le nombre d'éléments, et tu redéfinis la méthode put :
if (nombreDElements == tailleMax) { supprimer le plus ancien } appeler le put du parent
Le seul problème serait de trouver lequel est le plus ancien, par contre. Euh... ben réfléchis :op
Ced
Black Myst
Cédric Olmanst wrote:
Bonjour à tous, J'ai besoin d'une classe un peu bizarre. - elle doit permettre de stocker des objets (comme une collection), - elle ressemblerait à une Hashtable dans le sens où on pourrait interroger un élément par sa clé, - mais en plus à partir d'un nombre d'éléments décidé au départ, le plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non). Sur lequel m'appuyer pour que l'implémentation soit la plus simple possible ?
Merci d'avance à tous.
Ca m'étonnerait que le type de Collection que tu demandes existe, mais tu peux le créer très facilement en à peine quelques minutes, en faisant une classe qui hérite de HashMap.
Tu y stockes le nombre d'éléments, et tu redéfinis la méthode put :
if (nombreDElements == tailleMax) { supprimer le plus ancien } appeler le put du parent
Le seul problème serait de trouver lequel est le plus ancien, par contre. Euh... ben réfléchis :op Je pense que tu peux t'en sortir facilement avec une LinkedHashMap.
Cette map conservant l'ordre d'insertion des clés, tu retrouvera la plus ancienne en fin de liste...
Black Myst
Cédric Olmanst wrote:
Bonjour à tous,
J'ai besoin d'une classe un peu bizarre.
- elle doit permettre de stocker des objets (comme une collection),
- elle ressemblerait à une Hashtable dans le sens où on pourrait
interroger un élément par sa clé,
- mais en plus à partir d'un nombre d'éléments décidé au départ, le
plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non).
Sur lequel m'appuyer pour que l'implémentation soit la plus simple
possible ?
Merci d'avance à tous.
Ca m'étonnerait que le type de Collection que tu demandes existe, mais
tu peux le créer très facilement en à peine quelques minutes, en faisant
une classe qui hérite de HashMap.
Tu y stockes le nombre d'éléments, et tu redéfinis la méthode put :
if (nombreDElements == tailleMax) {
supprimer le plus ancien
}
appeler le put du parent
Le seul problème serait de trouver lequel est le plus ancien, par
contre. Euh... ben réfléchis :op
Je pense que tu peux t'en sortir facilement avec une LinkedHashMap.
Cette map conservant l'ordre d'insertion des clés, tu retrouvera la
plus ancienne en fin de liste...
Bonjour à tous, J'ai besoin d'une classe un peu bizarre. - elle doit permettre de stocker des objets (comme une collection), - elle ressemblerait à une Hashtable dans le sens où on pourrait interroger un élément par sa clé, - mais en plus à partir d'un nombre d'éléments décidé au départ, le plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non). Sur lequel m'appuyer pour que l'implémentation soit la plus simple possible ?
Merci d'avance à tous.
Ca m'étonnerait que le type de Collection que tu demandes existe, mais tu peux le créer très facilement en à peine quelques minutes, en faisant une classe qui hérite de HashMap.
Tu y stockes le nombre d'éléments, et tu redéfinis la méthode put :
if (nombreDElements == tailleMax) { supprimer le plus ancien } appeler le put du parent
Le seul problème serait de trouver lequel est le plus ancien, par contre. Euh... ben réfléchis :op Je pense que tu peux t'en sortir facilement avec une LinkedHashMap.
Cette map conservant l'ordre d'insertion des clés, tu retrouvera la plus ancienne en fin de liste...
Black Myst
Alain
tu ne chercherais pas a faire un cache LRU ?
pourquoi réinventer un Nieme cache...
http://java-source.net/open-source/cache-solutions un collègue a utilisé avec bonheur http://ehcache.sourceforge.net/
en changeant la config tu passe de LRU a LFU, tu ajuste divers détails... et en plus tu peux sans te fatiguer créer plein de cache selon tes besoins... sans craindre de te fatiguer...
un peu plus lourd au début, mais au moins il ne sera pas à débugger comme ce qu'on fait a la main ... (nb: j'ai fait comme toi avant, je sais!)
J'ai besoin d'une classe un peu bizarre. - elle doit permettre de stocker des objets (comme une collection), - elle ressemblerait à une Hashtable dans le sens où on pourrait interroger un élément par sa clé, - mais en plus à partir d'un nombre d'éléments décidé au départ, le plus ancien serait viré (selon le principe FIFO).
tu ne chercherais pas a faire un cache LRU ?
pourquoi réinventer un Nieme cache...
http://java-source.net/open-source/cache-solutions
un collègue a utilisé avec bonheur
http://ehcache.sourceforge.net/
en changeant la config tu passe de LRU a LFU, tu ajuste divers détails...
et en plus tu peux sans te fatiguer créer plein de cache selon tes
besoins... sans craindre de te fatiguer...
un peu plus lourd au début, mais au moins il ne sera pas à débugger
comme ce qu'on fait a la main ... (nb: j'ai fait comme toi avant, je sais!)
J'ai besoin d'une classe un peu bizarre.
- elle doit permettre de stocker des objets (comme une collection),
- elle ressemblerait à une Hashtable dans le sens où on pourrait
interroger un élément par sa clé,
- mais en plus à partir d'un nombre d'éléments décidé au départ, le
plus ancien serait viré (selon le principe FIFO).
http://java-source.net/open-source/cache-solutions un collègue a utilisé avec bonheur http://ehcache.sourceforge.net/
en changeant la config tu passe de LRU a LFU, tu ajuste divers détails... et en plus tu peux sans te fatiguer créer plein de cache selon tes besoins... sans craindre de te fatiguer...
un peu plus lourd au début, mais au moins il ne sera pas à débugger comme ce qu'on fait a la main ... (nb: j'ai fait comme toi avant, je sais!)
J'ai besoin d'une classe un peu bizarre. - elle doit permettre de stocker des objets (comme une collection), - elle ressemblerait à une Hashtable dans le sens où on pourrait interroger un élément par sa clé, - mais en plus à partir d'un nombre d'éléments décidé au départ, le plus ancien serait viré (selon le principe FIFO).
Bruno Jouhier
As-tu vraiment besoin que ça soit la *dernière* entrée qui parte?
Si tu veux juste un cache avec N entrées max et que tu n'as pas vraiment besoin d'une sémantique FIFO stricte mais plutôt que les derniers objets aient plus de chance que les anciens d'être dans le cache, tu peux t'en sortir avec un tableau tout bête à N entrées (il faut aussi que chaque objet ait une méthode getKey() qui donne la clé, ce qui est un cas fréquent).
La fonction de cache est tt simplement:
Object getObject(object key) { int index = Math.abs(key.hashCode()) % N; obj = array[index] if (obj == null || !obj .getKey().equals(key)) { // not found in cache, load it and cache it obj = loadObject(key); array[index] = obj; } return obj; }
Bruno
"benoit" a écrit dans le message de news:
Bonjour à tous,
J'ai besoin d'une classe un peu bizarre. - elle doit permettre de stocker des objets (comme une collection), - elle ressemblerait à une Hashtable dans le sens où on pourrait interroger un élément par sa clé, - mais en plus à partir d'un nombre d'éléments décidé au départ, le plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non). Sur lequel m'appuyer pour que l'implémentation soit la plus simple possible ?
Merci d'avance à tous.
As-tu vraiment besoin que ça soit la *dernière* entrée qui parte?
Si tu veux juste un cache avec N entrées max et que tu n'as pas vraiment
besoin d'une sémantique FIFO stricte mais plutôt que les derniers objets
aient plus de chance que les anciens d'être dans le cache, tu peux t'en
sortir avec un tableau tout bête à N entrées (il faut aussi que chaque objet
ait une méthode getKey() qui donne la clé, ce qui est un cas fréquent).
La fonction de cache est tt simplement:
Object getObject(object key)
{
int index = Math.abs(key.hashCode()) % N;
obj = array[index]
if (obj == null || !obj .getKey().equals(key))
{
// not found in cache, load it and cache it
obj = loadObject(key);
array[index] = obj;
}
return obj;
}
Bruno
"benoit" <benoit@benoit.fr> a écrit dans le message de news:
9niv229hummnek196u7eg36qaa1c8kh4qb@4ax.com...
Bonjour à tous,
J'ai besoin d'une classe un peu bizarre.
- elle doit permettre de stocker des objets (comme une collection),
- elle ressemblerait à une Hashtable dans le sens où on pourrait
interroger un élément par sa clé,
- mais en plus à partir d'un nombre d'éléments décidé au départ, le
plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non).
Sur lequel m'appuyer pour que l'implémentation soit la plus simple
possible ?
As-tu vraiment besoin que ça soit la *dernière* entrée qui parte?
Si tu veux juste un cache avec N entrées max et que tu n'as pas vraiment besoin d'une sémantique FIFO stricte mais plutôt que les derniers objets aient plus de chance que les anciens d'être dans le cache, tu peux t'en sortir avec un tableau tout bête à N entrées (il faut aussi que chaque objet ait une méthode getKey() qui donne la clé, ce qui est un cas fréquent).
La fonction de cache est tt simplement:
Object getObject(object key) { int index = Math.abs(key.hashCode()) % N; obj = array[index] if (obj == null || !obj .getKey().equals(key)) { // not found in cache, load it and cache it obj = loadObject(key); array[index] = obj; } return obj; }
Bruno
"benoit" a écrit dans le message de news:
Bonjour à tous,
J'ai besoin d'une classe un peu bizarre. - elle doit permettre de stocker des objets (comme une collection), - elle ressemblerait à une Hashtable dans le sens où on pourrait interroger un élément par sa clé, - mais en plus à partir d'un nombre d'éléments décidé au départ, le plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non). Sur lequel m'appuyer pour que l'implémentation soit la plus simple possible ?
Merci d'avance à tous.
Jack
benoit a présenté l'énoncé suivant :
Bonjour à tous,
J'ai besoin d'une classe un peu bizarre. - elle doit permettre de stocker des objets (comme une collection), - elle ressemblerait à une Hashtable dans le sens où on pourrait interroger un élément par sa clé, - mais en plus à partir d'un nombre d'éléments décidé au départ, le plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non). Sur lequel m'appuyer pour que l'implémentation soit la plus simple possible ?
J'ai besoin d'une classe un peu bizarre.
- elle doit permettre de stocker des objets (comme une collection),
- elle ressemblerait à une Hashtable dans le sens où on pourrait
interroger un élément par sa clé,
- mais en plus à partir d'un nombre d'éléments décidé au départ, le
plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non).
Sur lequel m'appuyer pour que l'implémentation soit la plus simple
possible ?
J'ai besoin d'une classe un peu bizarre. - elle doit permettre de stocker des objets (comme une collection), - elle ressemblerait à une Hashtable dans le sens où on pourrait interroger un élément par sa clé, - mais en plus à partir d'un nombre d'éléments décidé au départ, le plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non). Sur lequel m'appuyer pour que l'implémentation soit la plus simple possible ?
J'ai besoin d'une classe un peu bizarre. - elle doit permettre de stocker des objets (comme une collection), - elle ressemblerait à une Hashtable dans le sens où on pourrait interroger un élément par sa clé, - mais en plus à partir d'un nombre d'éléments décidé au départ, le plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non). Sur lequel m'appuyer pour que l'implémentation soit la plus simple possible ?
J'ai besoin d'une classe un peu bizarre.
- elle doit permettre de stocker des objets (comme une collection),
- elle ressemblerait à une Hashtable dans le sens où on pourrait
interroger un élément par sa clé,
- mais en plus à partir d'un nombre d'éléments décidé au départ, le
plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non).
Sur lequel m'appuyer pour que l'implémentation soit la plus simple
possible ?
J'ai besoin d'une classe un peu bizarre. - elle doit permettre de stocker des objets (comme une collection), - elle ressemblerait à une Hashtable dans le sens où on pourrait interroger un élément par sa clé, - mais en plus à partir d'un nombre d'éléments décidé au départ, le plus ancien serait viré (selon le principe FIFO).
Est-ce qu'un tel objet existe déjà ? (j'imagine que non). Sur lequel m'appuyer pour que l'implémentation soit la plus simple possible ?
