Qu’est-ce que l’équivalent Java pour LINQ?

Qu’est-ce que Java équivalent pour LINQ?

Il n’y a rien comme LINQ pour Java.

modifier

Maintenant, avec Java 8, nous sums initiés à l’ API Stream , c’est une chose similaire quand on traite des collections, mais ce n’est pas tout à fait la même chose que Linq.

Si c’est un ORM que vous recherchez, comme Entity Framework, vous pouvez alors essayer Hibernate

🙂

Il existe une solution alternative, Coollection .

Coolection ne prétend pas être le nouveau lambda, mais nous sums entourés de vieux projets Java hérités où cette lib aidera. C’est très simple à utiliser et à étendre, couvrant uniquement les actions d’itération les plus utilisées sur les collections, comme ça:

from(people).where("name", eq("Arthur")).first(); from(people).where("age", lessThan(20)).all(); from(people).where("name", not(contains("Francine"))).all(); 

Les Lambdas sont désormais disponibles dans Java 8 sous la forme de JSR-335 – Expressions Lambda pour le langage de programmation JavaTM

UPDATE : JDK8 a été libéré et contient le projet lambda. Il vaut la peine d’acquérir une copie de Java 8 in Action, toujours sous MEAP.

Lisez les articles de Brian Goetz relatifs aux lambdas pour bien comprendre comment les lambdas sont implémentés dans JDK8 tout en acquérant une compréhension des stream, des itérations internes, des courts-circuits et des références constructeurs. Consultez également les 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é The Power of the Arrow , et NetBeans 8 supporte très bien la conversion de constructions en JDK8 que j’ai également blogué sur 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 en utilisant la bibliothèque lambdaj

https://code.google.com/archive/p/lambdaj/

Il présente certains avantages par rapport à la bibliothèque Quaere car il n’utilise pas de chaîne magique, il est totalement sécurisé et, à mon avis, il offre un DSL plus lisible.

Vous ne trouverez pas l’équivalent de LINQ, sauf si vous utilisez javacc pour créer votre propre équivalent.

Jusqu’à ce que quelqu’un trouve un moyen viable de le faire, il existe de bonnes alternatives, telles que

LINQ to Objects – JAVA 8 a ajouté l’API Stream qui prend en charge les opérations de style fonctionnel sur les stream de valeurs:

Package java.util.stream

Explication de Java 8: application de Lambdas à des collections Java

LINQ to SQL / NHibernate / etc. (interrogation de la firebase database) – Une option serait d’utiliser JINQ qui utilise également les nouvelles fonctionnalités de JAVA 8 et qui a été publié 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 firebase database en Java. Vous pouvez traiter les données de la firebase database comme des objects Java normaux stockés dans des collections. Vous pouvez les parcourir et les filtrer en utilisant des commandes Java normales, et tout votre code sera automatiquement traduit en requêtes optimisées. Enfin, des 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.

Il existe de nombreux équivalents LINQ pour Java, voir ici pour une comparaison.

Pour un framework de style Typesafe Quaere / LINQ, envisagez d’utiliser Querydsl . Querydsl prend en charge les collections JPA / Hibernate, JDO, SQL et Java.

Je suis le responsable de Querydsl, donc cette réponse est biaisée.

vous pouvez utiliser scala, sa syntaxe est similaire et elle est probablement plus puissante que linq.

Comme en 2014, je peux enfin dire que LINQ est enfin là en Java 8. Plus besoin de trouver une alternative à LINQ.

Maintenant que Java 8 prend en charge lambdas, il est possible de créer des API Java qui ressemblent 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 est basé sur cinq années de recherche sur l’utilisation de l’parsing par bytecode pour traduire Java en requêtes de firebase database. Semblable à la façon dont C-LINQ est une couche de requête située au-dessus de Entity Framework, Jinq peut agir en tant que couche de requête par-dessus 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 .

La solution de type AC # est JaQue , qui fournit des arborescences d’expression pour Java Lambdas. En plus de cela peuvent être implémentés des fournisseurs LINQ spécifiques au domaine.

Voir SBQL4J . C’est un langage de requête robuste, sans risque de type, intégré à Java. Permet d’écrire des requêtes nestedes compliquées et multiples. Il y a beaucoup d’opérateurs, les méthodes Java peuvent être invoquées à l’intérieur des requêtes en tant que constructeurs. Les requêtes sont traduites en code Java pur (il n’y a pas de reflection lors de l’exécution), l’exécution est donc très rapide.

EDIT: Eh bien, jusqu’à présent, SBQL4J est la seule extension du langage Java qui offre des fonctionnalités de requête similaires à LINQ. Il existe des projets intéressants comme Quaere et JaQue, mais ce ne sont que des API, et non des extensions de syntaxe / sémantique avec une sécurité de type forte au moment de la compilation.

J’ai essayé les bibliothèques de goyaves depuis Google. Il a une FluentIterable que je pense proche de LINQ. Voir aussi FunctionalExplained .

 List parts = new ArrayList(); // add parts to the collection. FluentIterable partsStartingA = FluentIterable.from(parts).filter(new Predicate() { @Override public boolean apply(final Ssortingng input) { return input.startsWith("a"); } }).transform(new Function() { @Override public Integer apply(final Ssortingng input) { return input.length(); } }); 

Semble être une bibliothèque étendue 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 testList = new ArrayList<>(); 

de type

 class Dto { private int id; private Ssortingng text; public int getId() { return id; } public int getText() { return text; } } 

Filtre

Java 7

 Filter query = CQ.filter(testList) .where() .property("id").eq().value(1); Collection filtered = query.list(); 

Java 8

 Filter query = CQ.filter(testList) .where() .property(Dto::getId) .eq().value(1); Collection filtered = query.list(); 

Aussi,

 Filter query = CQ.filter() .from(testList) .where() .property(Dto::getId).between().value(1).value(2) .and() .property(Dto::grtText).in().value(new ssortingng[]{"a","b"}); 

Tri (également disponible pour Java 7)

 Filter query = CQ.filter(testList) .orderBy() .property(Dto::getId) .property(Dto::getName) Collection sorted = query.list(); 

Regroupement (également disponible pour Java 7)

 GroupQuery query = CQ.query(testList) .group() .groupBy(Dto::getId) Collection> grouped = query.list(); 

Jointures (également disponibles pour Java 7)

Donné,

 class LeftDto { private int id; private Ssortingng text; public int getId() { return id; } public int getText() { return text; } } class RightDto { private int id; private int leftId; private Ssortingng 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 Ssortingng text; public JoinedDto(int leftId,int rightId,Ssortingng 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 leftList = new ArrayList<>(); Collection rightList = new ArrayList<>(); 

Peut être rejoint comme,

 Collection results = CQ.query().from(leftList) .innerJoin(CQ.query().from(rightList)) .on(LeftFyo::getId, RightDto::getLeftId) .transformDirect(selection -> new JoinedDto(selection.getLeft().getText() , selection.getLeft().getId() , selection.getRight().getId()) ) .list(); 

Expressions

 Filter query = CQ.filter() .from(testList) .where() .exec(s -> s.getId() + 1).eq().value(2); 

Juste pour append une autre alternative: Java 6 a une solution pour les requêtes de firebase database sécurisées utilisant le package javax.persistence.criteria .

Cependant, je dois dire que ce n’est pas vraiment LINQ, car avec LINQ, vous pouvez interroger tout IEnumerable.

Il existe une très bonne bibliothèque que vous pouvez utiliser pour cela.

Situé ici: https://github.com/nicholas22/jpropel-light

Les Lambdas ne seront pas disponibles avant Java 8, donc leur utilisation est un peu différente et ne se sent pas aussi naturelle.

Il semble que le Linq dont tout le monde parle ici ne soit que LinqToObjects. Ce que je crois propose uniquement des fonctionnalités qui peuvent déjà être accomplies aujourd’hui en Java, mais avec une syntaxe vraiment laide.

Ce que je vois comme la véritable puissance de Linq dans .Net, c’est que les expressions lambda peuvent être utilisées dans un contexte nécessitant soit un délégué, soit une expression, puis être compilées dans la forme appropriée. C’est ce qui permet à des choses comme LinqToSql (ou autre chose que LinqToObjects) de fonctionner, et leur permet d’avoir une syntaxe identique à LinqToObjects.

Il semble que tous les projets mentionnés ci-dessus offrent uniquement 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 sont intégrés (Scala, Clojure, etc.) et vous pouvez obtenir des librairies supplémentaires pour les versions Java précédentes.

Scala (s’exécute sur la machine virtuelle Java) possède un access Slick

Vous pouvez essayer ma bibliothèque CollectionsQuery . Il permet d’exécuter des requêtes comme LINQ sur des collections d’objects. Vous devez passer un prédicat, comme dans LINQ. Si vous utilisez java6 / 7, vous devez utiliser une ancienne syntaxe avec des interfaces:

 List names = Queryable.from(people) .filter(new Predicate() { public boolean filter(Person p) { return p.age>20; } }) .map (new Converter() { public Integer convert(Person p) { return p.name; } }) .toList(); 

Vous pouvez aussi l’utiliser dans Java8, ou dans l’ancien Java avec RetroLambda et son plugin gradle , vous aurez alors une nouvelle syntaxe de fantaisie:

 List names = Queryable.from(people) .filter(p->p.age>20) .map (p->p.name) .toList(); 

Si vous avez besoin d’exécuter des requêtes DB, vous pouvez regarder JINQ, comme mentionné ci-dessus, mais il ne peut pas être sauvegardé par RetroLambda, qui utilise des lambdas sérialisés.

Pour LINQ (LINQ to Objects), Java 8 aura quelque chose d’équivalent, voir Project Lambda .

Il a des extensions LINQ to Objects d’ Enumerable comme des trucs . Mais pour des choses LINQ plus complexes comme Expression et ExpressionTree (celles-ci sont nécessaires pour LINQ to SQL et les autres fournisseurs LINQ si elles veulent fournir quelque chose d’optimisé et de réel), il n’y a pas encore d’équivalent mais peut-être le verrons-nous à l’avenir 🙂

Mais je ne pense pas qu’il y aura quelque chose comme les requêtes déclaratives sur Java à l’avenir.

Il n’y a pas de telle fonctionnalité dans Java. En utilisant l’autre API, vous obtiendrez cette fonctionnalité. Comme si nous avions un object animal contenant un nom et un identifiant. Nous avons un object liste ayant des objects animaux. Maintenant, si nous voulons obtenir tout le nom de l’animal qui contient «o» de l’object liste. nous pouvons écrire la requête suivante

from(animals).where("getName", contains("o")).all();

Au-dessus de la déclaration de requête listera les animaux qui contiennent 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

Découvrez minuscule-q . (Notez que vous ne pouvez actuellement pas le télécharger.)

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

 Ssortingng[] ssortingngs = { "bla", "mla", "bura", "bala", "mura", "buma" }; 

Maintenant, nous voulons sélectionner uniquement les chaînes qui commencent par “b”:

 Query ssortingngsStartingWithB = new Query(ssortingngs).where( new Query.Func(){ public Boolean run(Ssortingng in) { return in.startsWith("b"); } } ); 

Aucune donnée réelle déplacée copiée ou quelque chose comme ça, elle sera traitée dès que vous commencez à l’itérer:

 for(Ssortingng ssortingng : ssortingngsStartingWithB ) { System.out.println(ssortingng); } 

JaQu est l’équivalent LINQ pour Java. Bien qu’il ait été développé pour la firebase database H2, il devrait fonctionner pour toutes les bases de données car il utilise JDBC.

Peut-être pas la réponse que vous espérez, mais si une partie de votre code nécessite un gros travail sur les collections (recherche, sorting, filtrage, transformations, parsing), vous pouvez envisager d’écrire des cours en Clojure ou Scala .

En raison de leur nature fonctionnelle, travailler avec des collections est ce qu’ils préfèrent. Je n’ai pas beaucoup d’expérience avec Scala, mais avec Clojure, vous trouverez probablement un Linq plus puissant au bout de vos doigts et une fois compilé, les classes que vous produiriez s’intégreraient de manière transparente au rest de la base de code.

Un utilisateur anonyme en a mentionné un autre,

Diting est une bibliothèque de classes qui fournit des fonctionnalités de requête sur les collections via des méthodes chaînables et une interface anonyme telle que Linq dans .NET. Contrairement à la plupart des autres bibliothèques de collections, celles qui utilisent des méthodes statiques ont besoin d’itérer une collection entière, Diting fournit une classe Enumerable de base qui contient des méthodes chaînables différées pour implémenter une requête sur une collection ou un tableau.

Méthodes sockets en charge: any, cast, contact, contient, count, distinct, elementAt, sauf premier, firstOrDefault, groupBy, interset, jointure, lastOrDefault, ofType, orderBy, orderByDescending, reverse, select, selectMany, single, singleOrDefault, skip , skipWhile, take, takeWhile, toArray, toArrayList, union, où

en plus de ceux donnés, on pourrait aussi regarder:

https://github.com/julien-may/ch.julien/tree/master/query

Scala.Maintenant, je le lis, et l’a trouvé comme linq mais plus simple et plus illisible. mais Scala peut fonctionner à Linux, oui? csharp besoin de mono.

Il y avait le langage de programmation Pizza (une extension Java) et vous devriez y jeter un coup d’oeil. – Il utilise le concept “d’interfaces fluides” pour interroger les données de manière déclarative et qui est en principe identique à LINQ sans expressions de requête (http://en.wikipedia.org/wiki/Pizza_programming_language). Mais hélas, cela n’a pas été poursuivi, mais cela aurait été un moyen d’obtenir quelque chose de similaire à LINQ dans Java.

Pas vraiment un équivalent “Linq to SQL” pour Java. mais quelque chose de proche. Requête DSL