LINQ的Java等价物是什么？ [关闭]-Java 学习之路

759

LINQ的Java等价物是什么？

30 回答

我试过谷歌的guava-libraries . 它有一个 FluentIterable ，我认为它接近LINQ . 另见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();
        }
    });

似乎是一个广泛的Java库 . 当然不像LINQ那样简洁，但看起来很有趣 .

回复于 2024-04-16T19:48:22+08:00

119

java中没有这样的功能 . 通过使用其他API，您将获得此功能 . 就像假设我们有一个包含name和id的动物对象 . 我们有列表对象有动物对象 . 现在，如果我们想从列表对象中获取包含'o'的所有动物名称 . 我们可以编写以下查询

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

上面的查询语句将列出其名称中包含'o'字母的动物 . 更多信息请浏览以下博客 . http://javaworldwide.blogspot.in/2012/09/linq-in-java.html

回复于 2024-04-16T19:48:22+08:00
99

有编程语言Pizza（Java扩展），你应该看看它 . - 它使用“流畅的接口”的概念以声明的方式查询数据，并且原则上与LINQ w / o查询表达式（http://en.wikipedia.org/wiki/Pizza_programming_language）相同 . 但唉，它没有被追求，但它可能是将LINQ转化为Java的一种方法 .

回复于 2024-04-16T19:48:22+08:00
2

只是添加另一种选择：Java 6确实有一个使用javax.persistence.criteria包的类型安全数据库查询的解决方案 .

虽然我必须说这不是真正的LINQ，因为使用LINQ你可以查询任何IEnumerable .

回复于 2024-04-16T19:48:22+08:00
141

一位匿名用户提到了另一个，Diting：

Diting是一个类库，通过可链接的方法和.NET中的Linq等匿名接口为集合提供查询功能 . 与大多数其他集合库不同，那些使用静态方法需要迭代整个集合，Diting提供了一个核心Enumerable类，它包含了用于在集合或数组上实现查询的自由链接方法 . 支持的方法：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，where

回复于 2024-04-16T19:48:22+08:00
3

和2014年一样，我终于可以说LINQ终于在java 8中了 . 因此无需再找到LINQ的替代品 .

回复于 2024-04-16T19:48:22+08:00
777

也许不是你希望得到的答案，但如果你的某些部分代码需要在集合（搜索，排序，过滤，转换，分析）上进行繁重的工作，你可以考虑在Clojure或Scala中编写一些类 .

由于它们的功能性，使用集合是他们最擅长的 . 我对Scala没有多少经验，但是使用Clojure，你可能会发现一个更强大的Linq触手可及，一旦编译完成，你生成的类将与其余的代码库无缝集成 .

回复于 2024-04-16T19:48:22+08:00
4
有一个替代解决方案，Coollection .

Coolection并没有假装成新的lambda，但是我们被旧的遗留Java项目所包围，这个lib将会有所帮助 . 它的使用和扩展非常简单，仅涵盖迭代最常用的集合操作，如下所示：
```
from(people).where("name", eq("Arthur")).first();
from(people).where("age", lessThan(20)).all();
from(people).where("name", not(contains("Francine"))).all();
```
回复于 2024-04-16T19:48:22+08:00
4

Lambdas are now available在Java 8中以JSR-335 - Lambda Expressions for the JavaTM Programming Language的形式

UPDATE ：JDK8 has now been released，其中包含项目lambda . 值得抓一份Java 8 in Action目前仍然是MEAP .

阅读有关lambdas的Brian Goetz文章，以便对JDK8中如何实现lambdas同时理解流，内部迭代，短路和构造函数引用有所了解 . 另外，请查看JSR以获取更多示例 .

我写了一篇关于在JDK8中使用lambdas的一些优点的博客，名为The Power of the Arrow，同时NetBeans 8也非常支持将构造转换为JDK8，我也在博客上发表了关于Migrating to JDK 8 with NetBeans的内容 .

回复于 2024-04-16T19:48:22+08:00
0

Java有许多LINQ等价物，请参阅here进行比较 .

对于类型安全的Quaere / LINQ样式框架，请考虑使用Querydsl . Querydsl支持JPA / Hibernate，JDO，SQL和Java Collections .

我是Querydsl的维护者，所以这个答案是有偏见的 .

回复于 2024-04-16T19:48:22+08:00
2

您可以使用lambdaj库以更易读的方式选择集合中的项目（以及更多）

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

它比Quaere库有一些优势，因为它不使用任何魔术字符串，它完全是类型安全的，在我看来它提供了更易读的DSL .

回复于 2024-04-16T19:48:22+08:00
16

见SBQL4J . 它是与Java集成的类型安全的强查询语言 . 允许编写复杂和多重嵌套查询 . 有很多运算符，可以在查询内部调用Java方法作为构造函数 . 查询被转换为纯Java代码（运行时没有反射），因此执行速度非常快 .

编辑：嗯，到目前为止SBQL4J它是Java语言的唯一扩展，它提供类似于LINQ的查询功能 . 有一些有趣的项目，如Quaere和JaQue，但它们只是API，不是语法/语义扩展，在编译时具有强类型安全性 .

回复于 2024-04-16T19:48:22+08:00
9

有一个名为quaere的项目 .

它是一个Java框架，它增加了查询集合的能力 .

注意：根据作者的说法，该项目不再维护 .

回复于 2024-04-16T19:48:22+08:00
8

JaQu是Java的LINQ等价物 . 虽然它是为H2数据库开发的，但它应该适用于任何数据库，因为它使用JDBC .

回复于 2024-04-16T19:48:22+08:00
10

你可以使用scala，它在语法上类似，它实际上可能比linq更强大 .

回复于 2024-04-16T19:48:22+08:00

查看tiny-q . （请注意，您目前无法下载它 . ）

以下是改编上述链接的示例：

首先我们需要一些数据的集合，比方说一组字符串

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

现在我们只想选择以“b”开头的字符串：

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

没有复制的实际数据被移动或类似的东西，它会在您开始迭代后立即处理：

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

回复于 2024-04-16T19:48:22+08:00

你可以试试我的图书馆CollectionsQuery . 它允许在对象集合上运行LINQ之类的查询 . 你必须传递谓词，就像在LINQ中一样 . 如果您使用java6 / 7而不是必须在接口上使用旧语法：

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

您也可以在Java8中使用它，或者在旧版本的java中使用RetroLambda并且它是gradle plugin，那么您将拥有新的花哨语法：

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

如果您需要运行数据库查询，那么您可以查看JINQ，如上所述，但它不能由RetroLambda反向移植，使用序列化的lambdas .

回复于 2024-04-16T19:48:22+08:00

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

支持不同的可能性，

鉴于收藏，

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

类型，

class Dto
{
    private int id;
    private String text;

    public int getId()
    {
        return id;
    }

    public int getText()
    {
        return text;
    }
}

Filter

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

也，

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

Sorting （也适用于Java 7）

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

Grouping （也适用于Java 7）

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

Joins （也适用于Java 7）

鉴于，

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

可以加入像，

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

回复于 2024-04-16T19:48:22+08:00

9
除非使用javacc创建自己的等效项，否则您将找不到LINQ的等效项 .

直到那天有人找到可行的方法，有一些很好的选择，例如
- jOOQ
- JINQ
- JaQue
- JaQu
- Linq4j
- Quaere（不再维护）
- QueryDSL
- JSR-341
回复于 2024-04-16T19:48:22+08:00
1
你可以试试这个图书馆：https://code.google.com/p/qood/

以下是使用它的一些原因：
- 轻量级：只需要9个公共接口/类来学习 .
  像SQL一样的
- 查询：支持group-by，order-by，left join，formula，...等 .
- 用于大数据：使用文件（QFS）代替堆内存 .
- 尝试解决Object-relational impedance mismatch .
回复于 2024-04-16T19:48:22+08:00
0

没有相当于LINQ for Java . 但有一些外部API看起来像LINQ，如https://github.com/nicholas22/jpropel-light，https://code.google.com/p/jaque/

回复于 2024-04-16T19:48:22+08:00
4

对于LINQ（LINQ to Objects），Java 8将具有相同的功能，请参阅Project Lambda .

它有Enumerable的LINQ to Objects extensions，如stuffs . 但是对于更复杂的LINQ之类的事情，如Expression和ExpressionTree（这些是LINQ to SQL和其他LINQ提供程序，如果他们想要提供优化和真实的东西），那么还没有任何等价物，但也许我们将来会看到:)

但我不认为将来会有类似于Java的声明性查询 .

回复于 2024-04-16T19:48:22+08:00
1

没有像LINQ for Java那样的东西 .

...

Edit

现在使用Java 8，我们被介绍到Stream API，这在处理集合时是类似的事情，但它与Linq并不完全相同 .

如果它是您正在寻找的ORM，如实体框架，那么您可以尝试Hibernate

:-)

回复于 2024-04-16T19:48:22+08:00
12

有一个非常好的库，你可以用它 .

位于：https://github.com/nicholas22/jpropel-light

Lambda在Java 8之前不可用，所以使用它有点不同，感觉并不自然 .

回复于 2024-04-16T19:48:22+08:00
7

对于基本的功能集合，Java 8内置了它，大多数主要的非Java JVM语言都内置了（Scala，Clojure等），你可以在早期的Java版本上添加libs .

对于SQL语言的完全语言集成访问，Scala（在JVM上运行）具有Slick

回复于 2024-04-16T19:48:22+08:00
4

Scala.Now我明星阅读它，发现它像linq但更简单，更难以理解 . 但scala可以在linux上运行，是吗？ csharp需要单声道 .

回复于 2024-04-16T19:48:22+08:00
48

LINQ to Objects - JAVA 8添加了Stream API，它增加了对值流的功能样式操作的支持：

Package java.util.stream

Java 8 Explained: Applying Lambdas to Java Collections

LINQ to SQL/NHibernate/etc. (database querying) - 一种选择是使用JINQ，它也使用新的JAVA 8功能，于2014年2月26日在Github上发布：https://github.com/my2iu/Jinq

Jinq为开发人员提供了一种用Java编写数据库查询的简单而自然的方法 . 您可以将数据库数据视为存储在集合中的普通Java对象 . 您可以迭代它们并使用普通的Java命令对它们进行过滤，并且所有代码都将自动转换为优化的数据库查询 . 最后，LINQ样式的查询可用于Java！

JINQ项目现场：http://www.jinq.org/

回复于 2024-04-16T19:48:22+08:00
29

听起来像每个人在这里谈论的Linq只是LinqToObjects . 我相信只提供今天已经完成的功能Java，但语法真的很难看 .

我认为.Net中Linq的真正强大之处在于lambda表达式可以在需要Delegate或Expression的上下文中使用，然后编译成适当的形式 . 这样可以使LinqToSql（或LinqToObjects以外的任何东西）工作，并允许它们具有与LinqToObjects相同的语法 .

看起来上面提到的所有项目都只提供LinqToObjects的功能 . 这使得我认为LinqToSql类型的功能不适用于Java .

回复于 2024-04-16T19:48:22+08:00
152

类似C＃的解决方案是JaQue，它为Java Lambdas提供表达式树 . 除此之外，还可以实现特定于域的LINQ提供程序 .

回复于 2024-04-16T19:48:22+08:00
7

既然Java 8支持lambda，那么就可以创建与LINQ非常相似的Java API .

Jinq是Java的这些新的LINQ样式库之一 .

我是这个图书馆的开发者 . 它基于使用字节码分析将Java转换为数据库查询的五年研究 . 类似于C＃的D-LINQ是位于实体框架之上的查询层，Jinq能够充当位于JPA或jOOQ之上的查询层 . 它支持聚合，组和子查询 . 即使是Erik Meijer（LINQ的创建者）也有acknowledged Jinq .

回复于 2024-04-16T19:48:22+08:00

LINQ的Java等价物是什么？ [关闭]

30 回答

相关问题