ஸ்ட்ரீம்ஸ் API ஐப் பயன்படுத்தி Java 8 இல் வார்த்தை அதிர்வெண்களை எண்ணுதல்

ஜாவாவில் வார்த்தை அதிர்வெண் பகுப்பாய்வுகளை நெறிப்படுத்துதல்

ஜாவா 8 சக்திவாய்ந்த ஸ்ட்ரீம்ஸ் API ஐ அறிமுகப்படுத்தியது, டெவலப்பர்கள் சேகரிப்புகள் மற்றும் தரவு செயலாக்கத்தை எவ்வாறு கையாளுகிறார்கள் என்பதில் புரட்சியை ஏற்படுத்தியது. இந்த அம்சத்தின் மிகவும் நடைமுறை பயன்பாடுகளில் ஒன்று வாக்கியங்களின் தொகுப்பில் வார்த்தை அதிர்வெண்களை எண்ணுவது. 🌟 நீங்கள் பதிவுக் கோப்புகளைச் செயலாக்கினாலும் அல்லது உரைத் தரவை பகுப்பாய்வு செய்தாலும், வார்த்தை நிகழ்வுகளை திறமையாக எண்ணும் திறன் மதிப்புமிக்க திறமையாகும்.

உங்களிடம் ஒரு வாக்கியங்கள் இருப்பதாக கற்பனை செய்து பாருங்கள், ஒவ்வொன்றும் வெவ்வேறு அளவு இடைவெளிகள் மற்றும் வடிவமைத்தல் வினோதங்களுடன். இடைவெளியைப் பொருட்படுத்தாமல், "சரம்" என்ற வார்த்தை தொடர்ந்து கணக்கிடப்படுவதை எவ்வாறு உறுதிப்படுத்துவது? இதைத் தீர்ப்பதில் ஸ்ட்ரீம்ஸ் ஏபிஐ முறைகளைப் புரிந்துகொள்வது மற்றும் ஜாவாவின் செயல்பாட்டு நிரலாக்கக் கருவிகளில் தேர்ச்சி பெறுவது ஆகியவை அடங்கும்.

பல டெவலப்பர்கள் நேரடியான அணுகுமுறைகளுடன் தொடங்குகிறார்கள் - சரங்களைப் பிரித்து கைமுறையாக வரிசைகள் மூலம் மீண்டும் செய்கிறார்கள். செயல்படும் போது, ​​இந்த முறைகள் வாய்மொழியாகவும், பராமரிக்க கடினமாகவும் இருக்கும். நல்ல செய்தி என்னவென்றால், Java 8 இன் `சேகரிப்பாளர்கள்' இந்த செயல்முறையை ஒரு சுருக்கமான மற்றும் நேர்த்தியான தீர்வாக நெறிப்படுத்த முடியும். 💡

இந்த வழிகாட்டியில், ஸ்ட்ரீம்ஸ் API ஐப் பயன்படுத்தி வார்த்தை அதிர்வெண் எண்ணிக்கையை மேம்படுத்துவோம். கூடுதல் இடைவெளிகள் போன்ற பொதுவான சிக்கல்கள் முதல் நடைமுறை எடுத்துக்காட்டுகள் வரை, உங்கள் ஜாவா குறியீட்டை எவ்வாறு சுத்தமாகவும் திறமையாகவும் மாற்றுவது என்பதை நீங்கள் கற்றுக் கொள்வீர்கள். உள்ளே நுழைவோம்! 🚀

ஜாவா ஸ்ட்ரீம்களுடன் வார்த்தை அதிர்வெண் பகுப்பாய்வை மேம்படுத்துதல்

மேலே உள்ள ஸ்கிரிப்டுகள் சக்திவாய்ந்தவற்றைப் பயன்படுத்தி வாக்கியங்களின் வரிசையில் வார்த்தை அதிர்வெண்களை திறமையாக கணக்கிட வடிவமைக்கப்பட்டுள்ளன ஜாவா 8 ஸ்ட்ரீம்ஸ் ஏபிஐ. பதிவுகள் அல்லது ஆவணப் பகுப்பாய்வு போன்ற உரைத் தரவைச் செயலாக்குவதற்கு இது மிகவும் பயனுள்ளதாக இருக்கும், அங்கு இடைவெளி மற்றும் கேஸ் சென்சிட்டிவிட்டியின் சீரான கையாளுதல் அவசியம். சரங்களின் உள்ளீட்டு வரிசையை வார்த்தைகளின் ஒருங்கிணைந்த ஸ்ட்ரீமாக மாற்றுவதன் மூலம் முதன்மை ஓட்டம் தொடங்குகிறது. இது `பிளாட்மேப்` முறையைப் பயன்படுத்தி அடையப்படுகிறது, இது ஒவ்வொரு வாக்கியத்தையும் தனித்தனி வார்த்தைகளாகப் பிரிக்கிறது, அதே நேரத்தில் ஒழுங்கற்ற இடைவெளியை நீக்குகிறது. எடுத்துக்காட்டாக, உள்ளீட்டில் கூடுதல் இடைவெளிகள் இருந்தால், இவை கூடுதல் குறியீடு இல்லாமல் அழகாகக் கையாளப்பட்டு, பணியை எளிதாக்கும். 😊

ஸ்கிரிப்ட்களின் ஒரு முக்கிய அம்சம், வெற்று சரங்களைத் தவிர்க்க `வடிகட்டி'யைப் பயன்படுத்துவதாகும், இது பல இடைவெளிகளுடன் வாக்கியங்களைப் பிரிப்பதன் விளைவாக இருக்கலாம். பின்னர், `வரைபடம்(ஸ்ட்ரிங்::ட்ரிம்)` எஞ்சியுள்ள முன்னணி அல்லது பின்தங்கிய இடைவெளிகளை அகற்றுவதன் மூலம் வார்த்தைகளின் வடிவமைப்பை தரப்படுத்த பயன்படுத்தப்படுகிறது. இது "மாதிரி" மற்றும் "மாதிரி" போன்ற சொற்கள் ஒரே மாதிரியாகக் கருதப்படுவதை உறுதி செய்கிறது. இந்த முறைகளின் கலவையானது உரை செயலாக்கத்திற்கான நெறிப்படுத்தப்பட்ட மற்றும் நம்பகமான பொறிமுறையை வழங்குகிறது, குறிப்பாக கணிக்க முடியாத உள்ளீட்டுத் தரவைக் கையாளும் போது.

வார்த்தைகளை தொகுத்தல் மற்றும் எண்ணுதல் `Collectors.groupingBy` மற்றும் `Collectors.counting` மூலம் கையாளப்படுகிறது. இந்த இரண்டு முறைகளும் இணைந்து ஒரு வரைபடத்தை உருவாக்குகின்றன, அங்கு ஒவ்வொரு தனிப்பட்ட வார்த்தையும் ஒரு முக்கிய மற்றும் அதன் அதிர்வெண் மதிப்பு. எடுத்துக்காட்டாக, "இது ஒரு மாதிரி சரம்" உள்ளீட்டில், "மாதிரி" என்ற வார்த்தை உள்ளீட்டு வாக்கியங்களில் பல முறை தோன்றும். இந்த அணுகுமுறை அதன் மொத்த நிகழ்வுகள் கைப்பற்றப்படுவதை உறுதிசெய்கிறது, இது துல்லியமான அதிர்வெண் எண்ணிக்கையை வழங்குகிறது. வகைப்படுத்தியாக `Function.identity()` ஐப் பயன்படுத்துவதன் மூலம், அந்த வார்த்தையே விளைந்த வரைபடத்தில் திறவுகோலாகப் பயன்படுத்தப்படுகிறது.

இறுதியாக, ஸ்கிரிப்ட்களில் மட்டுப்படுத்தல் மற்றும் மறுபயன்பாடு ஆகியவை அடங்கும், `கால்குலேட் வேர்ட்ஃப்ரீக்வென்சிஸ்` போன்ற பயன்பாட்டு முறைகளை அறிமுகப்படுத்தி, தர்க்கத்தை எளிதாகப் பராமரிக்கவும் பெரிய திட்டங்களில் ஒருங்கிணைக்கவும் செய்கிறது. யூனிட் சோதனைகளைச் சேர்ப்பது, தீர்வு பல்வேறு உள்ளீடுகளில் எதிர்பார்த்தபடி செயல்படுவதை மேலும் உறுதிப்படுத்துகிறது. எடுத்துக்காட்டாக, ட்ரைலிங் ஸ்பேஸ்கள் அல்லது மாறுபட்ட சொல் கேப்பிடலைசேஷன் போன்ற பொதுவான சிக்கல்கள் முடிவுகளைப் பாதிக்காது என்பதை சோதனைச் சூழல்கள் சரிபார்க்கின்றன. பயனர் உருவாக்கிய உள்ளடக்கத்தை பகுப்பாய்வு செய்தல் அல்லது தேடல் பதிவுகளைப் பாகுபடுத்துதல் போன்ற நிஜ உலகக் காட்சிகளுக்கு இந்த வலிமையான நிலை ஸ்கிரிப்ட்களை ஏற்றதாக ஆக்குகிறது. 🚀

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

மேம்பட்ட ஜாவா நுட்பங்களுடன் உரை செயலாக்கத்தில் தேர்ச்சி பெறுதல்

உரைத் தரவை பகுப்பாய்வு செய்யும் போது, ​​வழக்கு உணர்திறன் மற்றும் இயல்பாக்கம் ஆகியவற்றைக் கையாள்வது மிகவும் முக்கியமானது. ஜாவாவில், தி ஸ்ட்ரீம்கள் API இந்த சவால்களை குறைந்த முயற்சியுடன் கையாளும் நெகிழ்வுத்தன்மையை வழங்குகிறது. உதாரணமாக, போன்ற முறைகளைப் பயன்படுத்துவதன் மூலம் map(String::toLowerCase), "மாதிரி" மற்றும் "மாதிரி" போன்ற வார்த்தைகள் ஒரே மாதிரியாகக் கருதப்படுவதை உறுதிசெய்து, நிலைத்தன்மையை மேம்படுத்தலாம். பயனர்கள் வழக்கு மரபுகளைப் பின்பற்றாத தேடல் தொடர்பான பயன்பாடுகளில் இது மிகவும் பயனுள்ளதாக இருக்கும்.

மற்றொரு முக்கியமான கருத்தில் நிறுத்தற்குறி உள்ளது. நிறுத்தற்குறிகள் அகற்றப்படாவிட்டால், "சரம்" மற்றும் "சரம்" போன்ற சொற்கள் பெரும்பாலும் வெவ்வேறு டோக்கன்களாகக் கருதப்படுகின்றன. பயன்படுத்தி replaceAll("[^a-zA-Z0-9 ]", ""), உரையைச் செயலாக்கும் முன் தேவையற்ற எழுத்துகளை அகற்றலாம். நிறுத்தற்குறிகள் பொதுவாக இருக்கும் பயனர் கருத்துகள் அல்லது மதிப்புரைகள் போன்ற நிஜ உலக தரவுத்தொகுப்புகளுக்கு இது மிகவும் முக்கியமானது. போன்ற தற்போதுள்ள கருவிகளுடன் இந்த நுட்பங்களை இணைப்பதன் மூலம் Collectors.groupingBy, நீங்கள் சுத்தமான, இயல்பாக்கப்பட்ட தரவுத்தொகுப்பை உருவாக்கலாம்.

கடைசியாக, பெரிய தரவுத்தொகுப்புகளுடன் பணிபுரியும் போது செயல்திறனை மேம்படுத்துவது முக்கியமானது. பயன்படுத்தி parallelStream() ஸ்கிரிப்டை பல இழைகளில் தரவை செயலாக்க அனுமதிக்கிறது, இது இயக்க நேரத்தை கணிசமாகக் குறைக்கிறது. மில்லியன் கணக்கான சொற்களைக் கையாளும் பயன்பாடுகளுக்கு இது கேம்-சேஞ்சராக இருக்கும். இந்த மேம்பாடுகள், யூனிட் சோதனையுடன் இணைந்தால், தீர்வை வலுவானதாகவும், உற்பத்தி சூழல்களுக்கு அளவிடக்கூடியதாகவும் ஆக்குகிறது, இது பல்வேறு நிலைமைகளின் கீழ் சிறப்பாக செயல்படுவதை உறுதி செய்கிறது. 🚀