LINQ와 동등한 Java는 무엇입니까? [닫은]

LINQ와 동등한 Java는 무엇입니까?

LINQ for Java와 같은 것은 없습니다.

...

편집하다

이제 Java 8에서는 Stream API를 소개합니다. 이것은 컬렉션을 다룰 때와 비슷한 종류이지만 Linq와는 다릅니다.

Entity Framework와 같은 ORM이라면 Hibernate 를 사용해 볼 수 있습니다.

:-)

다른 솔루션 인 Coollection이 있습니다.

Coolection은 새로운 람다 인 것처럼 보이지만이 라이브러리가 도움이 될 오래된 레거시 Java 프로젝트로 둘러싸여 있습니다. 다음과 같이 컬렉션에서 가장 많이 사용되는 반복 작업 만 포함하여 사용 및 확장이 매우 간단합니다.

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

람다는 이제 JSR-335-JavaTM 프로그래밍 언어를위한 람다 식 의 형태로 Java 8에서 사용 가능합니다.

업데이트 : JDK8이 릴리스 되어 프로젝트 람다가 포함되어 있습니다. 현재 여전히 MEAP 에서 Java 8 의 사본을 가져 오는 것이 좋습니다.

스트림, 내부 반복, 단락 및 생성자 참조에 대한 이해를 얻는 동시에 JDK8 내에서 람다가 어떻게 구현되는지에 대한 적절한 이해를 위해 람다와 관련된 Brian Goetz 기사를 읽으십시오 . 또한 JSR을 확인하여 추가 예제를 얻으십시오. .

필자는 JDK8에서 람다를 사용하여 얻을 수있는 장점 인 The Power of the Arrow 에 대한 블로그를 작성했습니다 . 또한 NetBeans 8 은 JDK8로 구문을 변환하는 데 큰 도움을 주며 NetBeans를 사용하여 JDK 8로 마이그레이션에 대해 블로그를 작성했습니다 .

lambdaj 라이브러리를 사용하여 더 읽기 쉬운 방식으로 컬렉션의 항목 등을 선택할 수 있습니다

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

그것은 마법의 문자열을 사용하지 않기 때문에 Quaere 라이브러리에 비해 몇 가지 장점이 있으며, 완전히 안전합니다. 제 생각에는 더 읽기 쉬운 DSL을 제공합니다.

javacc 를 사용하여 고유 한 항목 을 작성 하지 않으면 LINQ 항목을 찾을 수 없습니다 .

누군가가 그렇게 할 수있는 실용적인 방법을 찾을 때까지 다음과 같은 좋은 대안이 있습니다.

• 주크
• 진크
• 자키
• 자쿠
• Linq4j
• 무결점 (더 이상 유지되지 않음)
• QueryDSL
• JSR-341

LINQ to Objects -JAVA 8에는 값 스트림에서 기능 스타일 작업을 지원하는 Stream API가 추가되었습니다.

패키지 java.util.stream

Java 8 설명 : Java 콜렉션에 Lambdas 적용

LINQ to SQL / NHibernate 등 (데이터베이스 쿼리) -하나의 옵션은 새로운 JAVA 8 기능을 사용하고 2014 년 2 월 26 일 Github에서 릴리스 된 JINQ를 사용하는 것입니다 : https://github.com/my2iu/Jinq

Jinq는 개발자에게 Java로 데이터베이스 쿼리를 작성하는 쉽고 자연스러운 방법을 제공합니다. 컬렉션에 저장된 일반 Java 객체처럼 데이터베이스 데이터를 처리 할 수 ​​있습니다. 일반적인 Java 명령을 사용하여 반복하고 필터링 할 수 있으며 모든 코드가 자동으로 최적화 된 데이터베이스 쿼리로 변환됩니다. 마지막으로 LINQ 스타일 쿼리를 Java에 사용할 수 있습니다!

JINQ 프로젝트 사이트 : http://www.jinq.org/

quaere 라는 프로젝트가 있습니다 .

컬렉션을 쿼리하는 기능을 추가하는 Java 프레임 워크입니다.

참고 : 저자에 따르면 프로젝트는 더 이상 유지되지 않습니다.

Java와 동등한 LINQ가 많이 있습니다 . 비교를 위해 여기 를 참조 하십시오 .

형식이 안전한 Quaere / LINQ 스타일 프레임 워크의 경우 Querydsl 사용을 고려 하십시오 . Querydsl은 JPA / Hibernate, JDO, SQL 및 Java Collection을 지원합니다.

나는 Querydsl의 관리자 이므로이 대답은 편향되어 있습니다.

스칼라를 사용할 수 있습니다. 구문과 비슷하며 실제로 linq보다 더 강력합니다.

2014 년에 마침내 LINQ가 Java 8에 마침내 있다고 말할 수 있으므로 더 이상 LINQ의 대안을 찾을 필요가 없습니다.

Java 8은 람다를 지원하므로 LINQ와 매우 유사한 Java API를 작성할 수 있습니다.

Jinq 는 Java를위한 이러한 새로운 LINQ 스타일 라이브러리 중 하나입니다.

이 라이브러리의 개발자입니다. 바이트 코드 분석을 사용하여 Java를 데이터베이스 쿼리로 변환하는 것에 대한 5 년간의 연구를 기반으로합니다. C #의 D-LINQ가 Entity Framework 위에있는 쿼리 계층 인 방법과 유사하게 Jinq는 JPA 또는 jOOQ 위에있는 쿼리 계층으로 작동 할 수 있습니다. 집계, 그룹 및 하위 쿼리를 지원합니다. LINQ의 제작자 인 Erik Meijer조차도 Jinq 를 인정했습니다 .

SBQL4J를 참조하십시오 . Java와 통합 된 형식에 안전한 강력한 쿼리 언어입니다. 복잡하고 여러 번 중첩 된 쿼리를 작성할 수 있습니다. 많은 연산자가 있으며 생성자로서 쿼리 내에서 Java 메소드를 호출 할 수 있습니다. 쿼리는 순수 Java 코드로 변환되므로 (런타임에는 반영되지 않음) 실행 속도가 매우 빠릅니다.

편집 : 글쎄, 지금까지 SBQL4J는 LINQ와 유사한 쿼리 기능을 제공하는 Java 언어의 유일한 확장입니다. Quaere 및 JaQue와 같은 흥미로운 프로젝트가 있지만 컴파일 시간에 강력한 유형 안전성을 갖춘 구문 / 의미 확장이 아닌 API 일뿐입니다.

Java LINQ to SQL 구현. .NET LINQ에 비해 완전한 언어 통합과 더 큰 기능 세트를 제공합니다.

Google에서 구아바 라이브러리 를 사용해 보았습니다 . 그것은이 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만큼 간결하지는 않지만 흥미로워 보입니다.

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

필터

자바 7

Filter<Dto> query = CQ.<Dto>filter(testList)
    .where()
    .property("id").eq().value(1);
Collection<Dto> filtered = query.list();

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

정렬 (Java 7에도 사용 가능)

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

그룹화 (Java 7에도 사용 가능)

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

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

표현

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

내 라이브러리 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, 또는 오래된 자바에서 사용할 수 RetroLambda 과 그것의 Gradle을 플러그인 , 당신은 새로운 멋진 구문을해야합니다 :

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

DB 쿼리를 실행 해야하는 경우 위에서 언급 한 것처럼 JINQ에서 볼 수있는 것보다 직렬 람다를 사용하여 RetroLambda에 의해 백 포트 될 수 없습니다.

또 다른 대안을 추가하려면 Java 6에는 javax.persistence.criteria 패키지를 사용하여 형식이 안전한 데이터베이스 쿼리를위한 솔루션이 있습니다 .

LINQ를 사용하면 IEnumerable을 쿼리 할 수 ​​있기 때문에 이것이 실제로 LINQ가 아니라고 말해야합니다.

이를 위해 사용할 수있는 매우 좋은 라이브러리가 있습니다.

여기에 위치 : https://github.com/nicholas22/jpropel-light

람다는 Java 8까지는 사용할 수 없으므로 사용하는 것은 조금 다르며 자연스럽지 않습니다.

모두가 여기에서 말하는 Linq와 같은 소리는 LinqToObjects입니다. 나는 오늘날 Java로 이미 달성 할 수있는 기능 만 제공하지만 실제로는 추악한 구문을 제공한다고 생각합니다.

.Net에서 Linq의 진정한 힘으로 보는 것은 람다식이 위임 또는식이 필요한 컨텍스트에서 사용될 수 있으며 적절한 형식으로 컴파일된다는 것입니다. 이것은 LinqToSql (또는 LinqToObjects 이외의 것)과 같은 것들이 작동하도록하고 LinqToObjects와 동일한 구문을 갖도록합니다.

위에서 언급 한 모든 프로젝트가 LinqToObjects의 기능 만 제공하는 것 같습니다. LinqToSql 유형의 기능이 Java의 지평선에 있지 않다는 것을 알 수 있습니다.

기본 기능 모음의 경우 Java 8에 내장되어 있고 Java 이외의 주요 JVM 언어의 대부분에는 내장되어 있으며 (Scala, Clojure 등) 이전 Java 버전의 라이브러리에 추가 할 수 있습니다.

SQL 데이터베이스에 대한 전체 언어 통합 액세스를 위해 Scala (JVM에서 실행)에는 Slick이 있습니다.

LINQ (LINQ to Objects)의 경우 Java 8에는 동등한 기능이 있습니다 ( Project Lambda 참조) .

그것은 Enumerable에서의이 객체의 확장에 LINQ 와 같은 거즈 . 그러나 Expression 및 ExpressionTree 와 같은 더 복잡한 LINQ의 경우 (LINQ to SQL 및 기타 LINQ 공급자가 최적화되고 실제적인 것을 제공하려는 경우 필요함) 아직 이에 상응하는 것은 아니지만 앞으로는 다음과 같이 보일 것입니다.

그러나 앞으로 Java에 대한 선언 쿼리와 같은 것이 없을 것이라고 생각합니다.

자바에는 그러한 기능이 없습니다. 다른 API를 사용하면이 기능을 사용할 수 있습니다. 이름과 아이디가 포함 된 동물 객체가 있다고 가정합니다. 동물 대상을 가지는리스트 대상이 있습니다. 이제리스트 객체에서 'o'를 포함하는 모든 동물 이름을 가져 오려면 우리는 다음과 같은 쿼리를 작성할 수 있습니다

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

위의 Query 문에는 이름에 'o'알파벳이 포함 된 동물 목록이 표시됩니다. 자세한 내용은 다음 블로그를 참조하십시오. http://javaworldwide.blogspot.in/2012/09/linq-in-java.html

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

JaQu는 Java에 해당하는 LINQ입니다. H2 데이터베이스 용으로 개발되었지만 JDBC를 사용하므로 모든 데이터베이스에서 작동해야합니다.

원하는 답변이 아닐 수도 있지만 코드의 일부가 수집 (검색, 정렬, 필터링, 변환, 분석)에 대한 많은 작업이 필요한 경우 Clojure 또는 Scala로 일부 클래스를 작성하는 것을 고려할 수 있습니다 .

기능적 특성으로 인해 컬렉션 작업이 가장 좋습니다. Scala에 대한 경험이 많지 않지만 Clojure를 사용하면 손끝에서 더 강력한 Linq를 발견하고 한 번 컴파일하면 생성 한 클래스가 나머지 코드베이스와 완벽하게 통합됩니다.

익명의 사용자가 Diting :

Diting은 .NET의 Linq와 같은 익명 인터페이스와 체인 가능한 메소드를 통해 컬렉션에 쿼리 기능을 제공하는 클래스 라이브러리입니다. 정적 메소드를 사용하는 대부분의 다른 콜렉션 라이브러리와 달리 전체 콜렉션을 반복 해야하는 Diting은 핵심 Enumerable 클래스 whitch를 제공합니다.

지원되는 방법 : 첫 번째, firstOrDefault, groupBy, interset, join, last, lastOrDefault, ofType, orderBy, orderByDescending, reverse, select, selectMany, single, singleOrDefault, skip을 제외한 any, cast, contact, contains, count, distinct, elementAt , skipWhile, take, takeWhile, toArray, toArrayList, union, 여기서

Scala. 이제 나는 그것을 읽고, linq와 비슷하지만 더 간단하고 읽을 수 없다는 것을 알았습니다. 스칼라는 리눅스에서 실행할 수 있습니다. csharp는 모노가 필요합니다.

프로그래밍 언어 피자 (자바 확장)가 있었고 살펴보아야합니다. - "유창한 인터페이스"개념을 사용하여 선언적인 방식으로 데이터를 쿼리하며 이는 원칙적으로 쿼리식이없는 LINQ와 동일합니다 (http://ko.wikipedia.org/wiki/Pizza_programming_language). 그러나 안타깝게도 LINQ와 비슷한 것을 Java로 가져 오는 방법 중 하나였습니다.

LINQ for Java와 동등한 기능이 없습니다. 그러나 https://github.com/nicholas22/jpropel-light , https://code.google.com/p/jaque/ 와 같이 LINQ와 같은 외부 API가 있습니다.

이 라이브러리를 사용해보십시오 : https://code.google.com/p/qood/

사용하는 몇 가지 이유는 다음과 같습니다.

1. 경량 : 9 개의 공용 인터페이스 / 클래스 만 배울 수 있습니다.
2. SQL과 같은 쿼리 : group-by, order-by, left join, formula 등을 지원합니다.
3. 빅 데이터의 경우 : 힙 메모리 대신 파일 (QFS)을 사용하십시오.
4. 객체 관계형 임피던스 불일치 를 해결하십시오 .