Il n'y a rien de tel que LINQ for Java.
...
Modifier
Maintenant, avec Java 8, Stream API , il en va de même pour les collections, mais ce n'est pas tout à fait comme pour Linq.
Si vous recherchez un ORM, comme Entity Framework, vous pouvez essayer Hibernate
:-)
Il existe une autre solution, Coollection .
Coolection n'a pas prétendu être le nouveau lambda, mais nous sommes entourés d'anciens projets Java hérités où cette librairie vous aidera. C'est vraiment simple à utiliser et à étendre, en ne couvrant que les actions d'itération les plus utilisées sur les collections, comme ceci:
from(people).where("name", eq("Arthur")).first();
from(people).where("age", lessThan(20)).all();
from(people).where("name", not(contains("Francine"))).all();
Les Lambda sont maintenant disponibles dans Java 8 sous la forme de JSR-335 - Expressions Lambda pour le langage de programmation JavaTM
UPDATE: JDK8 est maintenant disponible qui contient le projet lambda. Il vaut la peine de se procurer une copie de Java 8 en action toujours MEAP.
Prenez connaissance de Brian Goetz articles sur les lambdas pour bien comprendre la manière dont les lambdas sont implémentés dans JDK8, tout en vous familiarisant avec les flux, les itérations internes, les courts-circuits et les références de constructeurs. la JSR ci-dessus pour obtenir d'autres exemples.
J'ai écrit un blog sur certains des avantages de l'utilisation de lambdas dans JDK8 appelé Le pouvoir de la flèche , également NetBeans 8 supporte grandement la conversion de constructions en JDK8, ce que je 'a également blogué à propos de Migration vers JDK 8 avec NetBeans .
Vous pouvez sélectionner les éléments d'une collection (et bien plus encore) de manière plus lisible à l'aide de la bibliothèque lambdaj
https://code.google.com/archive/p/lambdaj/
Elle présente certains avantages par rapport à la bibliothèque Quaere, car elle n’utilise aucune chaîne magique, elle est totalement sécurisée au niveau du type et, à mon avis, elle offre un DSL plus lisible.
LINQ to Objects - Java 8 a ajouté l'API Stream, qui prend en charge les opérations de style fonctionnel sur les flux de valeurs:
Explication de Java 8: application de Lambdas à Java Collections
LINQ to SQL/NHibernate/etc. (interrogation de la base de données) - Une option serait d’utiliser JINQ, qui utilise également les nouvelles fonctionnalités de Java 8, publiée le 26 février 2014 sur Github: https://github.com/my2iu/Jinq
Jinq fournit aux développeurs un moyen simple et naturel d'écrire des requêtes de base de données en Java. Vous pouvez traiter les données de base de données comme des objets Java normaux stockés dans des collections. Vous pouvez les parcourir et les filtrer à l'aide des commandes normales Java. Tout votre code sera automatiquement traduit en requêtes de base de données optimisées. Enfin, les requêtes de style LINQ sont disponibles pour Java!
Site du projet JINQ: http://www.jinq.org/
Il y a un projet appelé quaere .
C'est un framework Java qui ajoute la possibilité d'interroger des collections.
Note: Selon l'auteur, le projet n'est plus maintenu.
vous pouvez utiliser scala, sa syntaxe est similaire et il est probablement plus puissant que linq.
Comme en 2014, je peux enfin dire que LINQ est enfin là dans Java 8. Donc, plus besoin de trouver une alternative à LINQ.
Java LINQ to SQL implémentation. Fournit une intégration linguistique complète et un ensemble de fonctionnalités plus étendu par rapport à .NET LINQ.
Maintenant que Java 8 prend en charge lambdas, il est possible de créer Java API ressemblant beaucoup à LINQ.
Jinq est l'une de ces nouvelles bibliothèques de style LINQ pour Java.
Je suis le développeur de cette bibliothèque. Il repose sur cinq années de recherche sur l’utilisation de l’analyse bytecode pour traduire Java en requêtes de base de données. Semblable à la façon dont le D-LINQ de C # est une couche de requête reposant sur Entity Framework, Jinq peut agir en tant que couche de requête reposant sur JPA ou jOOQ. Il prend en charge l'agrégation, les groupes et les sous-requêtes. Même Erik Meijer (le créateur de LINQ) a reconnu Jinq .
Voir SBQL4J . C'est un langage d'interrogation puissant, sécurisé pour le type, intégré à Java. Permet d'écrire des requêtes complexes et de multiplier les requêtes imbriquées. Il y a beaucoup d'opérateurs, les méthodes Java peuvent être appelées à l'intérieur de requêtes de manière à constituer des constructeurs. Les requêtes sont traduites en code pur Java (il n'y a pas de réflexion au moment de l'exécution), donc l'exécution est très rapide.
EDIT: Eh bien, jusqu’à présent, SBQL4J, c’est la SEULE extension du langage Java qui donne des capacités de requête similaires à LINQ. Il y a des projets intéressants comme Quaere et JaQue mais ce ne sont que des API, pas des extensions de syntaxe/sémantique avec une sécurité de type forte au moment de la compilation.
J'ai essayé guava-libraries de Google. Il a une FluentIterable qui, je pense, est proche de LINQ. Voir aussi FunctionalExplained .
List<String> parts = new ArrayList<String>(); // add parts to the collection.
FluentIterable<Integer> partsStartingA =
FluentIterable.from(parts).filter(new Predicate<String>() {
@Override
public boolean apply(final String input) {
return input.startsWith("a");
}
}).transform(new Function<String, Integer>() {
@Override
public Integer apply(final String input) {
return input.length();
}
});
Semble être une vaste bibliothèque pour Java. Certainement pas aussi succinct que LINQ mais semble intéressant.
https://code.google.com/p/joquery/
Prend en charge différentes possibilités,
Collection donnée,
Collection<Dto> testList = new ArrayList<>();
de type,
class Dto
{
private int id;
private String text;
public int getId()
{
return id;
}
public int getText()
{
return text;
}
}
Filtre
Java 7
Filter<Dto> query = CQ.<Dto>filter(testList)
.where()
.property("id").eq().value(1);
Collection<Dto> filtered = query.list();
Java 8
Filter<Dto> query = CQ.<Dto>filter(testList)
.where()
.property(Dto::getId)
.eq().value(1);
Collection<Dto> filtered = query.list();
Aussi,
Filter<Dto> query = CQ.<Dto>filter()
.from(testList)
.where()
.property(Dto::getId).between().value(1).value(2)
.and()
.property(Dto::grtText).in().value(new string[]{"a","b"});
Tri (également disponible pour le Java 7)
Filter<Dto> query = CQ.<Dto>filter(testList)
.orderBy()
.property(Dto::getId)
.property(Dto::getName)
Collection<Dto> sorted = query.list();
Groupement (également disponible pour le Java 7)
GroupQuery<Integer,Dto> query = CQ.<Dto,Dto>query(testList)
.group()
.groupBy(Dto::getId)
Collection<Grouping<Integer,Dto>> grouped = query.list();
Jointures (également disponible pour le Java 7)
Donné,
class LeftDto
{
private int id;
private String text;
public int getId()
{
return id;
}
public int getText()
{
return text;
}
}
class RightDto
{
private int id;
private int leftId;
private String text;
public int getId()
{
return id;
}
public int getLeftId()
{
return leftId;
}
public int getText()
{
return text;
}
}
class JoinedDto
{
private int leftId;
private int rightId;
private String text;
public JoinedDto(int leftId,int rightId,String text)
{
this.leftId = leftId;
this.rightId = rightId;
this.text = text;
}
public int getLeftId()
{
return leftId;
}
public int getRightId()
{
return rightId;
}
public int getText()
{
return text;
}
}
Collection<LeftDto> leftList = new ArrayList<>();
Collection<RightDto> rightList = new ArrayList<>();
Peut être joint comme,
Collection<JoinedDto> results = CQ.<LeftDto, LeftDto>query().from(leftList)
.<RightDto, JoinedDto>innerJoin(CQ.<RightDto, RightDto>query().from(rightList))
.on(LeftFyo::getId, RightDto::getLeftId)
.transformDirect(selection -> new JoinedDto(selection.getLeft().getText()
, selection.getLeft().getId()
, selection.getRight().getId())
)
.list();
Expressions
Filter<Dto> query = CQ.<Dto>filter()
.from(testList)
.where()
.exec(s -> s.getId() + 1).eq().value(2);
Juste pour ajouter une autre alternative: Java 6 a une solution pour les requêtes de base de données sécurisée par le type utilisant le package javax.persistence.criteria .
Bien que je dois dire que ce n’est pas vraiment LINQ, car avec LINQ, vous pouvez interroger n’importe quel IEnumerable.
Il existe une très bonne bibliothèque que vous pouvez utiliser pour cela.
Situé ici: https://github.com/nicholas22/jpropel-light
Lambdas ne sera pas disponible avant le Java 8, donc son utilisation est un peu différente et ne semble pas naturelle.
Vous pouvez essayer ma bibliothèque CollectionsQuery . Cela permet d'exécuter LINQ comme des requêtes sur des collections d'objets. Vous devez passer le prédicat, comme dans LINQ. Si vous utilisez Java6/7, vous devez utiliser l'ancienne syntaxe avec Interfaces:
List<String> names = Queryable.from(people)
.filter(new Predicate<Person>() {
public boolean filter(Person p) {
return p.age>20;
}
})
.map (new Converter<Person,String>() {
public Integer convert(Person p) {
return p.name;
}
})
.toList();
Vous pouvez également l'utiliser en Java8 ou dans le vieux Java avec RetroLambda et c'est gradle plugin , vous aurez alors une nouvelle syntaxe sophistiquée:
List<String> names = Queryable.from(people)
.filter(p->p.age>20)
.map (p->p.name)
.toList();
Si vous devez exécuter des requêtes de base de données, consultez JINQ, comme indiqué ci-dessus, mais RetroLambda ne peut pas le porter en arrière, mais utilisez des lambda sérialisés.
On dirait que le Linq dont tout le monde parle est juste LinqToObjects. Ce qui, à mon avis, n'offre que des fonctionnalités qui peuvent déjà être accomplies aujourd'hui en Java, mais avec une syntaxe vraiment moche.
Ce que je vois comme le vrai pouvoir de Linq dans .Net est que les expressions lambda peuvent être utilisées dans un contexte nécessitant un délégué ou une expression et seront ensuite compilées sous la forme appropriée. C’est ce qui permet à des éléments comme LinqToSql (ou tout autre élément que LinqToObjects) de fonctionner et leur permet d’avoir une syntaxe identique à LinqToObjects.
Il semble que tous les projets mentionnés ci-dessus n'offrent que les fonctionnalités de LinqToObjects. Ce qui me fait penser que la fonctionnalité de type LinqToSql n'est pas à l'horizon pour Java.
Pour les collections fonctionnelles de base, Java 8 est intégré, la plupart des principaux langages JVM non-Java le sont également (Scala, Clojure, etc.) et vous pouvez obtenir des bibliothèques supplémentaires pour les versions antérieures Java versions.
Pour un accès complet en langage intégré à une base de données SQL, Scala (s'exécute sur la machine virtuelle Java) a Slick
Pour LINQ (LINQ to Objects), Java 8 aura quelque chose d'équivalent, voir Project Lambda .
Il a Enumerable's extensions LINQ to Objects comme stuffs . Mais pour les choses LINQ plus compliquées comme Expression et ExpressionTree (nécessaires pour LINQ to SQL et les autres fournisseurs LINQ s’ils veulent fournir quelque chose d’optimisé et de réel), il n’existe pas encore d’équivalent, mais nous verrons peut-être que dans le futur :)
Mais je ne pense pas qu’il y ait à l’avenir des requêtes déclaratives sur Java.
Départ minuscule-q . (Notez que vous ne pouvez pas le télécharger pour le moment.)
Voici un exemple adapté au lien ci-dessus:
Tout d'abord, nous avons besoin d'une collection de données, disons un ensemble de chaînes
String[] strings = { "bla", "mla", "bura", "bala", "mura", "buma" };
Maintenant, nous voulons sélectionner uniquement les chaînes qui commencent par "b":
Query<String> stringsStartingWithB = new Query<String>(strings).where(
new Query.Func<String, Boolean>(){
public Boolean run(String in) {
return in.startsWith("b");
}
}
);
Aucune donnée réelle déplacée, ni rien de ce genre, elle sera traitée dès que vous commencerez à itérer:
for(String string : stringsStartingWithB ) {
System.out.println(string);
}
Il n'y a pas une telle fonctionnalité en Java. En utilisant l'autre API, vous obtiendrez cette fonctionnalité. Comme si nous avions un objet animal contenant le nom et l'identifiant. Nous avons un objet liste ayant des objets animaux. Maintenant, si nous voulons obtenir tous les noms d’animaux qui contiennent "o" dans l’objet list. on peut écrire la requête suivante
from(animals).where("getName", contains("o")).all();
Au-dessus de la requête, la liste des animaux contenant l’alphabet "o" dans leur nom. Plus d'informations s'il vous plaît passer par le blog suivant. http://javaworldwide.blogspot.in/2012/09/linq-in-Java.html
Ce n’est peut-être pas la réponse que vous espérez, mais si une partie de votre code nécessite un travail important en collections (recherche, tri, filtrage, transformations, analyse), vous pouvez envisager d’écrire des classes dans Clojure = ou Scala .
En raison de leur nature fonctionnelle, les collections sont ce qu’elles font de mieux. Je n'ai pas beaucoup d'expérience avec Scala, mais avec Clojure, vous trouverez probablement un Linq plus puissant au bout des doigts et une fois compilé, les classes que vous produirez s'intégreraient de manière transparente au reste de la base de code.
JaQu est l'équivalent LINQ pour Java. Bien qu’il ait été développé pour la base de données H2, il devrait fonctionner pour n’importe quelle base de données, car il utilise JDBC.
Scala.Now i star l'a lu, et l'a trouvé comme linq mais plus simple et plus illisible. mais scala peut fonctionner sous Linux, oui? csharp nécessite mono.
Un utilisateur anonyme en a mentionné un autre, Diting :
Diting est une bibliothèque de classes offrant des fonctionnalités de requête sur les collections via des méthodes chaînables et une interface anonyme, comme Linq dans .NET Contrairement à la plupart des autres bibliothèques de collection, celles-ci utilisent des méthodes statiques et ont besoin de parcourir toute la collection. Diting fournit une classe Enumerable contenant des méthodes chaînables différées pour implémenter une requête sur une collection ou un tableau.
Méthodes prises en charge: any, cast, contact, contient, count, distinct, elementAt, sauf, first, firstOrDefault, groupBy, interset, join, last, lastOrDefault, ofType, orderBy, orderByDescending, inverse, select, select, selectMany, single, singleOrDefault, skip , sautez, prenez, prenezPrenez, toArray, toArrayList, union, où
HQL (Hibernate Query Language) est très similaire à Linq dans .Net
Pas vraiment "Linq to SQL" équivalent pour Java. mais quelque chose de proche. Requête DSL
vous pouvez essayer cette bibliothèque: https://code.google.com/p/qood/
Voici quelques raisons pour l'utiliser:
- poids léger: seulement 9 interface publique/classe à apprendre.
- requête similaire à SQL: groupe de support, ordre, jointure à gauche, formule, etc.
- pour les données volumineuses: utilisez File (QFS) au lieu de Heap Memory.
- essayer de résoudre mismatch impédance relation-objet .
Prise sans scrupule: vous pouvez toujours utiliser https://github.com/amoerie/jstreams
Fonctionne sur Java 6 et les versions ultérieures, ce qui convient parfaitement au développement de Android.
Cela ressemble beaucoup à Scala opérateurs, lodash, C # LINQ, etc.
Il n'y a pas d'équivalent à LINQ for Java. Mais il existe certaines des API externes qui ressemblent à LINQ, telles que https://github.com/nicholas22/jpropel-light , https://code.google.com/ p/jaque /
Il y avait le langage de programmation Pizza (une extension Java) et vous devriez y jeter un coup d'œil. - Il utilise le concept d '"interfaces fluides" pour interroger les données de manière déclarative, ce qui est en principe identique à LINQ sans expressions de requête (http://en.wikipedia.org/wiki/Pizza_programming_language). Malheureusement, cela n’a pas été poursuivi, mais c’était une façon d’obtenir quelque chose de similaire à LINQ en Java.
Vous pouvez utiliser Java Functional Utils pour convertir les 101 exemples LINQ de C # compatible avec Java 1.7 sur Android.