ਸਟ੍ਰੀਮ API ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Java 8 ਵਿੱਚ ਵਰਡ ਫ੍ਰੀਕੁਐਂਸੀ ਦੀ ਗਿਣਤੀ ਕਰਨਾ

ਜਾਵਾ ਵਿੱਚ ਵਰਡ ਫ੍ਰੀਕੁਐਂਸੀ ਵਿਸ਼ਲੇਸ਼ਣ ਨੂੰ ਸਟ੍ਰੀਮਲਾਈਨ ਕਰਨਾ

Java 8 ਨੇ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸਟ੍ਰੀਮਜ਼ API ਨੂੰ ਪੇਸ਼ ਕੀਤਾ, ਜਿਸ ਨਾਲ ਵਿਕਾਸਕਾਰ ਸੰਗ੍ਰਹਿ ਅਤੇ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਦੇ ਹਨ। ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਦੇ ਸਭ ਤੋਂ ਵਿਹਾਰਕ ਕਾਰਜਾਂ ਵਿੱਚੋਂ ਇੱਕ ਵਾਕਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਵਿੱਚ ਸ਼ਬਦਾਂ ਦੀ ਬਾਰੰਬਾਰਤਾ ਦੀ ਗਿਣਤੀ ਕਰਨਾ ਹੈ। 🌟 ਭਾਵੇਂ ਤੁਸੀਂ ਲੌਗ ਫਾਈਲਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰ ਰਹੇ ਹੋ ਜਾਂ ਟੈਕਸਟ ਡੇਟਾ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰ ਰਹੇ ਹੋ, ਸ਼ਬਦ ਦੀਆਂ ਘਟਨਾਵਾਂ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਗਿਣਨ ਦੀ ਯੋਗਤਾ ਇੱਕ ਕੀਮਤੀ ਹੁਨਰ ਹੈ।

ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਵਾਕਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੈ, ਹਰੇਕ ਵਿੱਚ ਵ੍ਹਾਈਟ ਸਪੇਸ ਅਤੇ ਫਾਰਮੈਟਿੰਗ ਕੁਆਰਕਸ ਦੀ ਵੱਖੋ ਵੱਖਰੀ ਮਾਤਰਾ ਹੈ। ਤੁਸੀਂ ਇਹ ਕਿਵੇਂ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹੋ ਕਿ ਸਪੇਸਿੰਗ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ, ਸ਼ਬਦ "ਸਟਰਿੰਗ" ਨੂੰ ਲਗਾਤਾਰ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ? ਇਸ ਨੂੰ ਹੱਲ ਕਰਨ ਵਿੱਚ ਸਟ੍ਰੀਮਜ਼ API ਵਿਧੀਆਂ ਨੂੰ ਸਮਝਣਾ ਅਤੇ ਜਾਵਾ ਦੇ ਕਾਰਜਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਟੂਲਸ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨਾ ਸ਼ਾਮਲ ਹੈ।

ਬਹੁਤ ਸਾਰੇ ਡਿਵੈਲਪਰ ਸਿੱਧੀਆਂ ਪਹੁੰਚਾਂ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ-ਸਤਰਾਂ ਨੂੰ ਵੰਡਣਾ ਅਤੇ ਐਰੇ ਰਾਹੀਂ ਹੱਥੀਂ ਦੁਹਰਾਉਣਾ। ਕਾਰਜਸ਼ੀਲ ਹੋਣ ਦੇ ਦੌਰਾਨ, ਇਹ ਵਿਧੀਆਂ ਜ਼ੁਬਾਨੀ ਬਣ ਸਕਦੀਆਂ ਹਨ ਅਤੇ ਬਣਾਈ ਰੱਖਣਾ ਔਖਾ ਹੋ ਸਕਦਾ ਹੈ। ਚੰਗੀ ਖ਼ਬਰ ਇਹ ਹੈ ਕਿ Java 8 ਦੇ 'ਕਲੈਕਟਰ' ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਇੱਕ ਸੰਖੇਪ ਅਤੇ ਸ਼ਾਨਦਾਰ ਹੱਲ ਵਿੱਚ ਸੁਚਾਰੂ ਬਣਾ ਸਕਦੇ ਹਨ। 💡

ਇਸ ਗਾਈਡ ਵਿੱਚ, ਅਸੀਂ ਸਟ੍ਰੀਮਜ਼ API ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਵਰਡ ਫ੍ਰੀਕੁਐਂਸੀ ਕਾਉਂਟਿੰਗ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਵਿੱਚ ਚੱਲਾਂਗੇ। ਆਮ ਸਮੱਸਿਆਵਾਂ ਜਿਵੇਂ ਕਿ ਵਾਧੂ ਥਾਂਵਾਂ ਤੋਂ ਲੈ ਕੇ ਵਿਹਾਰਕ ਉਦਾਹਰਨਾਂ ਤੱਕ, ਤੁਸੀਂ ਆਪਣੇ ਜਾਵਾ ਕੋਡ ਨੂੰ ਸਾਫ਼ ਅਤੇ ਵਧੇਰੇ ਕੁਸ਼ਲ ਬਣਾਉਣ ਬਾਰੇ ਸਿੱਖੋਗੇ। ਆਓ ਅੰਦਰ ਡੁਬਕੀ ਕਰੀਏ! 🚀

ਜਾਵਾ ਸਟ੍ਰੀਮਜ਼ ਦੇ ਨਾਲ ਵਰਡ ਫ੍ਰੀਕੁਐਂਸੀ ਵਿਸ਼ਲੇਸ਼ਣ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰਨਾ

ਉਪਰੋਕਤ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸ਼ਬਦਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਵਾਕਾਂ ਦੀ ਇੱਕ ਲੜੀ ਵਿੱਚ ਸ਼ਬਦਾਂ ਦੀ ਬਾਰੰਬਾਰਤਾ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਗਿਣਨ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ Java 8 ਸਟ੍ਰੀਮ API. ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਟੈਕਸਟ ਡੇਟਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਲਈ ਲਾਭਦਾਇਕ ਹੈ, ਜਿਵੇਂ ਕਿ ਲੌਗਸ ਜਾਂ ਦਸਤਾਵੇਜ਼ ਵਿਸ਼ਲੇਸ਼ਣ, ਜਿੱਥੇ ਵ੍ਹਾਈਟਸਪੇਸ ਅਤੇ ਕੇਸ ਸੰਵੇਦਨਸ਼ੀਲਤਾ ਦਾ ਇਕਸਾਰ ਪ੍ਰਬੰਧਨ ਜ਼ਰੂਰੀ ਹੈ। ਪ੍ਰਾਇਮਰੀ ਵਹਾਅ ਸਤਰ ਦੇ ਇਨਪੁਟ ਐਰੇ ਨੂੰ ਸ਼ਬਦਾਂ ਦੀ ਇਕਸਾਰ ਧਾਰਾ ਵਿੱਚ ਬਦਲ ਕੇ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ। ਇਹ 'ਫਲੈਟਮੈਪ' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜੋ ਅਨਿਯਮਿਤ ਸਪੇਸਿੰਗ ਨੂੰ ਖਤਮ ਕਰਦੇ ਹੋਏ ਹਰੇਕ ਵਾਕ ਨੂੰ ਵਿਅਕਤੀਗਤ ਸ਼ਬਦਾਂ ਵਿੱਚ ਵੰਡਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਇਨਪੁਟ ਵਿੱਚ ਵਾਧੂ ਥਾਂਵਾਂ ਹਨ, ਤਾਂ ਇਹਨਾਂ ਨੂੰ ਬਿਨਾਂ ਵਾਧੂ ਕੋਡ ਦੇ ਸ਼ਾਨਦਾਰ ਢੰਗ ਨਾਲ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ, ਕੰਮ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ। 😊

ਸਕ੍ਰਿਪਟਾਂ ਦੀ ਇੱਕ ਮੁੱਖ ਵਿਸ਼ੇਸ਼ਤਾ ਖਾਲੀ ਸਤਰਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਣ ਲਈ ਉਹਨਾਂ ਦੀ 'ਫਿਲਟਰ' ਦੀ ਵਰਤੋਂ ਹੈ, ਜਿਸਦਾ ਨਤੀਜਾ ਇੱਕ ਤੋਂ ਵੱਧ ਸਪੇਸ ਵਾਲੇ ਵਾਕਾਂ ਨੂੰ ਵੰਡਣ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਹੋ ਸਕਦਾ ਹੈ। ਬਾਅਦ ਵਿੱਚ, `ਨਕਸ਼ੇ(ਸਟ੍ਰਿੰਗ:: ਟ੍ਰਿਮ)` ਨੂੰ ਕਿਸੇ ਵੀ ਬਚੇ ਹੋਏ ਮੋਹਰੀ ਜਾਂ ਪਿਛਲਾ ਸਥਾਨਾਂ ਨੂੰ ਹਟਾ ਕੇ ਸ਼ਬਦਾਂ ਦੇ ਫਾਰਮੈਟ ਨੂੰ ਮਿਆਰੀ ਬਣਾਉਣ ਲਈ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ "ਨਮੂਨਾ" ਅਤੇ "ਨਮੂਨਾ" ਵਰਗੇ ਸ਼ਬਦਾਂ ਨੂੰ ਇੱਕੋ ਜਿਹਾ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਇਹਨਾਂ ਤਰੀਕਿਆਂ ਦਾ ਸੁਮੇਲ ਟੈਕਸਟ ਪ੍ਰੋਸੈਸਿੰਗ ਲਈ ਇੱਕ ਸੁਚਾਰੂ ਅਤੇ ਭਰੋਸੇਮੰਦ ਵਿਧੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਅਣਪਛਾਤੇ ਇਨਪੁਟ ਡੇਟਾ ਨਾਲ ਨਜਿੱਠਣਾ ਹੁੰਦਾ ਹੈ।

ਸ਼ਬਦਾਂ ਦਾ ਗਰੁੱਪ ਬਣਾਉਣਾ ਅਤੇ ਗਿਣਨ ਦਾ ਕੰਮ `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() ਸਕ੍ਰਿਪਟ ਨੂੰ ਕਈ ਥਰਿੱਡਾਂ ਵਿੱਚ ਡੇਟਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਰਨਟਾਈਮ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਘਟਾਉਂਦਾ ਹੈ। ਇਹ ਲੱਖਾਂ ਸ਼ਬਦਾਂ ਨਾਲ ਨਜਿੱਠਣ ਵਾਲੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਗੇਮ-ਚੇਂਜਰ ਹੋ ਸਕਦਾ ਹੈ। ਇਹ ਸੁਧਾਰ, ਜਦੋਂ ਯੂਨਿਟ ਟੈਸਟਿੰਗ ਦੇ ਨਾਲ ਮਿਲਾਏ ਜਾਂਦੇ ਹਨ, ਹੱਲ ਨੂੰ ਮਜ਼ਬੂਤ ​​​​ਅਤੇ ਉਤਪਾਦਨ ਵਾਤਾਵਰਨ ਲਈ ਸਕੇਲੇਬਲ ਬਣਾਉਂਦੇ ਹਨ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ ਕਿ ਇਹ ਵਿਭਿੰਨ ਸਥਿਤੀਆਂ ਵਿੱਚ ਵਧੀਆ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦਾ ਹੈ। 🚀