definicion - linq java 8
¿Cuál es el equivalente de Java para LINQ? (30)
¿Cuál es el equivalente de Java para LINQ?
Ahora que Java 8 es compatible con lambdas, es posible crear API de Java que se parezcan mucho a LINQ.
http://www.jinq.org/ 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 de análisis de código de bytes para traducir Java a consultas de base de datos. De manera similar a cómo D-LINQ de C # es una capa de consulta que se encuentra en la parte superior del Entity Framework, Jinq puede actuar como una capa de consulta sobre la JPA o jOOQ. Tiene soporte para agregación, grupos y subconsultas. Incluso Erik Meijer (el creador de LINQ) ha reconocido a Jinq .
Al igual que en 2014, finalmente puedo decir que LINQ finalmente está allí en Java 8. Así que ya no es necesario encontrar una alternativa a LINQ.
Echa un vistazo a tiny-q . (Tenga en cuenta que actualmente no puede descargarlo).
Aquí hay un ejemplo adaptado al enlace de arriba:
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 han copiado datos reales ni nada por el estilo, se procesarán tan pronto como comience la iteración:
for(String string : stringsStartingWithB ) {
System.out.println(string);
}
Estaba el lenguaje de programación Pizza (una extensión de Java) y deberías 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 fue perseguido, pero habría sido una forma de obtener algo similar a LINQ en Java.
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 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 su uso es un poco diferente y no se siente tan natural.
Hay una solución alternativa, Coollection .
Coolection no pretende ser el nuevo lambda, sin embargo, estamos rodeados de antiguos proyectos Java heredados donde esta biblioteca ayudará. Es realmente fácil de usar y extender, cubriendo solo las acciones más utilizadas de iteración sobre colecciones, como eso:
from(people).where("name", eq("Arthur")).first();
from(people).where("age", lessThan(20)).all();
from(people).where("name", not(contains("Francine"))).all();
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 usa JDBC.
La solución similar a AC # es JaQue , que proporciona Árboles de Expresión para Java Lambdas. Además de esto se pueden implementar proveedores LINQ de dominio específico.
No hay equivalente a LINQ para Java. Pero hay algunas de las API externas que se parecen a LINQ, como https://github.com/nicholas22/jpropel-light , https://code.google.com/p/jaque/
No hay nada como LINQ para Java.
...
Editar
Ahora, con Java 8 se nos presenta el Stream API , esto es algo similar cuando se trata de colecciones, pero no es lo mismo que Linq.
Si lo que busca es un ORM, como Entity Framework, puede probar Hibernate
:-)
No hay tal característica en java. Al usar la otra API obtendrás esta característica. Supongamos que tenemos un objeto animal que contiene nombre e id. Tenemos lista de objetos que tienen objetos de animales. Ahora si queremos obtener el nombre de todos los animales que contiene ''o'' del objeto de lista. podemos escribir la siguiente consulta
from(animals).where("getName", contains("o")).all();
La declaración anterior de la consulta incluirá una lista de los animales que contienen el alfabeto ''o'' en su nombre. Más información por favor vaya a través del siguiente blog. http://javaworldwide.blogspot.in/2012/09/linq-in-java.html
Para LINQ (LINQ to Objects), Java 8 tendrá algo equivalente, vea Proyecto Lambda .
Tiene las extensiones de LINQ to Objects de Enumerable como productos. Pero para cosas LINQ más complicadas como Expression y ExpressionTree (son necesarias para LINQ to SQL y otros proveedores de LINQ si desean proporcionar algo optimizado y real), aún no hay un equivalente, pero tal vez lo veremos en el futuro :)
Pero no creo que haya nada como consultas declarativas en Java en el futuro.
Para las colecciones funcionales básicas, Java 8 lo tiene incorporado, la mayoría de los principales lenguajes JVM que no son Java lo tienen integrado (Scala, Clojure, etc.), y puede agregar libs para las versiones anteriores de Java.
Para el acceso integrado a un lenguaje completo a una base de datos SQL, Scala (se ejecuta en la JVM) tiene Slick
Parece que el Linq del que todos hablan aquí es solo LinqToObjects. 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 apropiada. Esto es lo que permite que funcionen cosas como LinqToSql (o cualquier otra cosa que no sea LinqToObjects), 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.
Probé guava-libraries de google. Tiene un FluentIterable que creo que está cerca de LINQ. También vea 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 breve como LINQ pero parece interesante.
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 utiliza ninguna cadena mágica, es completamente segura y, en mi opinión, ofrece un DSL más legible.
Puedes probar mi biblioteca CollectionsQuery . Permite ejecutar consultas tipo LINQ sobre colecciones de objetos. Tienes que pasar predicado, al igual que en LINQ. Si está utilizando java6 / 7, tiene que usar una sintaxis antigua con 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 puedes usarlo en Java8, o en Java antiguo con RetroLambda y su plugin de gradle , entonces tendrás una nueva sintaxis de lujo:
List<String> names = Queryable.from(people)
.filter(p->p.age>20)
.map (p->p.name)
.toList();
Si necesita ejecutar consultas de base de datos, puede buscar en JINQ, como se mencionó anteriormente, pero RetroLambda no puede realizar una copia de seguridad, para el uso de lambdas serializadas.
Scala.Ahora la estrella lo leí, y lo encontré como linq pero más simple y más ilegible. Pero Scala puede correr en Linux, ¿sí? csharp necesita mono.
Solo para agregar otra alternativa: Java 6 tiene una solución para consultas de base de datos de tipo seguro utilizando el paquete javax.persistence.criteria .
Aunque debo decir que esto no es realmente LINQ, porque con LINQ puede consultar cualquier IEnumerable.
Tal vez no sea la respuesta que está esperando, pero si alguna parte de su código necesita un trabajo pesado en las colecciones (búsqueda, clasificación, filtrado, transformaciones, análisis), puede considerar tomar algunas clases en Clojure o Scala .
Debido a su naturaleza funcional, trabajar con colecciones es lo que hacen mejor. No tengo mucha experiencia con Scala, pero con Clojure probablemente encontrarás un Linq más poderoso al alcance de tu mano y, una vez compilado, las clases que producirás se integrarán perfectamente con el resto de la base de código.
Un usuario anónimo mencionó a otro, Diting :
Diting es una biblioteca de clases que proporciona capacidades de consulta en colecciones a través de métodos utilizables e interfaz anónima como Linq en .NET. A diferencia de la mayoría de las demás bibliotecas de colecciones, las que utilizan métodos estáticos necesitan una colección completa iterativa, Diting proporciona una clase Enumerable central que contiene métodos distintos y diferibles para implementar consultas en la colección o matriz.
Métodos admitidos: cualquiera, conversión, contacto, contiene, contar, diferenciado, elementAt, excepto, first, FirstOrDefault, groupBy, interset, join, last, LastOrDefault, ofType, orderBy, orderByDescending, reverse, select, selectMany, singleOrDefault, skip , skipWhile, take, takeWhile, toArray, toArrayList, union, donde
Ver SBQL4J . Es un lenguaje de consulta fuerte y seguro con el tipo integrado con Java. Permite escribir consultas complicadas y multiplicar anidadas. Hay una gran cantidad de operadores, los métodos de Java se pueden invocar dentro de las consultas, así como los constructores. Las consultas se convierten a código Java puro (no hay reflejo en el tiempo de ejecución), por lo que la ejecución es muy rápida.
EDIT: Bueno, hasta ahora SBQL4J es la ÚNICA extensión para el lenguaje Java que proporciona capacidades de consulta similares a LINQ. Hay algunos proyectos interesantes como Quaere y JaQue, pero solo son API, no una extensión de sintaxis / semántica con una seguridad de tipo fuerte en tiempo de compilación.
puede probar esta biblioteca: https://code.google.com/p/qood/
Aquí hay algunas razones para usarlo:
- ligero: solo 9 de interfaz / clase pública para aprender.
- consulta como SQL: soporte agrupación, ordenamiento, unión izquierda, fórmula, ... etc.
- para big data: use File (QFS) en lugar de Heap Memory.
- tratar de resolver el desajuste de impedancia relacional de objetos .
puedes usar scala, es similar en sintaxis y en realidad es probablemente más poderoso que linq.
Las Lambdas ahora están disponibles en Java 8 en la forma JSR-335 - Expresiones Lambda para el lenguaje de programación JavaTM
ACTUALIZACIÓN : JDK8 ahora ha sido lanzado que contiene el proyecto lambda. Vale la pena obtener una copia de Java 8 en Acción que todavía está en MEAP.
Lea los artículos de Brian Goetz relacionados con las lambdas para comprender mejor cómo se implementan las lambdas dentro de JDK8 y, al mismo tiempo, comprenda las corrientes, la iteración interna, el cortocircuito y las referencias de los constructores. 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 , además, NetBeans 8 tiene un gran soporte para convertir construcciones a JDK8, que también escribí sobre Migrating to JDK 8 con NetBeans .
https://code.google.com/p/joquery/
Soporta diferentes posibilidades,
Colección dada,
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();
Uniones (también disponibles 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);
LINQ to Objects - JAVA 8 ha agregado la API Stream que agrega soporte para operaciones de estilo funcional en flujos de valores:
Explicación de Java 8: Aplicación de Lambdas a colecciones Java
LINQ to SQL / NHibernate / etc. (consulta de la base de datos) : una opción sería usar JINQ, que también usa las nuevas características 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 recorrerlos y filtrarlos utilizando los comandos normales de Java, y todo su código se traducirá automáticamente en consultas de base de datos optimizadas. Finalmente, ¡las consultas de estilo LINQ están disponibles para Java!
Sitio del proyecto JINQ: http://www.jinq.org/