Quel est l'équivalent Java pour LINQ? [fermé]

Quel est l'équivalent Java pour LINQ?

Il n'y a rien de tel que LINQ pour Java.

...

Éditer

Maintenant, avec Java 8, nous sommes initiés à l' API Stream , c'est un genre similaire quand 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, 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 bibliothèque 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 ç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

MISE À JOUR : JDK8 a maintenant été publié qui contient le projet lambda. Cela vaut la peine de récupérer une copie de Java 8 en action actuellement encore MEAP.

Lisez les articles de Brian Goetz relatifs aux lambdas pour une compréhension décente de la façon dont les lambdas sont implémentés dans JDK8 tout en acquérant une compréhension des flux, des itérations internes, des courts-circuits et des références de 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é The Power of the Arrow , également NetBeans 8 a un excellent support pour convertir des constructions en JDK8 que j'ai également blogué sur la migration vers JDK 8 avec NetBeans .

Vous pouvez sélectionner les éléments d'une collection (et bien plus) 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 aucune chaîne magique, il est totalement sûr pour le type et à mon avis, il offre une DSL plus lisible.

Vous ne trouverez un équivalent de LINQ que 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
• JINQ
• JaQue
• JaQu
• Linq4j
• Quaere (n'est plus maintenu)
• QueryDSL
• JSR-341

LINQ to Objects - JAVA 8 a ajouté l'API Stream qui ajoute la prise en charge des opérations de style fonctionnel sur les flux de valeurs:

Paquet java.util.stream

Java 8 expliqué: application de Lambdas aux collections Java

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 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 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 Java normales, et tout votre code sera automatiquement traduit en requêtes de base de données 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.

Remarque: Selon l'auteur, le projet n'est plus maintenu.

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

Pour un cadre de style Quaere / LINQ typesafe, pensez à 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 il est probablement plus puissant que linq.

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

Maintenant que Java 8 prend en charge les 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 années de recherche sur l'utilisation de l'analyse de bytecode pour traduire Java en requêtes de base de données. Semblable à 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 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 . Il s'agit d'un langage de requête puissant de type sécurisé intégré à Java. Permet d'écrire des requêtes compliquées et multipliées imbriquées. Il y a beaucoup d'opérateurs, les méthodes Java peuvent être invoquées à l'intérieur des requêtes comme constructeurs. Les requêtes sont traduites en code Java pur (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 offre des capacités de requête similaires à LINQ. Il existe des projets intéressants comme Quaere et JaQue, mais ce ne sont que des API, pas une extension syntaxique / sémantique avec une sécurité de type élevée au moment de la compilation.

Implémentation de Java LINQ to SQL . Fournit une intégration linguistique complète et un ensemble de fonctionnalités plus large que .NET LINQ.

J'ai essayé les bibliothèques de goyaves de google. Il a un FluentIterablequi, je pense, est proche de LINQ. Voir également 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 complète 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,

Étant donné la collection,

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 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 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 rejoint 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);

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 un 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 également l'utiliser en Java8, ou en ancien java avec RetroLambda et son plugin gradle , 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 DB, vous pouvez regarder sur JINQ, comme mentionné ci-dessus, mais il ne peut pas être porté en arrière par RetroLambda, essayez d'utiliser des lambdas sérialisés.

Juste pour ajouter une autre alternative: Java 6 a une solution pour les requêtes de base de données de type sécurisé utilisant le package javax.persistence.criteria .

Bien que je doive 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

Les lambdas ne seront cependant pas disponibles avant Java 8, donc son utilisation est un peu différente et ne semble pas aussi naturelle.

On dirait que le Linq dont tout le monde parle ici n'est que 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 laide.

Ce que je considère comme la véritable puissance de Linq dans .Net, c'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 fonctionner, 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 penser 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 langue complète à une base de données SQL, Scala (s'exécute sur la JVM) a Slick

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

Il a les extensions LINQ to Objects d' Enumerable comme les trucs . 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 de réel), il n'y a pas encore d'équivalent mais nous verrons peut-être cela à l'avenir :)

Mais je ne pense pas qu'il y aura 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é. Par exemple, supposons que nous ayons un objet animal contenant un nom et un identifiant. Nous avons des objets de liste ayant des objets animaux. Maintenant, si nous voulons obtenir le nom de tout l'animal qui contient «o» de l'objet liste. nous pouvons écrire la requête suivante

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

La déclaration de requête ci-dessus répertorie les animaux qui contiennent l'alphabet «o» dans leur nom. Pour plus d'informations, veuillez consulter le blog suivant. http://javaworldwide.blogspot.in/2012/09/linq-in-java.html

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

Voici un exemple adapté du 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 à répéter:

for(String string : stringsStartingWithB ) {
    System.out.println(string);
}

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.

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 sur les collections (recherche, tri, filtrage, transformations, analyse), vous pouvez prendre en considération pour écrire certaines classes en Clojure ou Scala .

En raison de leur nature fonctionnelle, travailler avec les collections est leur spécialité. Je n'ai pas beaucoup d'expérience avec Scala, mais avec Clojure, vous trouveriez probablement un Linq plus puissant à portée de main et une fois compilé, les classes que vous produiriez s'intégreraient de manière transparente avec le reste de la base de code.

Un utilisateur anonyme en a mentionné un autre, Diting :

Diting est une bibliothèque de classes qui offre 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, celles qui utilisent des méthodes statiques doivent itérer toute la collection, 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 prises en charge: any, cast, contact, contains, count, distinct, elementAt, except, first, firstOrDefault, groupBy, interset, join, last, lastOrDefault, ofType, orderBy, orderByDescending, reverse, select, selectMany, single, singleOrDefault, skip , skipWhile, take, takeWhile, toArray, toArrayList, union, où

Scala.Maintenant, je l'ai lu et trouvé comme linq mais plus simple et plus illisible. mais scala peut fonctionner sous linux, oui? csharp a besoin de mono.

Il y avait le langage de programmation Pizza (une extension Java) et vous devriez y jeter un œil. - Il utilise le concept d '"interfaces fluentes" pour interroger les données de manière déclarative et qui est en principe identique aux expressions de requête LINQ sans 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 en Java.

Il n'y a pas d'équivalent à LINQ pour Java. Mais il y a une partie de l'API externe qui ressemble à LINQ comme https://github.com/nicholas22/jpropel-light , https://code.google.com/p/jaque/

vous pouvez essayer cette bibliothèque: https://code.google.com/p/qood/

Voici quelques raisons de l'utiliser:

1. léger: seulement 9 interface / classe publique à apprendre.
2. requête comme SQL: support group-by, order-by, left join, formula, ... etc.
3. pour les mégadonnées: utilisez File (QFS) au lieu de Heap Memory.
4. essayez de résoudre le décalage d'impédance relationnelle-objet .