Menghilangkan gelung dalam Java 8

Gaya berfungsi yang diperkenalkan dalam Java 8 adalah tambahan yang bagus kepada bahasa. Kini Java bukan OOP tulen, kini ia adalah gabungan OOP dan pengaturcaraan berfungsi. Ini adalah pengubah permainan dan kami perlu menukar otak OOP kami untuk menyerap perubahan ini. Tetapi mengapa kita harus menerima perubahan ini? Mengapa kita perlu membuang masa cuba untuk bergaul dengan gaya berfungsi apabila kita boleh menyelesaikan masalah menggunakan OOP tulen?

• Gaya berfungsi yang diperkenalkan dalam Java 8 membantu kami mengurangkan jurang antara logik perniagaan dan kod. Ia membolehkan kita menceritakan kisah dalam aliran semula jadi pada tahap yang lebih tinggi. Daripada mengatakan bagaimana anda mahu melakukannya, anda boleh mengatakan apa yang anda mahu lakukan.

• Kod menjadi lebih bersih dan ringkas.

• Fungsi pesanan tinggi membolehkan kami:

  • Hantar fungsi ke fungsi lain
  • Cipta fungsi di dalam fungsi lain
  • Kembalikan fungsi daripada fungsi lain

  Ini adalah kemenangan besar untuk Java, di mana kita perlu menghantar, mencipta dan mengembalikan objek untuk melakukan ini. Kami akan dapat menulis kod yang lebih dipercayai, fokus dan lebih mudah untuk digunakan semula.

• Terima kasih kepada lambdas, kami boleh melakukan pengiraan malas. Apabila ungkapan lambda dihantar sebagai hujah kaedah, pengkompil akan menilainya apabila ia dipanggil dalam kaedah. Ini berbeza daripada hujah kaedah biasa, yang dinilai serta-merta.

• Lambdas menjadikan ujian unit menulis menyeronokkan. Mereka membenarkan kami membuat ujian ringan yang bersih, bersaiz kecil dan pantas untuk ditulis. Kita boleh menghapuskan kod yang sedang diuji menggunakan lambdas. Ini membolehkan kami menguji cara semua jenis senario akan mempengaruhi kod.

• Corak baru untuk dipelajari.

• Dan banyak lagi!

Tetapi air yang mencukupi, dalam artikel ini kita akan melihat penyelesaian alternatif kepada kitaran tradisional. Sudah tentu, kitaran adalah fleksibel, tetapi ini tidak datang tanpa harga. break, mengubah tingkah laku gelung secara mendadak, memaksa kita memahami bukan sahaja perkara yang cuba dicapai oleh kod itu, continuetetapi returnjuga memahami cara gelung itu berfungsi. Sekarang kita akan melihat bagaimana kita boleh mengubah gelung menjadi kod yang lebih ringkas dan boleh dibaca.

Biarkan pengekodan bermula!

Kami akan bekerja dengan artikel. Sebuah artikel mempunyai tajuk, pengarang 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 mengandungi penyelesaian tradisional menggunakan gelung dan penyelesaian menggunakan ciri baharu Java 8. Dalam contoh pertama, kami ingin mencari artikel pertama dalam koleksi dengan teg "Java". Mari kita lihat penyelesaian menggunakan gelung.

public Article getFirstJavaArticle() {

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

Sekarang mari kita selesaikan masalah menggunakan operasi daripada API Strim.

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

Agak hebat, bukan? Kami mula-mula menggunakan operasi filteruntuk mencari semua artikel dengan teg "Java", kemudian kami gunakan findFirst()untuk mendapatkan kejadian pertama. Memandangkan strim malas dan penapis mengembalikan strim, pendekatan ini hanya akan memproses elemen sehingga ia menemui padanan pertama. Sekarang mari kita dapatkan semua artikel yang ditandakan “Java” dan bukannya yang pertama sahaja. Pertama penyelesaian menggunakan gelung.

public List<Article> getAllJavaArticles() {

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

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

Penyelesaian 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 memendekkan strim yang terhasil, dan bukannya mengisytiharkan koleksi dan menambah entri yang sepadan secara eksplisit. Setakat ini baik. Masa untuk contoh yang akan menjadikan Stream API benar-benar bersinar. Mari kumpulkan semua artikel mengikut pengarang. Seperti biasa, kita mulakan dengan menyelesaikannya menggunakan gelung:

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

Bolehkah kita mencari penyelesaian yang bersih untuk masalah ini menggunakan operasi aliran?

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

Hebat! Dengan menggunakan operasi groupingBydan rujukan kaedah getAuthor(), kami mendapat kod yang bersih dan boleh dibaca. Sekarang mari cari teg yang lain yang digunakan dalam koleksi. Mari kita mulakan dengan contoh gelung:

public Set<String> getDistinctTags() {

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

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

Okay, mari kita lihat cara kita boleh menyelesaikan perkara ini menggunakan operasi strim:

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

Sejuk! flatmapmembantu kami meratakan senarai teg ke dalam satu aliran hasil, yang kemudian kami gunakan collectuntuk membuat set pulangan.

Kemungkinan yang tidak berkesudahan

Ini ialah 4 contoh bagaimana gelung boleh digantikan dengan kod yang lebih mudah dibaca. Pastikan anda menyemak API Strim, kerana artikel ini hanya menconteng permukaan. Menguasai gaya fungsi Java yang baharu akan menjadi satu cabaran bagi pembangun OOP, tetapi ia merupakan satu cabaran yang harus diterima dengan baik. Saya akan pergi lebih jauh dan mengatakan bahawa anda harus mempelajari bahasa pengaturcaraan berfungsi tulen. Dengan cara ini anda boleh memahami sepenuhnya keupayaan dan kuasa yang diberikannya. Saya fikir ini akan membantu anda memahami pengaturcaraan berfungsi pada tahap yang berbeza. Jadi pelajari pengaturcaraan berfungsi bersama-sama dengan OOP lama yang baik, dan gunakan kedua-duanya untuk menulis kod yang lebih hebat! Campuran percuma terjemahan dua artikel - Mengapa anda harus menerima pengaturcaraan berfungsi dalam Java 8 dan Swerving Away from Loops in Java 8