Quel est L'équivalent Java pour LINQ? [fermé]
30 réponses
Il N'y a rien de tel que LINQ pour Java.
...
Modifier
Maintenant, avec Java 8, nous sommes introduits dans l'API Stream , c'est un genre de chose similaire lorsqu'il s'agit de 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, alors vous pouvez essayer Hibernate
:-)
Il existe une solution alternative, 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 lib vous aidera. C'est vraiment simple à utiliser et à étendre, 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 Lambdas sont maintenant disponibles dans Java 8 sous la forme d'Expressions JSR-335 - Lambda pour le langage de programmation JavaTM
Mise à jour: JDK8 a maintenant été publié {[2] } qui contient le projet lambda. Cela vaut la peine de saisir une copie de Java 8 en Action actuellement encore MEAP.
Avoir une lecture de Brian Goetz articles relatifs à lambdas pour une compréhension décente de la façon dont les lambdas sont implémentés dans JDK8 tout en gagnant un compréhension des flux, itération interne, court-circuit et références constructeur.. 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é la puissance de la flèche , aussi NetBeans 8 a un grand support pour convertir des constructions en JDK8 que j'ai également blogué sur migrer 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 a quelques avantages par rapport à la bibliothèque Quaere car il n'utilise aucune chaîne magique, il est complètement sûr de type et à mon avis il offre un DSL plus lisible.
Vous ne trouverez pas D'équivalent de LINQ sauf si vous utilisez le javacc pour créer votre propre équivalent.
Jusqu'à ce jour où quelqu'un trouve un moyen viable de le faire, il existe de bonnes alternatives, telles que
- jOOQ: http://www.jooq.org
- JINQ: http://www.jinq.org
- JaQue: http://github.com/TrigerSoft/jaque
- JaQu: http://www.h2database.com/html/jaqu.html
- Linq4j: https://github.com/julianhyde/linq4j
- Quaere: http://quaere.codehaus.org/
- QueryDSL: http://www.querydsl.com
- JSR-341: http://java.net/projects/el-spec/pages/CollectionOperations
LINQ aux objets - JAVA 8 a ajouté L'API Stream qui ajoute la prise en charge des opérations de style fonctionnel sur les flux de valeurs:
Java 8 expliqué: application de Lambdas aux Collections Java
LINQ à SQL / NHibernate / etc. (interrogation de base de données) - une option serait d'utiliser JINQ qui utilise également les nouvelles fonctionnalités de JAVA 8 et 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 une base de données les requêtes en Java. Vous pouvez traiter les données de base de données comme des objets Java stocké dans des collections. Vous pouvez itérer sur eux et les filtrer en utilisant commandes Java normales, et tout votre code sera automatiquement traduit en requêtes de base de données optimisées. Enfin, de style LINQ les requêtes sont disponibles pour Java!
Site du projet JINQ: http://www.jinq.org/
Il existe de nombreux équivalents LINQ pour Java, voir ici pour une comparaison.
Pour un framework de style Typesafe Quaere/LINQ, pensez à utiliser Querydsl . Querydsl prend en charge les Collections JPA / Hibernate, JDO, SQL et Java.
Je suis le mainteneur de Querydsl, donc cette réponse est biaisée.
Vous pouvez utiliser scala, il est similaire dans la syntaxe et il est en fait probablement plus puissant que linq.
Comme sur 2014, je peux enfin dire que LINQ est enfin là en java 8.So 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 étroitement à 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 ans de recherche sur l'utilisation de l'analyse bytecode pour traduire Java en requêtes de base de données. Similaire à la façon dont d-LINQ de C#est une couche de requête qui se trouve au-dessus de L'Entity Framework, Jinq est capable d'agir comme une couche de requête assise au-dessus de JPA ou jOOQ. Il a prise en charge de l'agrégation, des groupes et des sous-requêtes. Même Erik Meijer (le créateur de LINQ) a reconnu Jinq .
Une solution de type C#est JaQue , qui fournit des arbres D'Expression pour Java Lambdas. En plus de cela peut être mis en œuvre des fournisseurs LINQ spécifiques au domaine.
Voir SBQL4J . C'est un langage de requête fort sécurisé intégré à Java. Permet d'écrire des requêtes imbriquées compliquées et multipliées. Il y a beaucoup d'opérateurs, les méthodes Java peuvent être invoquées dans les requêtes en tant que constructeurs. Les requêtes sont traduites en code Java pur (il n'y a pas de réflexion à 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 quelques intéressants projet comme Quaere et JaQue mais ils ne sont que des API, pas une extension Syntaxe / sémantique avec une sécurité de type forte au moment de la compilation.
J'ai essayé goyave, les bibliothèques à partir de google. Il a un 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 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<Dto> testList = new ArrayList<>();
Du 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 Java 7)
Filter<Dto> query = CQ.<Dto>filter(testList)
.orderBy()
.property(Dto::getId)
.property(Dto::getName)
Collection<Dto> sorted = query.list();
Regroupement (également disponible pour 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 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ées par type en utilisant le javax.persistance.critères Paquet.
Bien que je dois dire que ce N'est pas vraiment LINQ, car avec LINQ vous pouvez interroger N'importe quel IEnumerable.
Il y a une très bonne bibliothèque que vous pouvez utiliser pour cela.
Trouve ici: https://github.com/nicholas22/jpropel-light
Lambdas ne sera pas disponible avant Java 8, donc l'utiliser est un peu différent et ne semble pas aussi naturel.
On dirait que le Linq dont tout le monde parle ici est juste LinqToObjects. Ce qui, je crois, 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 la puissance réelle 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 choses comme LinqToSql (ou autre chose que LinqToObjects) de travail, et leur permet d'avoir une syntaxe identique à LinqToObjects.
Il semble que tous les projets mentionnés ci-dessus n'offrent que les capacités de LinqToObjects. Ce qui me fait dire que la fonctionnalité de type LinqToSql n'est pas à L'horizon pour Java.
Pour les collections fonctionnelles de base, Java 8 l'a intégré, la plupart des principaux langages JVM non-Java l'ont intégré (Scala, Clojure, etc.), et vous pouvez obtenir des bibliothèques supplémentaires pour les versions Java antérieures.
Pour un accès intégré en langage complet à une base de données SQL, Scala (s'exécute sur la JVM) a Slick
Vous pouvez essayer ma bibliothèque CollectionsQuery. Il permet D'exécuter des requêtes de type LINQ sur des collections d'objets. Vous devez passer le prédicat, tout comme dans LINQ. Si vous utilisez java6 / 7, vous devez utiliser l'ancienne syntaxe avec les 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 aussi l'utiliser dans Java8, ou dans le vieux-java avec RetroLambda et gradle plugin, alors vous aurez de nouveaux fantaisie syntaxe:
List<String> names = Queryable.from(people)
.filter(p->p.age>20)
.map (p->p.name)
.toList();
Si vous avez besoin d'exécuter DB queryes, que vous pouvez regarder sur JINQ, comme mentionné ci-dessus, mais il ne peut pas être porté par RetroLambda, doe pour utiliser des lambdas sérialisés.
Pour LINQ (LINQ to Objects), Java 8 aura quelque chose d'équivalent, voir Project Lambda.
Il a Enumerable LINQ aux extensions D'objets comme étoffes. Mais pour des choses LINQ plus compliquées comme Expression et ExpressionTree (celles-ci sont nécessaires pour LINQ to SQL et d'autres fournisseurs LINQ s'ils veulent fournir quelque chose d'optimisé et réel), il n'y a pas encore d'équivalent mais peut-être que nous verrons cela à l'avenir:)
, Mais je ne pense pas qu'il y sera quelque chose comme des requêtes déclaratives sur Java à l'avenir.
Il N'y a pas une telle fonctionnalité en java. En utilisant l'autre API, vous obtiendrez cette fonctionnalité. Comme supposons que nous ayons un objet animal contenant le nom et l'id. Nous avons un objet de liste ayant des objets animaux. Maintenant, si nous voulons obtenir tout le nom de l'animal qui contient 'o' de l'objet list. nous pouvons écrire la requête suivante
from(animals).where("getName", contains("o")).all();
L'instruction de requête ci-dessus listera les animaux qui contiennent l'alphabet 'o' dans leur nom. Plus d'informations veuillez passer par ce qui suit blog. 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:
Nous avons D'abord 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 copiée ou quelque chose comme ça, elle sera traitée dès que vous commencerez à itérer:
for(String string : stringsStartingWithB ) {
System.out.println(string);
}
JaQu est L'équivalent de 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.
Peut-être pas la réponse que vous espérez, mais si une partie de votre code a besoin d'un travail lourd sur les collections (recherche, tri, filtrage, transformations, analyse), vous pouvez prendre en considération pour écrire des classes dans Clojure ou Scala.
En raison de leur nature fonctionnelle, travailler avec des collections est ce qu'ils font de mieux. Je n'ai pas beaucoup d'expérience avec Scala, mais avec Clojure, vous trouverez probablement un Linq plus puissant à portée de main et une fois compilé, le les classes que vous produiriez intégreraient seamlessy avec le reste de la base de code.
Un utilisateur anonyme a mentionné un autre, Diting:
Diting est une bibliothèque de classes fournit des capacité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 collections, ceux qui utilisent des méthodes statiques doivent itérer toute la collection, Diting fournit une classe énumérable de base.
Méthodes prises en charge: tout, fonte, contact, contient, le comte, distinctes, elementAt, à l'exception, le premier, firstOrDefault, groupBy, interset, de rejoindre dernière, lastOrDefault, ofType, orderBy, orderByDescending, inverse, de sélectionner, de selectMany, unique, singleOrDefault, sauter, skipWhile, de prendre, de takeWhile, toArray, toArrayList, de l'union, où
Scala.Maintenant, je l'ai lu, et je l'ai trouvé comme linq mais plus simple et plus illisible. mais scala peut fonctionner sous linux, Oui? Csharp besoin mono.
Il y avait le langage de programmation Pizza (une extension Java) et vous devriez y jeter un 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, il n'a pas été poursuivi, mais il aurait été un moyen d'obtenir quelque chose de similaire à LINQ en Java.
Pas vraiment un équivalent "Linq to SQL" pour Java. mais quelque chose de proche . requête DSL