Vārdu frekvenču skaitīšana programmā Java 8, izmantojot Streams API

Vārdu biežuma analīzes racionalizēšana Java

Java 8 ieviesa jaudīgo Streams API, radot revolūciju to, kā izstrādātāji apstrādā kolekcijas un datu apstrādi. Viens no praktiskākajiem šīs funkcijas pielietojumiem ir vārdu biežuma skaitīšana teikumu komplektā. 🌟 Neatkarīgi no tā, vai apstrādājat žurnālfailus vai analizējat teksta datus, spēja efektīvi skaitīt vārdu gadījumus ir vērtīga prasme.

Iedomājieties, ka jums ir teikumu kopa, un katrā no tiem ir atšķirīgs atstarpju daudzums un formatēšanas dīvainības. Kā nodrošināt, lai vārds "virkne" tiktu uzskaitīts konsekventi neatkarīgi no atstarpēm? Lai to atrisinātu, ir jāizprot Streams API metodes un jāapgūst Java funkcionālie programmēšanas rīki.

Daudzi izstrādātāji sāk ar vienkāršām pieejām — virkņu sadalīšanu un manuālu masīvu atkārtošanu. Lai gan šīs metodes ir funkcionālas, tās var kļūt detalizētas un grūti uzturējamas. Labā ziņa ir tā, ka Java 8 “Kolekcionāri” var vienkāršot šo procesu kodolīgā un elegantā risinājumā. 💡

Šajā rokasgrāmatā mēs apskatīsim vārdu biežuma skaitīšanas optimizēšanu, izmantojot Streams API. No izplatītām kļūmēm, piemēram, papildu atstarpēm, līdz praktiskiem piemēriem, jūs uzzināsit, kā padarīt savu Java kodu tīrāku un efektīvāku. Iegremdējamies! 🚀

Vārdu frekvences analīzes optimizēšana, izmantojot Java straumes

Iepriekš minētie skripti ir paredzēti, lai efektīvi saskaitītu vārdu biežumu teikumu masīvā, izmantojot jaudīgo Java 8 Streams API. Tas ir īpaši noderīgi teksta datu, piemēram, žurnālu vai dokumentu analīzes, apstrādei, kur ir būtiska konsekventa atstarpes un reģistrjutīgums. Primārā plūsma sākas, pārveidojot ievades virkņu masīvu vienotā vārdu plūsmā. Tas tiek panākts, izmantojot "flatMap" metodi, kas sadala katru teikumu atsevišķos vārdos, vienlaikus novēršot neregulāras atstarpes. Piemēram, ja ievadē ir papildu atstarpes, tās tiek apstrādātas graciozi bez papildu koda, vienkāršojot uzdevumu. 😊

Viena no galvenajām skriptu iezīmēm ir 'filtra' izmantošana, lai izslēgtu tukšas virknes, kas var rasties, sadalot teikumus ar vairākām atstarpēm. Pēc tam tiek lietota karte(String::trim), lai standartizētu vārdu formātu, noņemot visas atlikušās sākuma vai beigu atstarpes. Tas nodrošina, ka tādi vārdi kā "paraugs" un "paraugs" tiek uzskatīti par identiskiem. Šo metožu kombinācija nodrošina racionalizētu un uzticamu teksta apstrādes mehānismu, īpaši, ja tiek apstrādāti neparedzami ievades dati.

Vārdu grupēšana un skaitīšana tiek veikta ar `Collectors.groupingBy` un `Collectors.counting`. Šīs divas metodes darbojas kopā, lai izveidotu karti, kurā katrs unikālais vārds ir atslēga, un tā biežums ir vērtība. Piemēram, ievadē “Šī ir parauga virkne” vārds “sample” tiek parādīts vairākas reizes ievades teikumos. Šī pieeja nodrošina, ka tiek fiksēti tā kopējie gadījumi, nodrošinot precīzu biežuma uzskaiti. Izmantojot funkciju Function.identity() kā klasifikatoru, pats vārds tiek izmantots kā atslēga iegūtajā kartē.

Visbeidzot, skripti ietver modularitāti un atkārtotu izmantošanu, ieviešot tādas utilītas metodes kā "calculateWordFrequencies", padarot loģiku viegli uzturējamu un integrējamu lielākos projektos. Vienību testu iekļaušana vēl vairāk apstiprina, ka risinājums darbojas, kā paredzēts, izmantojot dažādas ievades. Piemēram, testa gadījumi pārbauda, ​​vai bieži sastopamas problēmas, piemēram, beigu atstarpes vai mainīga vārda lielo burtu lietojums, neietekmē rezultātus. Šis robustuma līmenis padara skriptus piemērotus reāliem scenārijiem, piemēram, lietotāju veidota satura analīzei vai meklēšanas žurnālu parsēšanai. 🚀

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

Teksta apstrādes apgūšana, izmantojot uzlabotas Java metodes

Analizējot teksta datus, svarīga ir reģistrjutība un normalizācija. Java valodā, Straumēšanas API nodrošina elastību, lai risinātu šīs problēmas ar minimālu piepūli. Piemēram, izmantojot tādas metodes kā map(String::toLowerCase), varat nodrošināt, ka tādi vārdi kā “Paraugs” un “paraugs” tiek uzskatīti par identiskiem, tādējādi uzlabojot konsekvenci. Tas ir īpaši noderīgi ar meklēšanu saistītās lietojumprogrammās, kurās lietotāji var neievērot gadījumus.

Vēl viens svarīgs apsvērums ir pieturzīmes. Ja pieturzīmes netiek noņemtas, tādi vārdi kā “virkne” un “virkne” bieži tiek uzskatīti par atšķirīgiem marķieriem. Izmantojot replaceAll("[^a-zA-Z0-9 ]", ""), pirms teksta apstrādes varat noņemt nevēlamās rakstzīmes. Tas ir ļoti svarīgi reālās pasaules datu kopām, piemēram, lietotāju komentāriem vai atsauksmēm, kur pieturzīmes ir izplatītas. Apvienojot šīs metodes ar esošajiem rīkiem, piemēram Collectors.groupingBy, varat izveidot tīru, normalizētu datu kopu.

Visbeidzot, strādājot ar lielām datu kopām, galvenais ir veiktspējas optimizācija. Izmantojot parallelStream() ļauj skriptam apstrādāt datus vairākos pavedienos, ievērojami samazinot izpildes laiku. Tas var mainīt spēli lietojumprogrammām, kas nodarbojas ar miljoniem vārdu. Šie uzlabojumi apvienojumā ar vienību testēšanu padara risinājumu stabilu un mērogojamu ražošanas vidēm, nodrošinot tā labu darbību dažādos apstākļos. 🚀