Sõnasageduste loendamine Java 8-s Streams API abil

Sõnade sageduse analüüsi sujuvamaks muutmine Javas

Java 8 tutvustas võimsat Streams API-t, mis muudab arendajate kogude ja andmetöötluse pöörde. Selle funktsiooni üks praktilisemaid rakendusi on sõnade sageduste loendamine lausekomplektis. 🌟 Olenemata sellest, kas töötlete logifaile või analüüsite tekstiandmeid, on sõnaesinemiste tõhus loendamine väärtuslik oskus.

Kujutage ette, et teil on lausete komplekt, millest igaühes on erineval hulgal tühikuid ja vormingu veidrusi. Kuidas tagada, et sõna "string" loetakse järjepidevalt, olenemata vahekaugusest? Selle lahendamine hõlmab Streams API meetodite mõistmist ja Java funktsionaalsete programmeerimistööriistade valdamist.

Paljud arendajad alustavad lihtsate lähenemisviisidega – stringide tükeldamisega ja massiivide käsitsi itereerimisega. Kuigi need meetodid toimivad, võivad need muutuda paljusõnaliseks ja neid on raske hooldada. Hea uudis on see, et Java 8 'kollektsionäärid' suudavad selle protsessi muuta ülevaatlikuks ja elegantseks lahenduseks. 💡

Selles juhendis käsitleme sõnade sageduse loendamise optimeerimist Streams API abil. Alates levinud lõksudest (nt lisatühikud) kuni praktiliste näideteni saate teada, kuidas muuta oma Java koodi puhtamaks ja tõhusamaks. Sukeldume sisse! 🚀

Sõnade sageduse analüüsi optimeerimine Java voogudega

Ülaltoodud skriptid on loodud sõnade sageduste tõhusaks loendamiseks lausemassiivis, kasutades võimsat Java 8 Streams API. See on eriti kasulik tekstiandmete (nt logid või dokumendianalüüs) töötlemisel, kus tühikute ja tõstutundlikkuse järjepidev käsitlemine on hädavajalik. Esmane voog algab stringide sisendmassiivi teisendamisega ühtseks sõnavooks. See saavutatakse meetodi "flatMap" abil, mis jagab iga lause üksikuteks sõnadeks, kõrvaldades samal ajal ebakorrapärased tühikud. Näiteks kui sisendis on lisatühikuid, käsitletakse neid graatsiliselt ilma täiendava koodita, mis lihtsustab ülesannet. 😊

Üks skriptide põhiomadus on 'filtri' kasutamine tühjade stringide välistamiseks, mis võib tuleneda mitme tühikuga lausete tükeldamisest. Seejärel rakendatakse sõnade vormingu standardiseerimiseks sõna "map(String::trim)", eemaldades kõik ees- või lõputühikud. See tagab, et selliseid sõnu nagu "proov" ja "proov" käsitletakse identsetena. Nende meetodite kombinatsioon tagab sujuva ja usaldusväärse mehhanismi tekstitöötluseks, eriti kui tegemist on ettearvamatute sisendandmetega.

Sõnade rühmitamist ja loendamist käsitletakse funktsioonidega "Collectors.groupingBy" ja "Collectors.counting". Need kaks meetodit töötavad koos, et luua kaart, kus iga kordumatu sõna on võti ja selle sagedus on väärtus. Näiteks sisendis "See on näidisstring" ilmub sisestuslausetes mitu korda sõna "näidis". See lähenemisviis tagab selle kogujuhtumite jäädvustamise, pakkudes täpset sagedusloendust. Kasutades klassifikaatorina funktsiooni „Function.identity()”, kasutatakse saadud kaardil võtmena sõna ennast.

Lõpuks hõlmavad skriptid modulaarsust ja korduvkasutatavust, tutvustades selliseid kasulikke meetodeid nagu "calculateWordFrequencies", mis muudab loogika hõlpsaks hooldamiseks ja suurematesse projektidesse integreerimise. Ühikutestide kaasamine kinnitab veelgi, et lahendus töötab erinevate sisendite puhul ootuspäraselt. Näiteks kontrollivad testjuhtumid, et levinud probleemid, nagu tühikud või sõnade vahelduv suurtähtede kasutamine, ei mõjuta tulemusi. Selline vastupidavuse tase muudab skriptid sobivaks reaalsete stsenaariumide jaoks, näiteks kasutajate loodud sisu analüüsimiseks või otsingulogide sõelumiseks. 🚀

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

Tekstitöötluse valdamine täiustatud Java-tehnikatega

Tekstiandmete analüüsimisel on tõstutundlikkuse käsitlemine ja normaliseerimine kriitilise tähtsusega. Javas on Streams API pakub paindlikkust nende väljakutsetega toimetulemiseks minimaalse pingutusega. Näiteks rakendades selliseid meetodeid nagu map(String::toLowerCase), saate tagada, et selliseid sõnu nagu "näidis" ja "näidis" käsitletakse identsetena, mis parandab järjepidevust. See on eriti kasulik otsinguga seotud rakendustes, kus kasutajad ei pruugi juhtude tavasid järgida.

Teine oluline kaalutlus on kirjavahemärgid. Kui kirjavahemärke ei eemaldata, käsitletakse sõnu nagu "string" ja "string" sageli erinevate märkidena. Kasutades replaceAll("[^a-zA-Z0-9 ]", ""), saate enne teksti töötlemist eemaldada soovimatud märgid. See on ülioluline reaalsete andmekogumite (nt kasutajate kommentaaride või arvustuste) puhul, kus kirjavahemärgid on tavalised. Kombineerides neid tehnikaid olemasolevate tööriistadega nagu Collectors.groupingBy, saate luua puhta, normaliseeritud andmestiku.

Lõpuks on suurte andmekogumitega töötamisel võtmetähtsusega jõudluse optimeerimine. Kasutades parallelStream() võimaldab skriptil töödelda andmeid mitme lõime vahel, vähendades oluliselt käitusaega. See võib muuta miljonite sõnadega tegelevate rakenduste mängu. Need täiustused koos üksuse testimisega muudavad lahenduse vastupidavaks ja tootmiskeskkondades skaleeritavaks, tagades selle hea toimimise erinevates tingimustes. 🚀