Mengira Kekerapan Perkataan dalam Java 8 Menggunakan Streams API

Memperkemas Analisis Kekerapan Perkataan di Jawa

Java 8 memperkenalkan Streams API yang berkuasa, merevolusikan cara pembangun mengendalikan pengumpulan dan pemprosesan data. Salah satu aplikasi paling praktikal bagi ciri ini ialah mengira kekerapan perkataan dalam satu set ayat. 🌟 Sama ada anda sedang memproses fail log atau menganalisis data teks, keupayaan untuk mengira kejadian perkataan dengan cekap adalah kemahiran yang berharga.

Bayangkan anda mempunyai satu set ayat, setiap satu dengan jumlah ruang putih dan kebiasaan pemformatan yang berbeza-beza. Bagaimanakah anda memastikan perkataan "rentetan" dikira secara konsisten, tanpa mengira jarak? Penyelesaian ini melibatkan pemahaman kaedah API Streams dan menguasai alat pengaturcaraan berfungsi Java.

Ramai pembangun bermula dengan pendekatan yang mudah—memisahkan rentetan dan mengulang secara manual melalui tatasusunan. Walaupun berfungsi, kaedah ini boleh menjadi bertele-tele dan sukar untuk dikekalkan. Berita baiknya ialah `Pengumpul` Java 8 boleh menyelaraskan proses ini menjadi penyelesaian yang ringkas dan elegan. 💡

Dalam panduan ini, kami akan menelusuri pengoptimuman pengiraan kekerapan perkataan menggunakan API Strim. Daripada perangkap biasa seperti ruang tambahan kepada contoh praktikal, anda akan belajar cara menjadikan kod Java anda lebih bersih dan lebih cekap. Mari selami! 🚀

Mengoptimumkan Analisis Kekerapan Perkataan dengan Java Streams

Skrip di atas direka untuk mengira kekerapan perkataan dengan cekap dalam susunan ayat menggunakan kuat API Java 8 Streams. Ini amat berguna untuk memproses data teks, seperti log atau analisis dokumen, di mana pengendalian ruang putih dan kepekaan huruf besar secara konsisten adalah penting. Aliran utama bermula dengan menukar tatasusunan input rentetan kepada aliran perkataan bersatu. Ini dicapai menggunakan kaedah `flatMap`, yang membahagikan setiap ayat kepada perkataan individu sambil menghapuskan jarak yang tidak teratur. Sebagai contoh, jika input mempunyai ruang tambahan, ini dikendalikan dengan anggun tanpa kod tambahan, memudahkan tugasan. 😊

Satu ciri utama skrip ialah penggunaan `penapis` untuk mengecualikan rentetan kosong, yang mungkin terhasil daripada pemisahan ayat dengan berbilang ruang. Selepas itu, `map(String::trim)` digunakan untuk menyeragamkan format perkataan dengan mengalih keluar sebarang baki ruang hadapan atau belakang. Ini memastikan bahawa perkataan seperti "sampel" dan "sampel " dianggap sama. Gabungan kaedah ini menyediakan mekanisme yang diperkemas dan boleh dipercayai untuk pemprosesan teks, terutamanya apabila berurusan dengan data input yang tidak dapat diramalkan.

Pengumpulan dan pengiraan perkataan dikendalikan dengan `Collectors.groupingBy` dan `Collectors.counting`. Kedua-dua kaedah ini bekerjasama untuk mencipta peta di mana setiap perkataan unik adalah kunci, dan kekerapannya ialah nilainya. Contohnya, dalam input "Ini ialah rentetan sampel," perkataan "sampel" muncul berbilang kali merentas ayat input. Pendekatan ini memastikan bahawa jumlah kejadiannya ditangkap, memberikan kiraan kekerapan yang tepat. Dengan menggunakan `Function.identity()` sebagai pengelas, perkataan itu sendiri digunakan sebagai kunci dalam peta yang terhasil.

Akhir sekali, skrip termasuk modulariti dan kebolehgunaan semula dengan memperkenalkan kaedah utiliti seperti `calculateWordFrequencies`, menjadikan logik mudah untuk dikekalkan dan disepadukan ke dalam projek yang lebih besar. Kemasukan ujian unit selanjutnya mengesahkan bahawa penyelesaian berfungsi seperti yang diharapkan merentasi pelbagai input. Sebagai contoh, kes ujian mengesahkan bahawa isu biasa, seperti ruang mengekor atau mengubah huruf besar perkataan, tidak menjejaskan keputusan. Tahap keteguhan ini menjadikan skrip sesuai untuk senario dunia sebenar, seperti menganalisis kandungan yang dijana pengguna atau menghuraikan log carian. 🚀

import java.util.Arrays;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
public class WordFrequency {
    public static void main(String[] args) {
        // Input array of sentences
        String[] input = {
            "This is a sample string",
            " string ",
            "Another sample string",
            "This is not    a sample string"
        };
        // Stream pipeline for word frequency calculation
        Map<String, Long> wordFrequencies = Arrays.stream(input)
            .flatMap(sentence -> Arrays.stream(sentence.split("\\s+")))
            .filter(word -> !word.isEmpty())
            .map(String::trim)
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
        // Output the result
        System.out.println(wordFrequencies);
    }
}

import java.util.Arrays;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
public class WordFrequencyWithUtils {
    public static void main(String[] args) {
        String[] input = {
            "This is a sample string",
            " string ",
            "Another sample string",
            "This is not    a sample string"
        };
        Map<String, Long> result = calculateWordFrequencies(input);
        System.out.println(result);
    }
    public static Map<String, Long> calculateWordFrequencies(String[] sentences) {
        return Arrays.stream(sentences)
            .flatMap(sentence -> Arrays.stream(sentence.split("\\s+")))
            .filter(word -> !word.isEmpty())
            .map(String::trim)
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
    }
}

import org.junit.jupiter.api.Test;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.*;
public class WordFrequencyTest {
    @Test
    void testCalculateWordFrequencies() {
        String[] input = {
            "This is a sample string",
            " string ",
            "Another sample string",
            "This is not    a sample string"
        };
        Map<String, Long> result = WordFrequencyWithUtils.calculateWordFrequencies(input);
        assertEquals(2, result.get("This"));
        assertEquals(4, result.get("string"));
        assertEquals(3, result.get("sample"));
        assertEquals(1, result.get("not"));
    }
}

Menguasai Pemprosesan Teks dengan Teknik Java Lanjutan

Apabila menganalisis data teks, pengendalian sensitiviti kes dan normalisasi adalah kritikal. Di Jawa, the API Strim menyediakan fleksibiliti untuk menangani cabaran ini dengan usaha yang minimum. Sebagai contoh, dengan menggunakan kaedah seperti map(String::toLowerCase), anda boleh memastikan bahawa perkataan seperti "Sampel" dan "sampel" dianggap sama, meningkatkan ketekalan. Ini amat berguna dalam aplikasi berkaitan carian yang pengguna mungkin tidak mematuhi konvensyen kes.

Satu lagi pertimbangan penting ialah tanda baca. Perkataan seperti "rentetan" dan "rentetan" selalunya dianggap sebagai token berbeza jika tanda baca tidak dialih keluar. menggunakan replaceAll("[^a-zA-Z0-9 ]", ""), anda boleh menanggalkan aksara yang tidak diingini sebelum memproses teks. Ini penting untuk set data dunia sebenar, seperti ulasan atau ulasan pengguna, yang tanda baca adalah perkara biasa. Dengan menggabungkan teknik ini dengan alat sedia ada seperti Collectors.groupingBy, anda boleh membuat set data yang bersih dan dinormalkan.

Akhir sekali, pengoptimuman untuk prestasi adalah kunci apabila bekerja dengan set data yang besar. menggunakan parallelStream() membolehkan skrip memproses data merentas berbilang urutan, mengurangkan masa jalan dengan ketara. Ini boleh menjadi pengubah permainan untuk aplikasi yang berurusan dengan berjuta-juta perkataan. Penambahbaikan ini, apabila digabungkan dengan ujian unit, menjadikan penyelesaian itu teguh dan berskala untuk persekitaran pengeluaran, memastikan ia berfungsi dengan baik dalam keadaan yang pelbagai. 🚀