การกำจัดลูปใน Java 8

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

• รูปแบบการทำงานที่นำมาใช้ใน Java 8 ช่วยให้เราลดช่องว่างระหว่างตรรกะทางธุรกิจและโค้ด ทำให้เราเล่าเรื่องได้อย่างลื่นไหลเป็นธรรมชาติในระดับที่สูงขึ้น แทนที่จะพูดว่าคุณต้องการทำอย่างไร คุณสามารถพูดได้ว่าคุณต้องการทำอะไร

• โค้ดจะสะอาดและกระชับยิ่งขึ้น

• ฟังก์ชั่นลำดับสูงช่วยให้เรา:

  • ส่งฟังก์ชันไปยังฟังก์ชันอื่น
  • สร้างฟังก์ชันภายในฟังก์ชันอื่นๆ
  • ส่งกลับฟังก์ชันจากฟังก์ชันอื่น

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

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

• Lambdas ทำให้การทดสอบหน่วยการเขียนเป็นเรื่องสนุก ช่วยให้เราสามารถสร้างการทดสอบน้ำหนักเบาที่สะอาด ขนาดเล็ก และเขียนได้รวดเร็ว เราสามารถรูทโค้ดที่กำลังทดสอบโดยใช้แลมบ์ดาได้ สิ่งนี้ช่วยให้เราสามารถทดสอบได้ว่าสถานการณ์ทุกประเภทจะส่งผลต่อโค้ดอย่างไร

• รูปแบบใหม่ที่จะเรียนรู้

• และอีกมากมาย!

แต่พอมีน้ำเพียงพอ ในบทความนี้ เราจะมาดูวิธีแก้ปัญหาอื่นนอกเหนือจากวงจรแบบเดิมๆ แน่นอนว่ารอบการทำงานมีความยืดหยุ่น แต่สิ่งนี้ไม่ได้มาโดยไม่มีราคา breakเปลี่ยน พฤติกรรมของลูปอย่างมาก บังคับให้เราเข้าใจไม่เพียงแต่โค้ดที่พยายามบรรลุผลเท่านั้น continueแต่returnยังต้องเข้าใจวิธีการทำงานของลูปด้วย ตอนนี้เราจะมาดูกันว่าเราจะแปลงลูปให้เป็นโค้ดที่กระชับและอ่านง่ายขึ้นได้อย่างไร

ให้การเข้ารหัสเริ่มต้น!

เราจะทำงานกับบทความ บทความมีชื่อเรื่อง ผู้แต่ง และแท็กหลายรายการ

private class Article {

    private final String title;
    private final String author;
    private final List<String> tags;

    private Article(String title, String author, List<String> tags) {
        this.title = title;
        this.author = author;
        this.tags = tags;
    }

    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }

    public List<String> getTags() {
        return tags;
    }
}

แต่ละตัวอย่างจะมีโซลูชันแบบดั้งเดิมที่ใช้ลูปและโซลูชันที่ใช้คุณสมบัติใหม่ของ Java 8 ในตัวอย่างแรก เราต้องการค้นหาบทความแรกในคอลเลกชันที่มีแท็ก “Java” มาดูวิธีแก้ปัญหาโดยใช้ลูปกัน

public Article getFirstJavaArticle() {

    for (Article article : articles) {
        if (article.getTags().contains("Java")) {
            return article;
        }
    }
    return null;
}

ตอนนี้เรามาแก้ไขปัญหาโดยใช้การดำเนินการจาก Stream API

public Optional<Article> getFirstJavaArticle() {
    return articles.stream()
        .filter(article -> article.getTags().contains("Java"))
        .findFirst();
    }

ค่อนข้างเจ๋งใช่มั้ย? ขั้นแรกเราใช้การดำเนินการfilterเพื่อค้นหาบทความทั้งหมดที่มีแท็ก "Java" จากนั้นเราใช้findFirst()เพื่อให้เกิดรายการแรก เนื่องจากสตรีมเป็นแบบ Lazy และตัวกรองส่งคืนสตรีม วิธีการนี้จะประมวลผลเฉพาะองค์ประกอบต่างๆ จนกว่าจะพบรายการที่ตรงกันรายการแรก ตอนนี้เรามาดูบทความทั้งหมดที่ติดแท็ก “Java” แทนที่จะเป็นเพียงบทความแรก ขั้นแรกให้แก้ปัญหาโดยใช้ลูป

public List<Article> getAllJavaArticles() {

    List<Article> result = new ArrayList<>();

    for (Article article : articles) {
        if (article.getTags().contains("Java")) {
            result.add(article);
        }
    }
    return result;
}

โซลูชันที่ใช้การดำเนินการสตรีม

public List<Article> getAllJavaArticles() {
    return articles.stream()
        .filter(article -> article.getTags().contains("Java"))
        .collect(Collectors.toList());
    }

ในตัวอย่างนี้ เราใช้การดำเนินการcollectเพื่อทำให้สตรีมผลลัพธ์สั้นลง แทนที่จะประกาศคอลเลกชันและเพิ่มรายการที่ตรงกันอย่างชัดเจน จนถึงตอนนี้ดีมาก ถึงเวลาสำหรับตัวอย่างที่จะทำให้ Stream API โดดเด่นจริงๆ มาจัดกลุ่มบทความทั้งหมดตามผู้เขียน ตามปกติ เราเริ่มต้นด้วยการแก้ปัญหาโดยใช้ลูป:

public Map<String, List<Article>> groupByAuthor() {

    Map<String, List<Article>> result = new HashMap<>();

    for (Article article : articles) {
        if (result.containsKey(article.getAuthor())) {
            result.get(article.getAuthor()).add(article);
        } else {
            ArrayList<Article> articles = new ArrayList<>();
            articles.add(article);
            result.put(article.getAuthor(), articles);
        }
    }
    return result;
}

เราสามารถหาวิธีแก้ปัญหาใหม่ทั้งหมดสำหรับปัญหานี้โดยใช้การดำเนินการสตรีมได้หรือไม่

public Map<String, List<Article>> groupByAuthor() {
    return articles.stream()
        .collect(Collectors.groupingBy(Article::getAuthor));
}

อัศจรรย์! ด้วยการใช้การดำเนินการgroupingByและการอ้างอิงเมธอดgetAuthor()เราจะได้โค้ดที่สะอาดและอ่านง่าย ตอนนี้เรามาดูแท็กที่เหลือที่ใช้ในคอลเลกชันกัน เริ่มต้นด้วยตัวอย่างการวนซ้ำ:

public Set<String> getDistinctTags() {

    Set<String> result = new HashSet<>();

    for (Article article : articles) {
        result.addAll(article.getTags());
    }
    return result;
}

เอาล่ะ มาดูกันว่าเราจะแก้ไขปัญหานี้โดยใช้การดำเนินการสตรีมได้อย่างไร:

public Set<String> getDistinctTags() {
    return articles.stream()
        .flatMap(article -> article.getTags().stream())
        .collect(Collectors.toSet());
}

เย็น! flatmapช่วยให้เราเรียบเรียงรายการแท็กให้เป็นสตรีมผลลัพธ์เดียว ซึ่งเราจะใช้collectเพื่อสร้างชุดการส่งคืน

ความเป็นไปได้ไม่สิ้นสุด

นี่คือตัวอย่าง 4 ประการของการแทนที่ลูปด้วยโค้ดที่อ่านง่ายขึ้น อย่าลืมตรวจสอบ Stream API เนื่องจากบทความนี้เป็นเพียงเนื้อหาเบื้องต้นเท่านั้น การเรียนรู้รูปแบบการทำงานใหม่ของ Java จะเป็นความท้าทายสำหรับนักพัฒนา OOP แต่เป็นความท้าทายที่ควรได้รับการตอบรับอย่างดี ฉันจะพูดเพิ่มเติมอีกว่าคุณควรเรียนรู้ภาษาโปรแกรมเชิงฟังก์ชันล้วนๆ วิธีนี้จะทำให้คุณสามารถเข้าใจความสามารถและพลังที่มีให้ได้อย่างถ่องแท้ ฉันคิดว่าสิ่งนี้จะช่วยให้คุณเข้าใจ Functional Programming ในระดับที่แตกต่างกัน ดังนั้นเรียนรู้การเขียนโปรแกรมเชิงฟังก์ชันไปพร้อมกับ OOP เก่าๆ และใช้ทั้งสองอย่างเพื่อเขียนโค้ดที่ดียิ่งขึ้น! การผสมผสานการแปลสองบทความฟรี - ทำไมคุณควรยอมรับการเขียนโปรแกรมเชิงฟังก์ชันใน Java 8และSwerving Away from Loops ใน Java 8