Persistante des structures de données en Java
Personne ne sait d'une bibliothèque ou d'une partie au moins de la recherche sur la création et l'utilisation persistante des structures de données en Java? Je ne vous parle pas de la persistance à long terme de stockage, mais la persistance dans les termes de l'immutabilité (voir L'entrée de Wikipedia).
Je suis actuellement en train d'explorer différentes façons de modéliser une api de persistance des structures. À l'aide des constructeurs semble être une solution intéressante:
//create persistent instance
Person p = Builder.create(Person.class)
.withName("Joe")
.withAddress(Builder.create(Address.class)
.withCity("paris")
.build())
.build();
//change persistent instance, i.e. create a new one
Person p2 = Builder.update(p).withName("Jack");
Person p3 = Builder.update(p)
.withAddress(Builder.update(p.address())
.withCity("Berlin")
.build)
.build();
Mais il se sent encore un peu boilerplated. Des idées?
Vous ne savez pas si la fonctionnelle de la programmation tag ici est appropriée. Je prends de la programmation fonctionnelle à dire des langages comme Haskell et Lisp. 🙂
Je pense que fonctionnel car persistante des structures de données sont communs aux langages de programmation fonctionnelle. Je devine qu'il veut être en mesure de faire quelque chose en Java, il est facilement en mesure de le faire dans certains langage fonctionnel. Pourquoi le wiki de la communauté? Cela semble être une solide programmation de question pour moi.
Je pense que fonctionnel car persistante des structures de données sont communs aux langages de programmation fonctionnelle. Je devine qu'il veut être en mesure de faire quelque chose en Java, il est facilement en mesure de le faire dans certains langage fonctionnel. Pourquoi le wiki de la communauté? Cela semble être une solide programmation de question pour moi.
OriginalL'auteur |
Vous devez vous connecter pour publier un commentaire.
Je suppose que les choix évidents sont:
o passer à un transitoire de la structure de données (builder) pour la mise à jour. C'est tout à fait normal.
StringBuilder
pourString
manipulation par exemple. Que votre exemple.o utilisez Toujours persistante des structures. Bien qu'il semble y avoir beaucoup de copie, vous devriez vraiment être le partage de presque tous les états, de sorte qu'il est loin d'être aussi terrible que ça en a l'air.
o Exploser la structure de données dans beaucoup de variables et de se recombiner avec un énorme et confuse constructeur.
o Utilisation de l'appel en arrière interfaces pour fournir les nouvelles données. Encore plus passe-partout.
o Utiliser méchant hacks pour faire des champs de façon transitoire à la disposition de code.
(C'est assez marrant je viens de faire un copier Purement Fonctionnelle des Structures de Données par Chris Okasaki.)
L'exemple ne devrait pas avoir le constructeur (mise à jour). Vous pouvez ajouter méchant hacks pour obtenir l'adresse, puis revenir à la personne, mais ce serait mal et de la confusion. Un autre méchant hack serait une classe qui explose à la Personne et utilise ensuite double croisillon idiome - pas assez de caractères pour le décrire.
Juste à noter, le double croisillon d'initialisation est appelé “méchant” pour une raison – il crée une sous-classe (impact sur la taille du code et de la performance) qui, souvent, obtient une référence à la englobante de l'objet (ce qui pourrait provoquer une fuite de mémoire).
OriginalL'auteur
Les constructeurs feront de votre code trop détaillé pour être utilisable. Dans la pratique, presque tous immuable des structures de données que j'ai vu passer dans l'état par le constructeur. Pour ce que sa vaut la peine, voici une belle série d'articles décrivant immuable des structures de données en C# (qui devrait se convertir facilement en Java):
C# et Java sont extrêmement détaillé, de sorte que le code de ces articles est assez effrayant. Je recommande d'apprendre OCaml, F#, ou de la Scala et de vous familiariser avec l'immutabilité avec ces langues. Une fois que vous maîtrisez la technique, vous serez en mesure de faire le même style de codage Java beaucoup plus facilement.
Je sais scala, haskell donc c'est certains de la motivation à enquêter sur les structures de données en java.
Le code à mettre en œuvre les constructeurs tend à inutiles verbeux, certainement. À l'aide des constructeurs il y a l'habituel ponctuation soupe de Java-comme des langues.
OriginalL'auteur
Ont un coup d'oeil à Fonctionnel Java. Actuellement fournis persistante des structures de données comprennent:
Un certain nombre d'exemples d'utilisation sont fournis avec la distribution binaire. La source est disponible sous licence BSD d' Google Code.
Au lieu de "l'objet", pensez "enregistrement" ou "struct". Un enregistrement est fondamentalement hétérogène liste avec recherche par type de capacité. J'ai pensé à la façon de mettre en œuvre ce genre de chose en Java. Laissez-moi savoir comment vous vous y prenez.
OriginalL'auteur
J'ai mis en place quelques persistante des structures de données en Java. Tous open source (GPL) sur Google code pour n'importe qui qui est intéressé:
http://code.google.com/p/mikeralib/source/browse/#svn/trunk/Mikera/src/mikera/persistent
La principale de celles que j'ai pour l'instant:
Intéressant point de vue de David.... Je sentais que c'était bien la peine de la mise en œuvre de ces interfaces, de sorte que la persistance de structures de données peuvent être utilisés avec des Api qui attendent une collection Java (ce qui est tout à fait beaucoup d'Api, y compris beaucoup de cœur des Api Java!) Si vous ne voulez pas que la compatibilité de l'API, il n'y a pas beaucoup d'autre choix que de lancer une UnsupportedOperationException - cependant, je pense que c'est une bonne chose parce que si quelqu'un tente de modifier un immuable collection puis il y a manifestement un bug dans leur logique, ils devraient être de fixation!
Oui, pour l'API de compatibilité UnsupportedOperationExceptions sont le chemin. Mais il n'a pas à être les principales catégories qui sont compatibles, les classes wrapper soutenu par votre propre volonté faire ainsi. Ensuite, vous avez de compatibilité lorsque vous en avez besoin, et le reste du temps, les classes qui leur communiquer l'immutabilité au moment de la compilation.
OriginalL'auteur
Très simple provisoire avec dynamic proxy:
utilisation:
grandir directions:
espère que cela aide 🙂
désolé j'ai mal compris votre question! 🙁 Par la voie de l'écriture de ce code était très drôle et très utile 🙂
OriginalL'auteur
Il est très difficile, voire impossible, de faire des choses immuables qui n'est pas conçu de la sorte.
Si vous pouvez concevoir de sol:
OriginalL'auteur
Voulez-vous immutabilité :
Dans les deux cas, il y a des moyens plus faciles pour obtenir le résultat désiré.
L'arrêt de code externe à partir de la modification des données est facile avec les interfaces:
Alors arrêter modifications apportées à une valeur une fois réglé, c'est aussi "facile" à l'aide de java.util.de façon concomitante.atomique.AtomicReference (bien que hibernate ou une autre couche de persistance d'utilisation peuvent avoir besoin d'être modifié):
Mais pourquoi avez-vous besoin de quelque chose plus que juste des interfaces pour accomplir la tâche?
OriginalL'auteur
Google Goyave accueille désormais une variété de immuable/persistante des structures de données.
OriginalL'auteur