Menyingkirkan loop di Java 8

Gaya fungsional yang diperkenalkan di Java 8 merupakan tambahan yang bagus untuk bahasa ini. Sekarang Java bukan OOP murni, sekarang merupakan gabungan dari OOP dan pemrograman fungsional. Ini adalah terobosan baru dan kita perlu mengubah otak OOP kita untuk menyerap perubahan ini. Namun mengapa kita harus menerima perubahan ini? Mengapa kita harus membuang waktu untuk mencoba menggunakan gaya fungsional ketika kita dapat menyelesaikan masalah menggunakan OOP murni?

• Gaya fungsional yang diperkenalkan di Java 8 membantu kita mengurangi kesenjangan antara logika bisnis dan kode. Hal ini memungkinkan kita untuk menceritakan kisah dalam aliran alami pada tingkat yang lebih tinggi. Daripada mengatakan bagaimana Anda ingin melakukannya, Anda bisa mengatakan apa yang ingin Anda lakukan.

• Kode menjadi lebih bersih dan ringkas.

• Fungsi tingkat tinggi memungkinkan kita untuk:

  • Kirim fungsi ke fungsi lain
  • Buat fungsi di dalam fungsi lainnya
  • Mengembalikan fungsi dari fungsi lainnya

  Ini adalah kemenangan besar bagi Java, di mana kita perlu mengirim, membuat, dan mengembalikan objek untuk melakukan hal ini. Kita akan dapat menulis kode yang lebih andal, fokus, dan lebih mudah digunakan kembali.

• Berkat lambdas, kita bisa melakukan perhitungan yang malas. Ketika ekspresi lambda dikirim sebagai argumen metode, kompiler akan mengevaluasinya ketika dipanggil dalam metode. Ini berbeda dengan argumen metode normal, yang langsung dievaluasi.

• Lambdas membuat pengujian unit penulisan menjadi menyenangkan. Mereka memungkinkan kami membuat pengujian ringan yang bersih, berukuran kecil, dan cepat ditulis. Kita dapat melakukan root pada kode yang sedang diuji menggunakan lambda. Hal ini memungkinkan kami menguji bagaimana semua jenis skenario akan memengaruhi kode.

• Pola baru untuk dipelajari.

• Dan banyak lagi!

Tapi cukup air, dalam artikel ini kita akan melihat solusi alternatif untuk siklus tradisional. Tentu saja, siklus itu fleksibel, tetapi hal ini bukannya tanpa konsekuensi. break, secara dramatis mengubah perilaku perulangan, memaksa kita untuk memahami tidak hanya apa yang ingin dicapai oleh kode, continuetetapi returnjuga untuk memahami cara kerja perulangan. Sekarang kita akan melihat bagaimana kita dapat mengubah loop menjadi kode yang lebih ringkas dan mudah dibaca.

Biarkan pengkodean dimulai!

Kami akan bekerja dengan artikel. Sebuah artikel memiliki judul, penulis dan beberapa tag.

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

Setiap contoh akan berisi solusi tradisional menggunakan loop dan solusi menggunakan fitur baru Java 8. Pada contoh pertama, kami ingin mencari artikel pertama dalam koleksi dengan tag “Java”. Mari kita lihat solusi menggunakan loop.

public Article getFirstJavaArticle() {

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

Sekarang mari kita selesaikan masalah menggunakan operasi dari Stream API.

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

Cukup keren, bukan? Pertama kita gunakan operasi filteruntuk mencari semua artikel dengan tag “Java”, lalu kita gunakan findFirst()untuk mendapatkan kemunculan pertama. Karena aliran lambat dan filter mengembalikan aliran, pendekatan ini hanya akan memproses elemen hingga menemukan kecocokan pertama. Sekarang mari kita buat semua artikel diberi tag “Java” dan bukan hanya artikel pertama saja. Pertama solusinya menggunakan loop.

public List<Article> getAllJavaArticles() {

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

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

Solusi menggunakan operasi aliran.

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

Dalam contoh ini, kami menggunakan operasi collectuntuk mempersingkat aliran yang dihasilkan, daripada mendeklarasikan koleksi dan secara eksplisit menambahkan entri yang cocok. Sejauh ini bagus. Saatnya memberikan contoh yang akan membuat Stream API benar-benar bersinar. Mari kelompokkan semua artikel berdasarkan penulis. Seperti biasa, kita mulai dengan menyelesaikannya menggunakan loop:

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

Bisakah kita menemukan solusi tepat untuk masalah ini menggunakan operasi aliran?

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

Luar biasa! Dengan menggunakan operasi groupingBydan referensi metode getAuthor(), kita mendapatkan kode yang bersih dan mudah dibaca. Sekarang mari kita temukan tag lainnya yang digunakan dalam koleksi. Mari kita mulai dengan contoh perulangan:

public Set<String> getDistinctTags() {

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

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

Oke, mari kita lihat bagaimana kita dapat menyelesaikan masalah ini menggunakan operasi aliran:

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

Dingin! flatmapmembantu kami meratakan daftar tag menjadi satu aliran hasil, yang kemudian kami gunakan collectuntuk membuat kumpulan kembalian.

Kemungkinan Tanpa Batas

Ini adalah 4 contoh bagaimana loop dapat diganti dengan kode yang lebih mudah dibaca. Pastikan untuk memeriksa Stream API, karena artikel ini hanya membahas permukaan saja. Menguasai gaya fungsional baru Java akan menjadi tantangan bagi pengembang OOP, namun ini merupakan tantangan yang harus diterima dengan baik. Saya bahkan akan mengatakan lebih jauh bahwa Anda harus mempelajari bahasa pemrograman fungsional murni. Dengan cara ini Anda dapat sepenuhnya memahami kemampuan dan kekuatan yang diberikannya. Saya rasa ini akan membantu Anda memahami pemrograman fungsional di tingkat lain. Jadi pelajari pemrograman fungsional bersama dengan OOP lama yang bagus, dan gunakan keduanya untuk menulis kode yang lebih hebat lagi! Campuran terjemahan dua artikel gratis - Mengapa Anda harus menggunakan pemrograman fungsional di Java 8 dan Menjauh dari Loops di Java 8