¿Cuál es el equivalente de Java para LINQ? [cerrado]

¿Qué es el equivalente de Java para LINQ?

No hay nada como LINQ para Java.

...

Editar

Ahora, con Java 8, se nos presenta la API Stream , este es un tipo similar de cosas cuando se trata de colecciones, pero no es lo mismo que Linq.

Si está buscando un ORM, como Entity Framework, puede probar Hibernate

:-)

Hay una solución alternativa, Coollection .

Coolection no ha pretendido ser el nuevo lambda, sin embargo, estamos rodeados de viejos proyectos Java heredados donde esta lib ayudará. Es realmente simple de usar y extender, cubriendo solo las acciones más utilizadas de iteración sobre colecciones, así:

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

Las Lambdas ahora están disponibles en Java 8 en forma de JSR-335 - Expresiones de Lambda para el lenguaje de programación JavaTM

ACTUALIZACIÓN : JDK8 ahora se ha lanzado que contiene el proyecto lambda. Vale la pena agarrar una copia de Java 8 en acción actualmente MEAP.

Lea los artículos de Brian Goetz relacionados con lambdas para obtener una comprensión decente de cómo se implementan las lambdas dentro de JDK8 y al mismo tiempo obtener una comprensión de las secuencias, la iteración interna, el cortocircuito y las referencias del constructor. También consulte los JSR anteriores para obtener más ejemplos .

He escrito un blog sobre algunas de las ventajas de usar lambdas en JDK8 llamado The Power of the Arrow , también NetBeans 8 tiene un gran soporte para convertir construcciones a JDK8, que también he blogueado sobre Migrar a JDK 8 con NetBeans .

Puede seleccionar los elementos de una colección (y mucho más) de una manera más legible utilizando la biblioteca lambdaj

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

Tiene algunas ventajas sobre la biblioteca Quaere porque no usa ninguna cadena mágica, es completamente segura y, en mi opinión, ofrece un DSL más legible.

No encontrará un equivalente de LINQ a menos que use el javacc para crear su propio equivalente.

Hasta ese día, cuando alguien encuentra una manera viable de hacerlo, hay algunas buenas alternativas, como

• jOOQ
• Jinq
• JaQue
• JaQu
• Linq4j
• Quaere (ya no se mantiene)
• Consulta DSL
• JSR-341

LINQ to Objects : JAVA 8 ha agregado la API Stream que agrega soporte para operaciones de estilo funcional en flujos de valores:

Paquete java.util.stream

Explicación de Java 8: aplicación de Lambdas a colecciones de Java

LINQ to SQL / NHibernate / etc. (consulta de base de datos) : una opción sería utilizar JINQ, que también utiliza las nuevas funciones de JAVA 8 y se lanzó el 26 de febrero de 2014 en Github: https://github.com/my2iu/Jinq

Jinq proporciona a los desarrolladores una forma fácil y natural de escribir consultas de bases de datos en Java. Puede tratar los datos de la base de datos como objetos Java normales almacenados en colecciones. Puede iterar sobre ellos y filtrarlos utilizando comandos Java normales, y todo su código se traducirá automáticamente en consultas optimizadas de la base de datos. ¡Finalmente, las consultas de estilo LINQ están disponibles para Java!

Sitio del proyecto JINQ: http://www.jinq.org/

Hay un proyecto llamado quaere .

Es un marco de Java que agrega la capacidad de consultar colecciones.

Nota: Según el autor, el proyecto ya no se mantiene.

Hay muchos equivalentes de LINQ para Java, vea aquí para una comparación.

Para un marco de estilo Quaere / LINQ seguro de tipo, considere usar Querydsl . Querydsl admite colecciones JPA / Hibernate, JDO, SQL y Java.

Soy el mantenedor de Querydsl, por lo que esta respuesta es parcial.

puedes usar scala, es similar en sintaxis y en realidad es probablemente más poderoso que linq.

Como en 2014, finalmente puedo decir que LINQ finalmente está allí en Java 8. Así que ya no es necesario encontrar una alternativa de LINQ.

Ahora que Java 8 admite lambdas, es posible crear API Java que se parezcan mucho a LINQ.

Jinq es una de estas nuevas bibliotecas de estilo LINQ para Java.

Soy el desarrollador de esta biblioteca. Se basa en cinco años de investigación sobre el uso del análisis de bytecode para traducir Java a consultas de bases de datos. Al igual que D-LINQ de C # es una capa de consulta que se encuentra en la parte superior de Entity Framework, Jinq puede actuar como una capa de consulta que se encuentra en la parte superior de JPA o jOOQ. Tiene soporte para agregación, grupos y subconsultas. Incluso Erik Meijer (el creador de LINQ) ha reconocido a Jinq .

Ver SBQL4J . Es un lenguaje de consulta seguro de tipo seguro integrado con Java. Permite escribir consultas complicadas y múltiples anidadas. Hay muchos operadores, los métodos Java pueden invocarse dentro de las consultas como constructores. Las consultas se traducen a código Java puro (no hay reflejo en tiempo de ejecución), por lo que la ejecución es muy rápida.

EDITAR: Bueno, hasta ahora SBQL4J es la ÚNICA extensión al lenguaje Java que brinda capacidades de consulta similares a LINQ. Hay algunos proyectos interesantes como Quaere y JaQue, pero son solo API, no extensiones de sintaxis / semántica con seguridad de tipo fuerte en tiempo de compilación.

Implementación de Java LINQ to SQL . Proporciona integración completa de idiomas y un conjunto de características más amplio en comparación con .NET LINQ.

Intenté guava-bibliotecas de google. Tiene uno FluentIterableque creo que está cerca de LINQ. Ver también 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();
        }
    });

Parece ser una extensa biblioteca para Java. Ciertamente no es tan sucinto como LINQ pero parece interesante.

https://code.google.com/p/joquery/

Admite diferentes posibilidades,

Dada la colección,

Collection<Dto> testList = new ArrayList<>();

de tipo,

class Dto
{
    private int id;
    private String text;

    public int getId()
    {
        return id;
    }

    public int getText()
    {
        return text;
    }
}

Filtrar

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

También,

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"});

Clasificación (también disponible para Java 7)

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

Agrupación (también disponible para Java 7)

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

Se une (también disponible para Java 7)

Dado,

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

Se puede unir como,

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

Expresiones

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

Puedes probar mi biblioteca CollectionsQuery . Permite ejecutar LINQ como consultas sobre colecciones de objetos. Tienes que pasar predicado, al igual que en LINQ. Si está utilizando java6 / 7, debe utilizar una sintaxis antigua con las 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();

También puede usarlo en Java8, o en Java antiguo con RetroLambda y su complemento de gradle , entonces tendrá una nueva sintaxis elegante:

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

Si necesita ejecutar consultas de base de datos, entonces puede mirar en JINQ, como se mencionó anteriormente, pero RetroLambda no puede hacer una copia de seguridad del puerto, para usar lambdas serializadas.

Solo para agregar otra alternativa: Java 6 tiene una solución para consultas de bases de datos seguras con el paquete javax.persistence.criteria .

Aunque debo decir que esto no es realmente LINQ, porque con LINQ puedes consultar cualquier IEnumerable.

Hay una muy buena biblioteca que puedes usar para esto.

Ubicado aquí: https://github.com/nicholas22/jpropel-light

Sin embargo, Lambdas no estará disponible hasta Java 8, por lo que usarlo es un poco diferente y no parece tan natural.

Parece que el Linq del que todos hablan aquí es solo LinqToObjects. Lo que creo que solo ofrece una funcionalidad que ya se puede lograr hoy en Java, pero con una sintaxis realmente fea.

Lo que veo como el verdadero poder de Linq en .Net es que las expresiones lambda se pueden usar en un contexto que requiere un Delegado o una Expresión y luego se compilarán en la forma adecuada. Esto es lo que permite que cosas como LinqToSql (o cualquier otra cosa que no sea LinqToObjects) funcionen, y les permite tener una sintaxis idéntica a LinqToObjects.

Parece que todos los proyectos mencionados anteriormente solo ofrecen las capacidades de LinqToObjects. Lo que me hace pensar que la funcionalidad de tipo LinqToSql no está en el horizonte para Java.

Para las colecciones funcionales básicas, Java 8 lo tiene incorporado, la mayoría de los principales lenguajes JVM no Java lo tienen incorporado (Scala, Clojure, etc.), y puede agregar libs para versiones anteriores de Java.

Para el acceso integrado de lenguaje completo a una base de datos SQL, Scala (se ejecuta en la JVM) tiene Slick

Para LINQ (LINQ to Objects), Java 8 tendrá algo equivalente, vea Proyecto Lambda .

Tiene extensiones de LINQ to Objects de Enumerable como cosas . Pero para cosas LINQ más complicadas como Expression y ExpressionTree (estas son necesarias para LINQ to SQL y otros proveedores de LINQ si quieren proporcionar algo optimizado y real), todavía no hay ningún equivalente, pero tal vez lo veremos en el futuro :)

Pero no creo que haya nada como consultas declarativas en Java en el futuro.

No existe tal característica en Java. Al usar la otra API obtendrá esta característica. Como supongamos que tenemos un objeto animal que contiene nombre e id. Tenemos una lista de objetos con objetos animales. Ahora si queremos obtener todo el nombre del animal que contiene 'o' del objeto de la lista. podemos escribir la siguiente consulta

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

La declaración de consulta anterior enumerará los animales que contienen el alfabeto 'o' en su nombre. Más información por favor vaya al siguiente blog. http://javaworldwide.blogspot.in/2012/09/linq-in-java.html

Echa un vistazo a tiny-q . (Tenga en cuenta que actualmente no puede descargarlo).

Aquí hay un ejemplo adaptado el enlace anterior:

Primero necesitamos una recopilación de algunos datos, digamos un conjunto de cadenas

String[] strings = { "bla", "mla", "bura", "bala", "mura", "buma" };

Ahora queremos seleccionar solo las cadenas que comienzan con "b":

Query<String> stringsStartingWithB = new Query<String>(strings).where(
    new Query.Func<String, Boolean>(){
        public Boolean run(String in) {
            return in.startsWith("b");
        }
    }
);

No se copió ningún dato real ni nada por el estilo, se procesará tan pronto como comience a iterar:

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

JaQu es el equivalente de LINQ para Java. Aunque fue desarrollado para la base de datos H2, debería funcionar para cualquier base de datos ya que utiliza JDBC.

Tal vez no sea la respuesta que espera, pero si alguna parte de su código necesita un trabajo pesado en las colecciones (búsqueda, clasificación, filtrado, transformaciones, análisis), puede tomar en consideración escribir algunas clases en Clojure o Scala .

Debido a su naturaleza funcional, trabajar con colecciones es en lo que son mejores. No tengo mucha experiencia con Scala, pero con Clojure probablemente encontrarás un Linq más potente a tu alcance y, una vez compiladas, las clases que producirías se integrarían perfectamente con el resto de la base de código.

Un usuario anónimo mencionó otro, Diting :

Diting es una biblioteca de clases que proporciona capacidades de consulta en colecciones a través de métodos encadenables y una interfaz anónima como Linq en .NET. A diferencia de la mayoría de las otras bibliotecas de colecciones que usan métodos estáticos necesitan iterar toda la colección, Diting proporciona una clase de Enumerable central que contiene métodos encadenables diferidos para implementar la consulta en la colección o matriz.

Métodos admitidos: any, cast, contact, contiene, count, distinct, elementAt, excepto, first, firstOrDefault, groupBy, interset, join, last, lastOrDefault, ofType, orderBy, orderByDescending, reverse, select, selectMany, single, singleOrDefault, skip , skipWhile, take, takeWhile, toArray, toArrayList, union, where

Scala. Ahora lo leí en estrella, y lo encontré como linq pero más simple y más ilegible. pero scala puede ejecutarse en linux, ¿sí? csharp necesita mono.

Estaba el lenguaje de programación Pizza (una extensión de Java) y debería echarle un vistazo. - Utiliza el concepto de "interfaces fluidas" para consultar datos de manera declarativa y, en principio, es idéntico a LINQ sin expresiones de consulta (http://en.wikipedia.org/wiki/Pizza_programming_language). Pero, por desgracia, no se persiguió, pero habría sido una forma de obtener algo similar a LINQ en Java.

No hay equivalente a LINQ para Java. Pero hay algunas API externas que se parecen a LINQ, como https://github.com/nicholas22/jpropel-light , https://code.google.com/p/jaque/

puedes probar esta biblioteca: https://code.google.com/p/qood/

Aquí hay algunas razones para usarlo:

1. ligero: solo 9 interfaces / clases públicas para aprender.
2. consulta como SQL: admite agrupar por, ordenar por, combinación izquierda, fórmula, ... etc.
3. para big data: use File (QFS) en lugar de Heap Memory.
4. intenta resolver la falta de coincidencia de impedancia relacional de objetos .