LINQ için Java eşdeğeri nedir? [kapalı]

LINQ için Java eşdeğeri nedir?

Java için LINQ gibi bir şey yoktur.

...

Düzenle

Java 8 ile Stream API ile tanıştık , bu koleksiyonlarla uğraşırken benzer bir şey, ancak Linq ile aynı değil.

Entity Framework gibi aradığınız bir ORM ise, Hazırda Bekletme'yi deneyebilirsiniz

:-)

Alternatif bir çözüm var, Coollection .

Coolection yeni lambda gibi davranmadı, ancak bu lib'in yardımcı olacağı eski eski Java projeleri ile çevriliyiz. Koleksiyonlar üzerinde yalnızca en çok kullanılan yineleme eylemlerini kapsayan, kullanımı ve genişletilmesi gerçekten basittir:

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

Lambdas artık Java 8'de JavaTM Programlama Dili için JSR-335 - Lambda İfadeleri biçiminde kullanılabilir

GÜNCELLEME : lambda projesini içeren JDK8 yayınlandı . Şu anda MEAP olan Java 8 in Action'ı kopyalamaya değer .

Akıntılar, iç yineleme, kısa devre ve yapıcı referansları hakkında bir anlayış kazanırken, lambdaların JDK8 içinde nasıl uygulandığının iyi bir şekilde anlaşılması için lambdalarla ilgili Brian Goetz makalelerini okuyun. Daha fazla örnek almak için yukarıdaki JSR'lara da göz atın. .

JDK8'de The Power of the Arrow adlı lambda kullanmanın bazı avantajları hakkında bir blog yazdım , ayrıca NetBeans 8 , NetBeans ile JDK 8'e Geçiş hakkında blog yazdığım yapıları JDK8'e dönüştürmek için de büyük desteğe sahip .

Bir koleksiyondaki öğeleri (ve daha fazlasını) lambdaj kütüphanesini kullanarak daha okunabilir bir şekilde seçebilirsiniz

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

Quaere kütüphanesine göre bazı avantajları var, çünkü herhangi bir sihirli dize kullanmıyor, tamamen güvenli ve bence daha okunabilir bir DSL sunuyor.

Kendi eşdeğerinizi oluşturmak için javacc kullanmadığınız sürece LINQ eşdeğerini bulamazsınız .

Birisi bunu yapmak için uygun bir yol bulana kadar, bazı iyi alternatifler vardır.

• jOOQ
• JINQ
• jaque
• JaQu
• Linq4j
• Quaere (Artık bakım yapılmıyor )
• QueryDSL
• JSR-341

Nesnelere LINQ - JAVA 8, değer akışları üzerinde işlevsel stil işlemleri için destek ekleyen Akış API'sını ekledi:

Paket java.util.stream

Java 8 Açıklaması: Java Koleksiyonlarına Lambdas Uygulamak

LINQ to SQL / NHibernate / vb. (veritabanı sorgulama) - Bir seçenek, yeni JAVA 8 özelliklerini de kullanan ve 26 Şubat 2014 tarihinde Github'da yayınlanan JINQ kullanmak olacaktır: https://github.com/my2iu/Jinq

Jinq, geliştiricilere Java'da veritabanı sorguları yazmak için kolay ve doğal bir yol sağlar. Koleksiyonlarda depolanan normal Java nesneleri gibi veritabanı verilerini işleyebilirsiniz. Bunları tekrarlayabilir ve normal Java komutlarını kullanarak filtreleyebilirsiniz; tüm kodunuz otomatik olarak optimize edilmiş veritabanı sorgularına dönüştürülür. Son olarak, Java için LINQ stili sorgular mevcuttur!

JINQ proje sitesi: http://www.jinq.org/

Quaere adında bir proje var .

Koleksiyonları sorgulama yeteneğini ekleyen bir Java çerçevesi.

Not: Yazara göre proje artık sürdürülmemektedir.

Java için birçok LINQ eşdeğeri vardır, karşılaştırma için buraya bakın .

Tipik bir Quaere / LINQ stili çerçevesi için Querydsl kullanmayı düşünün . Querydsl, JPA / Hibernate, JDO, SQL ve Java Koleksiyonlarını destekler.

Ben Querydsl'in koruyucusuyum, bu yüzden bu cevap taraflı.

scala kullanabilirsiniz, sözdizimine benzer ve aslında linq'den daha güçlüdür.

2014'te olduğu gibi, sonunda LINQ'un java 8'de olduğunu söyleyebilirim. Artık LINQ için bir alternatif bulmaya gerek yok.

Artık Java 8 lambdas'ı desteklediğine göre, LINQ'ya çok benzeyen Java API'leri oluşturmak mümkündür.

Jinq , Java için bu yeni LINQ tarzı kütüphanelerden biridir.

Bu kütüphanenin geliştiricisiyim. Java'yı veritabanı sorgularına çevirmek için bayt kod analizini kullanma üzerine beş yıllık bir araştırmaya dayanmaktadır. C # 'ın D-LINQ'sinin Entity Framework'ün üstünde oturan bir sorgu katmanı gibi Jinq, JPA veya jOOQ'nun üstünde oturan bir sorgu katmanı gibi davranabilir. Toplama, gruplar ve alt sorgular için desteği vardır. Hatta Erik Meijer ( LINQ'nun yaratıcısı) Jinq'i kabul etti .

Bkz. SBQL4J . Java ile entegre tip-güvenli güçlü sorgu dili. Karmaşık ve çoğaltılmış iç içe sorgular yazmayı sağlar. Çok sayıda operatör var, Java yöntemleri sorgular içinde kurucular olarak çağrılabilir. Sorgular saf Java koduna çevrilir (çalışma zamanında yansıma yoktur), bu nedenle yürütme çok hızlıdır.

EDIT: Şimdiye kadar, SBQL4J LINQ benzer sorgu yetenekleri veren Java diline SADECE uzantısıdır. Quaere ve JaQue gibi ilginç bir proje var, ancak derleme zamanında güçlü tip güvenliği olan sözdizimi / anlambilim uzantısı değil, sadece API'ler.

Java LINQ to SQL uygulaması. .NET LINQ ile karşılaştırıldığında tam dil entegrasyonu ve daha geniş özellik kümesi sağlar.

Google'dan guava kütüphanelerini denedim . FluentIterableLINQ yakın olduğunu düşünüyorum bir vardır. Ayrıca bkz. Functional Explained .

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 için kapsamlı bir kütüphane gibi görünüyor. Kesinlikle LINQ kadar özlü değil, ilginç görünüyor.

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

Farklı olasılıkları destekler,

Verilen koleksiyon,

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

türünde,

class Dto
{
    private int id;
    private String text;

    public int getId()
    {
        return id;
    }

    public int getText()
    {
        return text;
    }
}

filtre

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

Ayrıca,

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

Sıralama (Java 7 için de mevcuttur)

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

Gruplama (Java 7 için de mevcuttur)

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

Birleşimler (Java 7 için de mevcuttur)

göz önüne alındığında,

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

Gibi Katılabilir,

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

İfade

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

CollectionsQuery kütüphanemi deneyebilirsiniz . Nesne koleksiyonları üzerinde LINQ benzeri sorgular çalıştırmayı sağlar. Tıpkı LINQ'da olduğu gibi yüklemi geçmek zorundasınız. Java6 / 7 kullanıyorsanız, Arayüzlerle eski sözdizimini kullanmanız gerekir:

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

Ayrıca Java8'de veya RetroLambda ile eski java ve gradle eklentisi de kullanabilirsiniz , o zaman yeni fantezi sözdizimine sahip olacaksınız:

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

DB sorgularını çalıştırmanız gerekiyorsa, yukarıda belirtildiği gibi JINQ'ya bakabilirsiniz, ancak serileştirilmiş lambdaların kullanımı için RetroLambda, doe tarafından geri taşınamaz.

Sadece başka bir alternatif eklemek için: Java 6, javax.persistence.criteria paketini kullanarak tür güvenli veritabanı sorguları için bir çözüme sahiptir .

Gerçi bu gerçekten LINQ olmadığını söylemek gerekir, çünkü LINQ ile herhangi bir IEnumerable sorgulayabilirsiniz.

Bunun için kullanabileceğiniz çok iyi bir kütüphane var.

Burada bulunan: https://github.com/nicholas22/jpropel-light

Lambdas, Java 8'e kadar mevcut olmayacak, bu yüzden onu kullanmak biraz farklı ve doğal hissetmiyor.

Herkesin bahsettiği Linq gibi görünüyor sadece LinqToObjects. Ben sadece bugün Java zaten, ancak gerçekten çirkin sözdizimi ile başarılabilecek işlevsellik sunuyor inanıyorum.

Linq'in .Net'teki gerçek gücü olarak gördüğüm şey, lambda ifadelerinin Delege veya İfade gerektiren bir bağlamda kullanılabilmesidir ve daha sonra uygun forma derlenecektir. Bu, LinqToSql (veya LinqToObjects dışında bir şey) gibi şeylerin çalışmasına izin verir ve LinqToObjects ile aynı sözdizimine sahip olmalarını sağlar.

Yukarıda adı geçen tüm projelerin yalnızca LinqToObjects'in yeteneklerini sunduğu görülüyor. Bu bana LinqToSql tipi işlevsellik Java ufukta olmayan bir şey yapar.

Temel fonksiyonel koleksiyonlar için Java 8 yerleşik olarak bulunur, Java olmayan büyük JVM dillerinin çoğunda yerleşiktir (Scala, Clojure, vb.) Ve önceki Java sürümleri için kütüphanelere ekleyebilirsiniz.

SQL veritabanına tam dilde tümleşik erişim için Scala (JVM'de çalışır) Slick içerir

LINQ (LINQ'dan Nesnelere) için Java 8'de eşdeğer bir şey olacaktır, bkz . Lambda Projesi .

Bu enumerable en bulunur Nesneler uzantılarına LINQ gibi maddeleri . Ancak Expression ve ExpressionTree gibi daha karmaşık LINQ şeyleri için (bunlar, optimize edilmiş ve gerçek bir şey sağlamak istiyorlarsa, LINQ to SQL ve diğer LINQ sağlayıcıları için gereklidir), henüz eşdeğer değildir, ancak belki de gelecekte göreceğiz :)

Ancak gelecekte Java ile ilgili bildirim sorguları gibi bir şey olacağını sanmıyorum.

Java'da böyle bir özellik yoktur. Diğer API'yi kullanarak bu özelliği alacaksınız. Diyelim ki isim ve kimlik içeren bir hayvan Nesnemiz var. Hayvan nesnelerine sahip liste nesnesimiz var. Şimdi 'o' içeren tüm hayvan adını liste nesnesinden almak istiyorsak. aşağıdaki sorguyu yazabiliriz

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

Yukarıdaki Sorgu ifadesi, adlarında 'o' alfabesi içeren hayvanları listeler. Daha fazla bilgi için lütfen aşağıdaki blog'a bakınız. http://javaworldwide.blogspot.in/2012/09/linq-in-java.html

Tiny-q'a bir göz atın . (Şu anda indiremeyeceğinizi unutmayın.)

Yukarıdaki bağlantıya uyarlanmış bir örnek:

Öncelikle bazı verilerin toplanmasına ihtiyacımız var, diyelim bir dizi dizgi

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

Şimdi sadece "b" ile başlayan dizeleri seçmek istiyoruz:

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

Kopyalanmış gerçek veriler veya bunun gibi bir şey taşınmaz, yinelemeye başlar başlamaz işlenir:

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

JaQu, Java için LINQ eşdeğeridir. H2 veritabanı için geliştirilmiş olmasına rağmen, JDBC kullandığı için herhangi bir veritabanı için çalışmalıdır.

Belki umduğunuz cevap olmayabilir, ancak kodunuzun bir kısmı koleksiyonlar (arama, sıralama, filtreleme, dönüşümler, analiz) üzerinde ağır işlere ihtiyaç duyarsa , Clojure veya Scala'da bazı sınıflar yazmayı düşünebilirsiniz. .

İşlevsel nitelikleri nedeniyle koleksiyonlarla çalışmak en iyi oldukları şeydir. Scala ile pek tecrübem yok, ama Clojure ile muhtemelen parmaklarınızın ucunda daha güçlü bir Linq bulacaksınız ve derlendiğinde, üreteceğiniz sınıflar kod tabanının geri kalanıyla sorunsuz bir şekilde bütünleşecekti.

İsimsiz bir kullanıcı başka birinden bahsetti, Diting :

Diting, zincirlenebilir yöntemler ve .NET'teki Linq gibi anonim arabirimler aracılığıyla koleksiyonlarda sorgu yetenekleri sağlayan bir sınıf kütüphanesidir. Statik yöntemler kullanan diğer koleksiyon kitaplıklarının çoğundan farklı olarak, yineleme tüm koleksiyona ihtiyaç duyar, Diting, çekirdek veya numaralandırılabilir bir sınıf numaralandırması, toplama veya dizi üzerinde sorgu uygulamak için zorunlu zincirlenebilir yöntemler içerir.

Desteklenen Yöntemler: herhangi bir, döküm, kişi, içerir, sayım, farklı, elementAt, ilk, ilkOrtakDefault, groupBy, kesişme, katıl, son, lastOrDefault, ofType, orderBy, orderByDescending, ters, seçin, selectMany, tek, singleOrDefault, atla , skipWhile, take, takeWhile, toArray, toArrayList, birleşim, nerede

Scala.Şimdi okudum ve linq gibi buldum ama daha basit ve daha okunaksız. ama scala linux'da çalışabilir, değil mi? csharp mono gerekir.

Pizza (Java uzantısı) programlama dili vardı ve ona bir göz atmalısınız. - Verileri bildirici bir şekilde sorgulamak için "akıcı arayüzler" kavramını kullanır ve ilke olarak LINQ sorgu ifadeleri olmadan aynıdır (http://en.wikipedia.org/wiki/Pizza_programming_language). Ancak ne yazık ki takip edilmedi, ancak LINQ'ya benzer bir şeyi Java'ya almanın bir yolu olurdu.

Java için LINQ eşdeğeri yoktur. Ancak, https://github.com/nicholas22/jpropel-light , https://code.google.com/p/jaque/ gibi LINQ gibi görünen bazı harici API'ler var

şu kütüphaneyi deneyebilirsiniz: https://code.google.com/p/qood/

İşte kullanmak için bazı nedenler:

1. hafif: öğrenmek için sadece 9 genel arayüz / sınıf.
2. SQL gibi sorgu: gruplama, sıralama, sola birleştirme, formül, vb.
3. büyük veri için: Yığın Bellek yerine Dosya (QFS) kullanın.
4. Nesne-ilişkisel empedans uyumsuzluğunu çözmeye çalışın .