Žodžių dažnių skaičiavimas Java 8 naudojant Streams API

Žodžių dažnio analizės supaprastinimas Java

„Java 8“ pristatė galingą „Streams“ API, sukeldama revoliuciją, kaip kūrėjai tvarko kolekcijas ir duomenų apdorojimą. Vienas iš praktiškiausių šios funkcijos pritaikymų yra žodžių dažnių skaičiavimas sakinių rinkinyje. 🌟 Nesvarbu, ar apdorojate žurnalo failus, ar analizuojate tekstinius duomenis, gebėjimas efektyviai skaičiuoti žodžių įvykius yra vertingas įgūdis.

Įsivaizduokite, kad turite sakinių rinkinį, kiekviename su skirtingu tarpų kiekiu ir formatavimo keistenybėmis. Kaip užtikrinti, kad žodis „eilutė“ būtų skaičiuojamas nuosekliai, nepaisant tarpų? Norint tai išspręsti, reikia suprasti Streams API metodus ir įvaldyti „Java“ funkcinius programavimo įrankius.

Daugelis kūrėjų pradeda nuo nesudėtingų metodų – skaido eilutes ir rankiniu būdu kartoja masyvus. Nors šie metodai yra funkcionalūs, jie gali tapti sudėtingi ir sunkiai prižiūrimi. Geros naujienos yra tai, kad „Java 8“ „Kolekcionieriai“ gali supaprastinti šį procesą į glaustą ir elegantišką sprendimą. 💡

Šiame vadove apžvelgsime žodžių dažnio skaičiavimo optimizavimą naudojant Streams API. Nuo įprastų spąstų, pvz., papildomų tarpų, iki praktinių pavyzdžių, sužinosite, kaip padaryti „Java“ kodą švaresnį ir efektyvesnį. Pasinerkime! 🚀

Žodžių dažnio analizės optimizavimas naudojant Java srautus

Aukščiau pateikti scenarijai skirti efektyviai skaičiuoti žodžių dažnį sakinių masyve naudojant galingą „Java 8 Streams“ API. Tai ypač naudinga apdorojant tekstinius duomenis, pvz., žurnalus ar dokumentų analizę, kai būtina nuosekliai tvarkyti tarpą ir didžiųjų ir mažųjų raidžių jautrumą. Pirminis srautas prasideda konvertuojant įvesties eilučių masyvą į vieningą žodžių srautą. Tai pasiekiama naudojant "flatMap" metodą, kuris suskaido kiekvieną sakinį į atskirus žodžius ir pašalina netaisyklingus tarpus. Pavyzdžiui, jei įvestyje yra papildomų tarpų, jie tvarkomi grakščiai be papildomo kodo, o tai supaprastina užduotį. 😊

Viena iš pagrindinių scenarijų ypatybių yra „filtro“ naudojimas, kad būtų pašalintos tuščios eilutės, kurios gali atsirasti suskaidžius sakinius su keliais tarpais. Vėliau taikomas „map(String::trim)“, kad būtų standartizuotas žodžių formatas, pašalinant visus likusius priekinius arba galinius tarpus. Taip užtikrinama, kad tokie žodžiai kaip „sample“ ir „sample“ būtų traktuojami kaip identiški. Šių metodų derinys suteikia supaprastintą ir patikimą teksto apdorojimo mechanizmą, ypač kai dirbama su nenuspėjamais įvesties duomenimis.

Žodžių grupavimas ir skaičiavimas atliekami naudojant „Collectors.groupingBy“ ir „Collectors.counting“. Šie du metodai veikia kartu, kad būtų sukurtas žemėlapis, kuriame kiekvienas unikalus žodis yra raktas, o jo dažnis yra reikšmė. Pavyzdžiui, įvestyje „Tai yra pavyzdinė eilutė“ žodis „sample“ pasirodo kelis kartus įvesties sakiniuose. Šis metodas užtikrina, kad būtų užfiksuoti visi jo įvykiai, o tai užtikrina tikslų dažnių skaičių. Naudojant „Function.identity()“ kaip klasifikatorių, pats žodis naudojamas kaip raktas gautame žemėlapyje.

Galiausiai, scenarijus apima moduliškumą ir galimybę pakartotinai naudoti tokius naudingus metodus kaip „calculateWordFrequencies“, todėl logiką lengva prižiūrėti ir integruoti į didesnius projektus. Vienetų testų įtraukimas dar labiau patvirtina, kad sprendimas veikia taip, kaip tikėtasi įvairiose įvesties srityse. Pavyzdžiui, bandomieji atvejai patvirtina, kad įprastos problemos, pvz., tarpai ar kintamoji didžiųjų raidžių rašyba, neturi įtakos rezultatams. Dėl tokio patvarumo scenarijai tinka realiems scenarijams, pvz., analizuojant vartotojo sukurtą turinį arba analizuojant paieškos žurnalus. 🚀

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

Teksto apdorojimo įvaldymas naudojant pažangias Java technologijas

Analizuojant tekstinius duomenis, labai svarbu tvarkyti didžiųjų ir mažųjų raidžių jautrumą ir normalizuoti. Java programoje Streams API suteikia lankstumo susidoroti su šiais iššūkiais su minimaliomis pastangomis. Pavyzdžiui, taikant tokius metodus kaip map(String::toLowerCase), galite užtikrinti, kad tokie žodžiai kaip „Pavyzdys“ ir „pavyzdys“ būtų traktuojami kaip identiški, todėl pagerėja nuoseklumas. Tai ypač naudinga su paieška susijusiose programose, kur vartotojai gali nesilaikyti atvejo konvencijų.

Kitas svarbus aspektas yra skyrybos ženklai. Tokie žodžiai, kaip „eilutė“ ir „eilutė“, dažnai traktuojami kaip skirtingi žetonai, jei skyrybos ženklai nepašalinami. Naudojant replaceAll("[^a-zA-Z0-9 ]", ""), galite pašalinti nepageidaujamus simbolius prieš apdorodami tekstą. Tai labai svarbu realaus pasaulio duomenų rinkiniams, pvz., naudotojų komentarams ar apžvalgoms, kur dažniausiai naudojami skyrybos ženklai. Derinant šiuos metodus su esamomis priemonėmis, pvz Collectors.groupingBy, galite sukurti švarų, normalizuotą duomenų rinkinį.

Galiausiai, dirbant su dideliais duomenų rinkiniais, labai svarbu optimizuoti našumą. Naudojant parallelStream() leidžia scenarijui apdoroti duomenis keliose gijose, žymiai sumažinant vykdymo laiką. Tai gali pakeisti žaidimą, kai kalbama apie milijonus žodžių. Dėl šių patobulinimų, kartu su vienetų testavimu, sprendimas yra tvirtas ir keičiamas gamybos aplinkoje, užtikrinant, kad jis gerai veiktų įvairiomis sąlygomis. 🚀