Home Articles

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

Asked
Viewed 1214 times
759

LINQ的Java等价物是什么?

30 Answers

  • 777

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

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

  • 152

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

  • 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

  • 119

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

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

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

  • 99

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

  • 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/

  • 29

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

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

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

  • 16

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

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

  • 12

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

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

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

  • 10

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

  • 9

    有一个名为quaere的项目 .

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

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

  • 9

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

    直到那天有人找到可行的方法,有一些很好的选择,例如

  • 8

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

  • 7

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

    对于SQL语言的完全语言集成访问,Scala(在JVM上运行)具有Slick

  • 7

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

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

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

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

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

    UPDATEJDK8 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的内容 .

  • 4

    你可以试试我的图书馆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 .

  • 4

    对于LINQ(LINQ to Objects),Java 8将具有相同的功能,请参阅Project Lambda .

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

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

  • 4

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

  • 3

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

  • 2

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

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

  • 2

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

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

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

  • 1

    我试过谷歌的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那样简洁,但看起来很有趣 .

  • 1

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

    你可以试试这个图书馆:https://code.google.com/p/qood/

    以下是使用它的一些原因:

    • 轻量级:只需要9个公共接口/类来学习 .
      像SQL一样的

    • 查询:支持group-by,order-by,left join,formula,...等 .

    • 用于大数据:使用文件(QFS)代替堆内存 .

    • 尝试解决Object-relational impedance mismatch .

  • 1

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

    ...

    Edit

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

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

    :-)

  • 0

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

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

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

  • 0

    查看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);
    }
    
  • 0

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

Related