java LINQ के लिए जावा समतुल्य क्या है?




(24)

यह लिंक की तरह लगता है कि हर कोई यहां के बारे में बात कर रहा है बस LinqToObjects है। जो मेरा मानना ​​है कि केवल कार्यक्षमता प्रदान करता है जो जावा में आज ही पूरा हो सकता है, लेकिन वास्तव में बदसूरत वाक्यविन्यास के साथ।

जो मैं लिंक में वास्तविक शक्ति के रूप में देखता हूं। नेट यह है कि लैम्ब्डा अभिव्यक्तियों का उपयोग किसी संदर्भ में किया जा सकता है जो या तो प्रतिनिधि या अभिव्यक्ति की आवश्यकता होती है और फिर उचित रूप में संकलित की जाएगी। यह वही है जो LinqToSql (या LinqToObjects के अलावा कुछ भी) काम करने की अनुमति देता है, और उन्हें LinqToObjects के समान वाक्यविन्यास रखने की अनुमति देता है।

ऐसा लगता है कि ऊपर उल्लिखित सभी परियोजनाएं केवल LinqToObjects की क्षमताओं की पेशकश कर रही हैं। जो मुझे चीज बनाता है कि लिंक के लिए क्षितिज पर LinqToSql-type कार्यक्षमता नहीं है।

LINQ के लिए जावा समतुल्य क्या है?


जेएमआर -335 के रूप में लैम्बडास अब जावा 8 के भीतर उपलब्ध हैं - जावाटीएम प्रोग्रामिंग भाषा के लिए लैम्ब्डा एक्सप्रेशन

अद्यतन : जेडीके 8 अब जारी किया गया है जिसमें परियोजना लैम्ब्डा शामिल है। वर्तमान में अभी भी MEAP में जावा 8 की एक प्रति को पकड़ने लायक है।

जेडीके 8 के भीतर भेड़ के बच्चे को कैसे लागू किया जाता है, जबकि धाराओं, आंतरिक पुनरावृत्ति, शॉर्ट-सर्किटिंग और कन्स्ट्रक्टर संदर्भों की समझ प्राप्त करने के बारे में अच्छी समझ के लिए लैम्बडा से संबंधित ब्रायन गोएट्ज़ लेखों का एक अध्ययन पढ़ें .. आगे के उदाहरण प्राप्त करने के लिए जेएसआर के ऊपर भी देखें ।

मैंने जेडीके 8 में लैम्बडास का उपयोग करने के कुछ फायदों पर एक ब्लॉग लिखा है जिसे द पावर ऑफ द एरो कहा जाता है, नेटबीन 8 को जेडीके 8 में संरचनाओं को परिवर्तित करने के लिए बहुत अच्छा समर्थन है, जिसे मैंने नेटबीन के साथ जेडीके 8 में माइग्रेट करने के बारे में भी ब्लॉग किया है।


बुनियादी कार्यात्मक संग्रहों के लिए, जावा 8 ने इसे बनाया है, अधिकांश गैर-जावा जेवीएम भाषाओं में यह बनाया गया है (स्कैला, क्लोजर इत्यादि), और आप पहले जावा संस्करणों के लिए libs पर जोड़ सकते हैं।

पूर्ण भाषा के लिए एक SQL डेटाबेस में एकीकृत पहुंच के लिए, स्कैला (JVM पर चलता है) में Slick


LINQ (LINQ से ऑब्जेक्ट्स) के लिए, जावा 8 में कुछ समकक्ष होगा, परियोजना Lambda देखें।

इसमें stuffs जैसे ऑब्जेक्ट्स एक्सटेंशन के लिए एन्यूमेरेबल का LINQ है । लेकिन Expression और अभिव्यक्ति ट्री जैसी अधिक जटिल LINQ चीजों के लिए (इन्हें LINQ से SQL और अन्य LINQ प्रदाताओं के लिए आवश्यक है यदि वे कुछ अनुकूलित और वास्तविक प्रदान करना चाहते हैं), अभी तक कोई समकक्ष नहीं है लेकिन शायद हम भविष्य में इसे देखेंगे :)

लेकिन मुझे नहीं लगता कि भविष्य में जावा पर घोषणात्मक प्रश्नों की तरह कुछ भी होगा।


SBQL4J देखें। यह जावा के साथ एकीकृत टाइप-सुरक्षित मजबूत क्वेरी भाषा है। जटिल और गुणात्मक प्रश्नों को गुणा करने की अनुमति देता है। बहुत सारे ऑपरेटर हैं, जावा विधियों को कन्स्ट्रक्टर के रूप में प्रश्नों के अंदर बुलाया जा सकता है। प्रश्नों का शुद्ध जावा कोड में अनुवाद किया जाता है (रनटाइम पर कोई प्रतिबिंब नहीं है) इसलिए निष्पादन बहुत तेज़ है।

संपादित करें: ठीक है, अब तक एसबीक्यूएल 4 जे जावा भाषा का एकमात्र विस्तार है जो LINQ के समान क्वेरी क्षमताओं को देता है। Quaere और JaQue जैसे कुछ रोचक प्रोजेक्ट हैं लेकिन वे केवल एपीआई हैं, संकलन समय में मजबूत प्रकार की सुरक्षा के साथ वाक्यविन्यास / अर्थशास्त्र विस्तार नहीं।


आप मेरी लाइब्रेरी CollectionsQuery को आजमा सकते हैं। यह वस्तुओं के संग्रह पर प्रश्नों की तरह LINQ चलाने की अनुमति देता है। आपको LINQ की तरह, भविष्यवाणी करना होगा। यदि आप इंटरफेस के साथ पुराने वाक्यविन्यास का उपयोग करने के लिए जावा 6/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();

आप इसे जावा 8 में या पुराने जावा में RetroLambda और इसके RetroLambda प्लगइन के साथ भी इस्तेमाल कर सकते हैं, तो आपके पास नया फैंसी सिंटैक्स होगा:

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

यदि आपको डीबी पूछताछ चलाने की आवश्यकता है, तो आप ऊपर बताए अनुसार जेआईएनक्यू पर देख सकते हैं, लेकिन इसे रेट्रोलैम्बा द्वारा बैक-पोर्ट किया जा सकता है, सीरियलकृत लैम्ब्डा के उपयोग के लिए डो।


मैंने Google से 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();
        }
    });

जावा के लिए एक व्यापक पुस्तकालय लगता है। निश्चित रूप से LINQ के रूप में संक्षेप में नहीं बल्कि दिलचस्प लग रहा है।


एक वैकल्पिक समाधान, Coollection

Coolection नई lambda होने का नाटक नहीं किया है, हालांकि हम पुराने विरासत जावा परियोजनाओं से घिरे हुए हैं जहां यह lib मदद करेगा। उपयोग और विस्तार करना वास्तव में सरल है, संग्रहों पर पुनरावृत्ति के केवल सबसे अधिक उपयोग किए जाने वाले कार्यों को कवर करना, जैसे:

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

आप स्कैला का उपयोग कर सकते हैं, यह वाक्यविन्यास में समान है और यह वास्तव में शायद linq से अधिक शक्तिशाली है।


एसी # JaQue समाधान JaQue , जो जावा Lambdas के लिए अभिव्यक्ति पेड़ प्रदान करता है। इसके शीर्ष पर डोमेन विशिष्ट LINQ प्रदाताओं को लागू किया जा सकता है।


quaere नामक एक परियोजना है।

यह जावा फ्रेमवर्क है जो संग्रहों की क्वेरी करने की क्षमता को जोड़ता है।

नोट: लेखक के अनुसार, परियोजना अब और नहीं रखी गई है।


हो सकता है कि आप जिस उत्तर की उम्मीद कर रहे हों, लेकिन यदि आपके कोड के कुछ हिस्से को संग्रह (खोज, सॉर्टिंग, फ़िल्टरिंग, ट्रांसफॉर्मेशन, विश्लेषण) पर भारी काम की आवश्यकता है तो आप Clojure या Clojure में कुछ कक्षाएं लिखने पर विचार कर सकते हैं।

उनकी कार्यात्मक प्रकृति के कारण, संग्रह के साथ काम करना वह सबसे अच्छा है। मुझे स्कैला के साथ बहुत अधिक अनुभव नहीं है, लेकिन क्लोजर के साथ आपको शायद आपकी उंगलियों पर एक अधिक शक्तिशाली लिंक मिलेगा और एक बार संकलित हो जाएगा, आपके द्वारा उत्पादित कक्षाएं शेष कोड बेस के साथ सहजता को एकीकृत करती हैं।


जावा के लिए कई LINQ समकक्ष हैं, तुलना के लिए here देखें।

एक टाइपएफ़ Quaere / LINQ शैली ढांचे के लिए, Querydsl का उपयोग करने पर विचार करें। Querydsl जेपीए / हाइबरनेट, जेडीओ, एसक्यूएल और जावा संग्रह का समर्थन करता है।

मैं Querydsl के रखरखाव हूँ, तो यह जवाब पक्षपातपूर्ण है।


बस एक और विकल्प जोड़ने के लिए: जावा 6 में javax.persistence.criteria पैकेज का उपयोग कर टाइप-सुरक्षित डेटाबेस क्वेरीज़ का समाधान है।

हालांकि मुझे यह कहना होगा कि यह वास्तव में LINQ नहीं है, क्योंकि LINQ के साथ आप किसी भी IENumerable से पूछ सकते हैं।


एक अज्ञात उपयोगकर्ता ने एक और का उल्लेख किया, Diting :

डाइटिंग एक क्लास लाइब्रेरी अक्षरों के तरीकों और एनईटी में लिंक्स जैसे अज्ञात इंटरफ़ेस के माध्यम से संग्रह पर क्वेरी क्षमताओं प्रदान करती है। अन्य संग्रह लाइब्रेरी के विपरीत, जो स्थिर विधियों का उपयोग कर रहे हैं, पूरे संग्रह को फिर से पूरा करने की आवश्यकता है, डाइटिंग एक कोर एन्युमेरेबल क्लास व्हिच में संग्रह या सरणी पर क्वेरी लागू करने के लिए डिफर्ड चेन करने योग्य विधियों को प्रदान करता है।

समर्थित तरीके: किसी भी, कास्ट, संपर्क, शामिल, गिनती, विशिष्ट, तत्व, छोड़कर, पहले, पहले, पहले ऑरफिफॉल्ट, समूहबी, इंटर्सेट, शामिल, आखिरी, आखिरी ओआरडीफॉल्ट, टाइप, ऑर्डरबी, ऑर्डरबैडस्केंडिंग, रिवर्स, सिलेक्ट, चुनिए मैनी, सिंगल, सिंगलऑर्डफॉल्ट, स्किप , छोड़ो, ले लो, ले लो, हालांकि, toArray, toArrayList, संघ, जहां


Scala.अब मैं इसे पढ़ा स्टार, और इसे linq की तरह पाया लेकिन अधिक सरल और अधिक अपठनीय। लेकिन स्केल लिनक्स पर चल सकता है, हाँ? csharp मोनो की जरूरत है।


आप lambdaj लाइब्रेरी का उपयोग कर एक अधिक पठनीय तरीके से संग्रह (और बहुत कुछ) में आइटम का चयन कर सकते हैं

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

क्वायर लाइब्रेरी पर इसके कुछ फायदे हैं क्योंकि यह किसी भी जादू स्ट्रिंग का उपयोग नहीं करता है, यह पूरी तरह से सुरक्षित है और मेरी राय में यह एक और अधिक पढ़ने योग्य डीएसएल प्रदान करता है।


अब जावा 8 लैम्ब्डा का समर्थन करता है, जावा एपीआई बनाना संभव है जो LINQ जैसा दिखता है।

http://www.jinq.org/ जावा के लिए इन नए http://www.jinq.org/ शैली पुस्तकालयों में से एक है।

मैं इस पुस्तकालय का डेवलपर हूं। यह जावा से डेटाबेस प्रश्नों का अनुवाद करने के लिए बाइटकोड विश्लेषण का उपयोग करने पर पांच साल के शोध पर आधारित है। सी # की डी-लाइनक्यू एक क्वेरी लेयर है जो एंटिटी फ्रेमवर्क के शीर्ष पर बैठती है, जेनक जेपीए या ज्यूक्यू के शीर्ष पर बैठे एक क्वेरी लेयर के रूप में कार्य करने में सक्षम है। इसमें एकत्रीकरण, समूह और उप-सामानों के लिए समर्थन है। एरिक मीजर (LINQ के निर्माता) ने भी जिन्क को स्वीकार किया है


एक बहुत अच्छी लाइब्रेरी है जिसका उपयोग आप इसके लिए कर सकते हैं।

यहां स्थित है: https://github.com/nicholas22/jpropel-light

लैम्बडास जावा 8 तक उपलब्ध नहीं होंगे, इसलिए इसका उपयोग करना थोड़ा अलग है और यह प्राकृतिक नहीं लगता है।


tiny-q । (ध्यान दें कि आप वर्तमान में इसे डाउनलोड नहीं कर सकते हैं।)

उपर्युक्त लिंक को अनुकूलित करने वाला एक उदाहरण यहां दिया गया है:

सबसे पहले हमें कुछ डेटा एकत्र करने की ज़रूरत है, आइए तारों का एक सेट कहें

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

अब हम केवल "तार" से शुरू होने वाले तारों का चयन करना चाहते हैं:

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

जावा के लिए LINQ जैसे कुछ भी नहीं है।


LINQ से ऑब्जेक्ट्स - जावा 8 ने स्ट्रीम एपीआई जोड़ा है जो मूल्यों की धाराओं पर कार्यात्मक-शैली संचालन के लिए समर्थन जोड़ता है:

पैकेज java.util.stream

जावा 8 समझाया गया: जावा संग्रह में लैम्ब्डा को लागू करना

LINQ से SQL / NHibernate / आदि। (डेटाबेस पूछताछ) - एक विकल्प जेएनक्यू का उपयोग करना होगा जो नई जावा 8 सुविधाओं का भी उपयोग करता है और 26 फरवरी, 2014 को गिथब पर जारी किया गया था: https://github.com/my2iu/Jinq

Jinq जावा में डेटाबेस क्वेरीज लिखने के लिए डेवलपर्स को एक आसान और प्राकृतिक तरीका प्रदान करता है। आप संग्रह डेटा में संग्रहीत सामान्य जावा ऑब्जेक्ट्स जैसे डेटाबेस डेटा का इलाज कर सकते हैं। आप उन पर पुनरावृत्त कर सकते हैं और सामान्य जावा कमांड का उपयोग करके उन्हें फ़िल्टर कर सकते हैं, और आपके सभी कोड स्वचालित रूप से अनुकूलित डेटाबेस क्वेरीज़ में अनुवादित किए जाएंगे। अंत में, जावा के लिए LINQ-style क्वेरी उपलब्ध हैं!

जेआईएनक्यू परियोजना साइट: http://www.jinq.org/


JaQu जावा के लिए LINQ समकक्ष है। हालांकि यह एच 2 डेटाबेस के लिए विकसित किया गया था, यह किसी भी डेटाबेस के लिए काम करना चाहिए क्योंकि यह जेडीबीसी का उपयोग करता है।


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

सॉर्टिंग (जावा 7 के लिए भी उपलब्ध है)

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

ग्रुपिंग (जावा 7 के लिए भी उपलब्ध है)

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

जुड़ता है (जावा 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);




linq