Java เทียบเท่ากับ LINQ คืออะไร [ปิด]

Java เทียบเท่ากับ LINQ คืออะไร

ไม่มีอะไรที่เหมือนกับ LINQ สำหรับ Java

...

แก้ไข

ขณะนี้มี Java 8 ที่เรารู้จักกับStream APIนี่เป็นสิ่งที่คล้ายกันเมื่อจัดการกับคอลเลกชัน แต่มันไม่เหมือนกับ Linq

หากเป็น ORM ที่คุณกำลังมองหาเช่น Entity Framework คุณสามารถลองHibernate ได้

:-)

มีวิธีการแก้ปัญหาอื่นคือCoollection

Coolection ไม่ได้หลอกว่าเป็นแลมบ์ดาใหม่ แต่เราล้อมรอบด้วยโปรเจ็กต์เก่าของ Java ที่ lib นี้จะช่วย ง่ายมากที่จะใช้และขยายซึ่งครอบคลุมเฉพาะการกระทำที่ใช้มากที่สุดของการวนซ้ำในคอลเลกชันเช่นนั้น:

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

แลมบ์ดามีวางจำหน่ายภายใน Java 8 ในรูปแบบของJSR-335 - แลมบ์ดานิพจน์สำหรับ JavaTM Programming Language

ปรับปรุง : JDK8 ตอนนี้ได้รับการปล่อยตัวซึ่งมีแลมบ์ดาโครงการ มันคุ้มค่าที่จะคว้าสำเนาของJava 8 in Action ในปัจจุบันมาเป็น MEAP

อ่านบทความของBrian Goetz ที่เกี่ยวข้องกับ lambdas เพื่อทำความเข้าใจว่า lambdas ถูกนำไปใช้ใน JDK8 ได้อย่างไรในขณะที่ยังได้รับความเข้าใจเกี่ยวกับลำธารการวนซ้ำภายในการลัดวงจรและการอ้างอิงคอนสตรัคเตอร์อีกด้วย .

ผมเคยเขียนบล็อกในบางส่วนของข้อดีของการใช้ lambdas ใน JDK8 เรียกว่าพลังของลูกยังNetBeans 8ได้รับการสนับสนุนที่ดีสำหรับการแปลงโครงสร้างการ JDK8 ซึ่งผมเคย blogged ยังเกี่ยวกับการโยกย้ายไปยัง JDK 8 กับ NetBeans

คุณสามารถเลือกรายการในคอลเลกชัน (และอื่น ๆ อีกมากมาย) ในวิธีที่อ่านได้มากขึ้นโดยใช้ห้องสมุด lambdaj

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

มันมีข้อดีกว่าห้องสมุด Quaere เพราะมันไม่ได้ใช้สายเวทย์ใด ๆ มันปลอดภัยอย่างสมบูรณ์และฉันคิดว่ามันมี DSL ที่อ่านได้มากกว่า

คุณจะไม่พบสิ่งเทียบเท่า LINQ เว้นแต่ว่าคุณจะใช้javaccเพื่อสร้างสิ่งที่เทียบเท่าของคุณเอง

จนกว่าจะถึงวันนั้นเมื่อมีคนพบวิธีที่ปฏิบัติได้มีทางเลือกที่ดีเช่น

• jOOQ
• JINQ
• Jaque
• JaQu
• Linq4j
• Quaere (ไม่ได้รับการดูแลอีกต่อไป)
• QueryDSL
• JSR-341

LINQ to Objects - JAVA 8 ได้เพิ่ม Stream API ซึ่งเพิ่มการสนับสนุนสำหรับการใช้งานในรูปแบบการใช้งานบนกระแสของค่า:

แพ็คเกจ java.util.stream

Java 8 อธิบายแล้ว: การใช้ Lambdas กับ Java Collections

LINQ เป็น SQL / NHibernate / ฯลฯ (การสืบค้นฐานข้อมูล) - ตัวเลือกหนึ่งคือใช้ JINQ ซึ่งใช้คุณสมบัติ JAVA 8 ใหม่และเปิดตัวเมื่อวันที่ 26 กุมภาพันธ์ 2014 บน Github: https://github.com/my2iu/Jinq

Jinq ให้นักพัฒนาวิธีที่ง่ายและเป็นธรรมชาติในการเขียนแบบสอบถามฐานข้อมูลใน Java คุณสามารถจัดการข้อมูลฐานข้อมูลเช่นวัตถุ Java ปกติที่เก็บในคอลเลกชัน คุณสามารถทำซ้ำได้มากกว่าพวกเขาและกรองพวกเขาโดยใช้คำสั่ง Java ปกติและรหัสทั้งหมดของคุณจะถูกแปลโดยอัตโนมัติเป็นแบบสอบถามฐานข้อมูลที่ดีที่สุด ในที่สุดเคียวรีสไตล์ LINQ พร้อมใช้งานสำหรับ Java!

ไซต์โครงการ JINQ: http://www.jinq.org/

มีโครงการที่เรียกว่าเป็นquaere

เป็นกรอบงาน Java ที่เพิ่มความสามารถในการสืบค้นคอลเลกชัน

หมายเหตุ: ตามที่ผู้เขียน, โครงการจะไม่รักษาอีกต่อไป

มี LINQ ที่เทียบเท่ากับ Java มากมายให้ดูที่นี่เพื่อเปรียบเทียบ

สำหรับ typesafe กรอบสไตล์ Quaere / LINQ พิจารณาใช้Querydsl Querydsl รองรับ JPA / Hibernate, JDO, SQL และ Java Collections

ฉันเป็นผู้ดูแลของ Querydsl ดังนั้นคำตอบนี้จึงมีอคติ

คุณสามารถใช้สกาล่ามันคล้ายกับซินแท็กซ์และจริงๆแล้วมันอาจมีประสิทธิภาพมากกว่าลินุกซ์

ในปี 2014 ฉันสามารถพูดได้ว่าในที่สุด LINQ จะอยู่ที่นั่นใน java 8. ดังนั้นไม่จำเป็นต้องหาทางเลือกของ LINQ อีกต่อไป

ตอนนี้ Java 8 รองรับ lambdas เป็นไปได้ที่จะสร้าง Java APIs ที่คล้ายกับ LINQ

Jinqเป็นหนึ่งในไลบรารีสไตล์ LINQ ใหม่เหล่านี้สำหรับ Java

ฉันเป็นผู้พัฒนาห้องสมุดนี้ มันขึ้นอยู่กับห้าปีของการวิจัยเกี่ยวกับการใช้การวิเคราะห์ bytecode เพื่อแปล Java เป็นแบบสอบถามฐานข้อมูล เช่นเดียวกับวิธี D-LINQ ของ C # เป็นเลเยอร์แบบสอบถามที่อยู่ด้านบนของ Entity Framework, Jinq สามารถทำหน้าที่เป็นเลเยอร์แบบสอบถามที่อยู่ด้านบนของ JPA หรือ jOOQ มันมีการสนับสนุนสำหรับการรวมกลุ่มและแบบสอบถามย่อย แม้เอริคเมย์เยอร์ (ผู้สร้าง LINQ) ที่ได้รับการยอมรับ Jinq

ดูSBQL4J มันเป็นภาษาคิวรีที่ปลอดภัยชนิดที่ปลอดภัยรวมกับ Java อนุญาตให้เขียนแบบสอบถามที่ซับซ้อนและซ้อนกันหลายรายการ มีโอเปอเรเตอร์จำนวนมากวิธีการของจาวาสามารถถูกเรียกใช้ภายในเคียวรีเพื่อเป็นตัวสร้าง การค้นหาถูกแปลเป็นโค้ด Java บริสุทธิ์ (ไม่มีการสะท้อนที่รันไทม์) ดังนั้นการดำเนินการจึงรวดเร็วมาก

แก้ไข: ตอนนี้ SBQL4J เป็นเพียงส่วนขยายของภาษาจาวาเท่านั้นซึ่งให้ความสามารถในการสืบค้นคล้ายกับ LINQ มีบางโครงการที่น่าสนใจเช่น Quaere และ JaQue แต่เป็นเพียง API เท่านั้นไม่ใช่ส่วนขยายไวยากรณ์ / ความหมายที่มีความปลอดภัยสูงในเวลารวบรวม

Java LINQ กับการใช้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;
    }
}

กรอง

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

การเรียงลำดับ (มีให้สำหรับ 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 หรือใน java เก่ากับRetroLambdaและมันเป็นปลั๊กอิน gradleจากนั้นคุณจะมีรูปแบบแฟนซีใหม่:

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

หากคุณต้องการรันการสืบค้น DB คุณสามารถดู JINQ ได้ตามที่กล่าวไว้ข้างต้น แต่ไม่สามารถย้อนกลับพอร์ตโดย RetroLambda ได้ให้ใช้ lambdas ต่อเนื่อง

เพียงเพื่อเพิ่มทางเลือกอื่น: Java 6 มีวิธีแก้ปัญหาสำหรับการสืบค้นฐานข้อมูลที่ปลอดภัยโดยใช้แพ็คเกจjavax.persistence.criteria

แม้ว่าฉันต้องบอกว่านี่ไม่ใช่ LINQ จริงๆเพราะด้วย LINQ คุณสามารถค้นหา IEnumerable ใด ๆ

มีห้องสมุดที่ดีมากที่คุณสามารถใช้ได้

อยู่ที่นี่: https://github.com/nicholas22/jpropel-light

แลมบ์ดาจะไม่สามารถใช้งานได้จนถึง Java 8 ดังนั้นการใช้งานจะแตกต่างกันเล็กน้อยและไม่รู้สึกเป็นธรรมชาติ

ดูเหมือนว่า Linq ที่ทุกคนพูดถึงที่นี่เป็นเพียง LinqToObjects ซึ่งฉันเชื่อว่ามีเพียงฟังก์ชันการทำงานที่สามารถทำได้ในวันนี้ใน Java แต่ด้วยไวยากรณ์ที่น่าเกลียดจริงๆ

สิ่งที่ฉันเห็นในฐานะพลังที่แท้จริงของ Linq ใน. Net คือการแสดงออกแลมบ์ดาสามารถนำมาใช้ในบริบทที่ต้องการตัวแทนหรือนิพจน์และจากนั้นจะถูกรวบรวมเป็นรูปแบบที่เหมาะสม นี่คือสิ่งที่อนุญาตให้สิ่งต่าง ๆ เช่น LinqToSql (หรือสิ่งอื่นใดนอกเหนือจาก LinqToObjects) ในการทำงานและช่วยให้พวกเขามีไวยากรณ์เหมือนกันกับ LinqToObjects

ดูเหมือนว่าทุกโครงการที่กล่าวถึงข้างต้นจะเสนอความสามารถของ LinqToObjects เท่านั้น ซึ่งทำให้ฉันเป็นสิ่งที่ฟังก์ชั่นประเภท LinqToSql ไม่ได้อยู่บนขอบฟ้าสำหรับ Java

สำหรับคอลเลกชันการทำงานขั้นพื้นฐาน Java 8 มีอยู่แล้วภายในส่วนใหญ่ภาษาที่ไม่ใช่ Java JVM ส่วนใหญ่จะมีอยู่แล้วภายใน (Scala, Clojure ฯลฯ ) และคุณสามารถเพิ่ม libs สำหรับ Java เวอร์ชันก่อนหน้าได้

สำหรับการเข้าถึงภาษาฐานข้อมูล SQL แบบบูรณาการอย่างสมบูรณ์ Scala (ทำงานบน JVM) มีความลื่นไหล

สำหรับ LINQ (LINQ กับวัตถุ), Java 8 จะมีสิ่งที่เทียบเท่าดูโครงการแลมบ์ดา

มันมี Enumerable ของLINQ กับส่วนขยายของวัตถุเช่นวัตถุดิบ แต่สำหรับ LINQ ที่ซับซ้อนกว่าเช่นExpressionและ ExpressionTree (สิ่งเหล่านี้จำเป็นสำหรับ LINQ กับ SQL และผู้ให้บริการ LINQ อื่น ๆ หากพวกเขาต้องการให้สิ่งที่ปรับให้เหมาะสมและเป็นของจริง) ไม่มีอะไรเทียบเท่า แต่บางทีเราจะเห็นในอนาคต :)

แต่ฉันไม่คิดว่าจะมีสิ่งใดที่เหมือนกับข้อความค้นหาแถลงการณ์บน Java ในอนาคต

ไม่มีคุณสมบัติดังกล่าวใน java เมื่อใช้ API อื่นคุณจะได้รับคุณลักษณะนี้ อย่างเช่นสมมติว่าเรามีสัตว์วัตถุที่มีชื่อและรหัส เรามีรายการวัตถุที่มีวัตถุสัตว์ ตอนนี้ถ้าเราต้องการได้รับชื่อสัตว์ทั้งหมดที่มี 'o' จากรายการวัตถุ เราสามารถเขียนแบบสอบถามต่อไปนี้

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

ข้อความสั่งการด้านบนจะแสดงรายการสัตว์ที่มีตัวอักษร 'o' อยู่ในชื่อ ข้อมูลเพิ่มเติมโปรดอ่านบล็อกต่อไปนี้ http://javaworldwide.blogspot.in/2012/09/linq-in-java.html

ตรวจสอบเล็ก ๆ -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 เทียบเท่ากับ LINQ สำหรับ Java แม้ว่าจะได้รับการพัฒนาสำหรับฐานข้อมูล H2 แต่ก็ควรทำงานกับฐานข้อมูลใด ๆ เนื่องจากใช้ JDBC

อาจจะไม่ได้คำตอบที่คุณกำลังหวังให้ แต่ถ้าบางส่วนของคุณรหัสจำเป็นที่จะต้องทำงานหนักในคอลเลกชัน (การค้นหาการเรียงลำดับการกรองการแปลงการวิเคราะห์) ที่คุณอาจต้องใช้เวลาในการพิจารณาที่จะเขียนบางชั้นเรียนในClojureหรือScala

เนื่องจากลักษณะการทำงานการทำงานกับคอลเลกชันจึงเป็นสิ่งที่ดีที่สุด ฉันไม่ได้มีประสบการณ์กับ Scala มากนัก แต่ด้วย Clojure คุณอาจจะพบ Linq ที่ทรงพลังมากขึ้นเพียงปลายนิ้วสัมผัสและเมื่อรวบรวมแล้วชั้นเรียนที่คุณสร้างจะผสมผสานอย่างราบรื่นกับส่วนอื่น ๆ ของรหัส

ผู้ใช้ที่ไม่ระบุชื่อพูดถึงอีกคนหนึ่งกำลัง :

การกำหนดเป็นไลบรารีคลาสให้ความสามารถในการสืบค้นบนคอลเลกชันผ่านวิธีการเชื่อมต่อและอินเตอร์เฟสที่ไม่ระบุชื่อเช่น Linq ใน. NET ซึ่งแตกต่างจากห้องสมุดคอลเลกชันอื่น ๆ ส่วนใหญ่ที่ใช้วิธีการคงที่ต้องการซ้ำทั้งคอลเลกชัน, Diting ให้หลัก whitch คลาสที่นับไม่ได้มีวิธีการที่ chainable deffered เพื่อใช้แบบสอบถามในคอลเลกชันหรืออาร์เรย์

วิธีการที่รองรับ: ใด ๆ , โยน, ติดต่อ, มี, นับ, แตกต่างกัน, elementAt, ยกเว้น, เป็นครั้งแรก, ครั้งแรกหรือเริ่มต้น, กลุ่ม, โดยชุดย่อย, เข้าร่วม, สุดท้าย, สุดท้ายหรือเริ่มต้น, ประเภท, คำสั่ง , skipWhile, take, takeWhile, toArray, toArrayList, union, where

Scala.Now ฉันอ่านดาวและพบว่ามันเหมือน linq แต่ง่ายขึ้นและอ่านไม่ได้มากขึ้น แต่สกาล่าสามารถทำงานที่ลินุกซ์ใช่ไหม csharp ต้องการโมโน

มีภาษาการเขียนโปรแกรม Pizza (ส่วนขยาย Java) และคุณควรดูมัน - ใช้แนวคิดของ "ส่วนต่อประสานที่คล่องแคล่ว" เพื่อสืบค้นข้อมูลในลักษณะที่เปิดเผยและเป็นหลักการเดียวกับ LINQ โดยไม่มีนิพจน์การค้นหา (http://en.wikipedia.org/wiki/Pizza_programming_language) แต่อนิจจามันไม่ได้ถูกติดตาม แต่มันจะเป็นหนทางหนึ่งที่จะนำสิ่งที่คล้ายกับ LINQ ไปสู่ ​​Java

ไม่เทียบเท่ากับ LINQ สำหรับ Java แต่มี API ภายนอกบางตัวที่ดูเหมือน LINQ เช่นhttps://github.com/nicholas22/jpropel-light , https://code.google.com/p/jaque/

คุณสามารถลองใช้ห้องสมุดนี้: https://code.google.com/p/qood/

นี่คือเหตุผลบางอย่างที่จะใช้:

1. Lightweight: เพียง 9 public interface / class เพื่อเรียนรู้
2. แบบสอบถามเช่น SQL: รองรับกลุ่มตามคำสั่งโดยซ้ายเข้าร่วมสูตร ... ฯลฯ
3. สำหรับข้อมูลขนาดใหญ่: ใช้ File (QFS) แทน Heap Memory
4. พยายามที่จะแก้วัตถุสัมพันธ์ต้านทานไม่ตรงกัน