ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਇਨਪੁਟਸਟ੍ਰੀਮ ਨੂੰ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਕਿਵੇਂ ਬਦਲਿਆ ਜਾਵੇ

ਜਾਣ-ਪਛਾਣ:

Java ਵਿੱਚ InputStreams ਨਾਲ ਕੰਮ ਕਰਨਾ ਇੱਕ ਆਮ ਕੰਮ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਬਾਹਰੀ ਸਰੋਤਾਂ ਜਿਵੇਂ ਕਿ ਫਾਈਲਾਂ, ਨੈੱਟਵਰਕ ਕਨੈਕਸ਼ਨਾਂ, ਜਾਂ ਹੋਰ ਇਨਪੁਟ ਚੈਨਲਾਂ ਤੋਂ ਡਾਟਾ ਨਾਲ ਨਜਿੱਠਣਾ ਹੋਵੇ। ਜਾਣਕਾਰੀ ਨੂੰ ਲੌਗ ਕਰਨ, ਪ੍ਰੋਸੈਸ ਕਰਨ ਜਾਂ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਇਸ ਡੇਟਾ ਨੂੰ ਸਟ੍ਰਿੰਗ ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਣਾ ਜ਼ਰੂਰੀ ਹੋ ਸਕਦਾ ਹੈ।

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਇਨਪੁਟਸਟ੍ਰੀਮ ਨੂੰ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਬਦਲਣ ਦੇ ਸਭ ਤੋਂ ਸਿੱਧੇ ਅਤੇ ਕੁਸ਼ਲ ਤਰੀਕੇ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ। ਇਹਨਾਂ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਕੇ, ਤੁਸੀਂ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ Java ਵਿੱਚ ਤੁਹਾਡਾ ਡੇਟਾ ਹੈਂਡਲਿੰਗ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਅਤੇ ਭਰੋਸੇਮੰਦ ਹੈ।

ਪਰਿਵਰਤਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਮਝਣਾ

ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਦਰਸਾਉਂਦੀਆਂ ਹਨ ਕਿ ਇੱਕ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਕਿਵੇਂ ਬਦਲਣਾ ਹੈ InputStream ਨੂੰ ਏ String ਜਾਵਾ ਵਿੱਚ. ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਏ BufferedReader ਇੱਕ ਦੁਆਲੇ ਲਪੇਟਿਆ InputStreamReader, ਜੋ ਕਿ ਤੋਂ ਬਾਈਟਸ ਪੜ੍ਹਦਾ ਹੈ InputStream ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਅੱਖਰਾਂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ। ਦ lines() ਦੀ ਵਿਧੀ BufferedReader ਲਾਈਨਾਂ ਦੀ ਇੱਕ ਧਾਰਾ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜੋ ਫਿਰ ਇੱਕ ਸਿੰਗਲ ਵਿੱਚ ਇਕੱਠੀਆਂ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ String ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Collectors.joining. ਇਹ ਪਹੁੰਚ ਡੇਟਾ ਦੀਆਂ ਵੱਡੀਆਂ ਧਾਰਾਵਾਂ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਲਈ ਕੁਸ਼ਲ ਹੈ ਕਿਉਂਕਿ ਇਹ ਲਾਈਨਾਂ ਨੂੰ ਆਲਸ ਨਾਲ ਪ੍ਰੋਸੈਸ ਕਰਕੇ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਦਾ ਹੈ।

ਦੂਜੀ ਸਕ੍ਰਿਪਟ ਇੱਕ ਸਮਾਨ ਪਹੁੰਚ ਦੀ ਪਾਲਣਾ ਕਰਦੀ ਹੈ ਪਰ a ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ StringBuilder ਤੋਂ ਪੜ੍ਹੀਆਂ ਗਈਆਂ ਲਾਈਨਾਂ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਲਈ BufferedReader. ਇਹ ਵਿਧੀ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਸਾਰੀਆਂ ਲਾਈਨਾਂ ਨੂੰ ਨਾਲ ਜੋੜਿਆ ਗਿਆ ਹੈ StringBuilder ਸਹੀ ਲਾਈਨ ਵਿਭਾਜਕਾਂ ਦੇ ਨਾਲ. ਦੋਵੇਂ ਸਕ੍ਰਿਪਟਾਂ a ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਪਵਾਦਾਂ ਨੂੰ ਸੰਭਾਲਦੀਆਂ ਹਨ try-with-resources ਸਟੇਟਮੈਂਟ, ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸਰੋਤ ਆਪਣੇ ਆਪ ਬੰਦ ਹੋ ਗਏ ਹਨ। ਦੀ ਵਰਤੋਂ StandardCharsets.UTF_8 ਦੂਜੀ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਇਹ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ ਕਿ ਪਲੇਟਫਾਰਮ ਦੇ ਡਿਫੌਲਟ ਅੱਖਰ-ਸੈੱਟ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ, ਟੈਕਸਟ ਦੀ ਸਹੀ ਵਿਆਖਿਆ ਕੀਤੀ ਗਈ ਹੈ।

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.stream.Collectors;

public class InputStreamConverter {
    public static String convertStreamToString(InputStream is) {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(is))) {
            return reader.lines().collect(Collectors.joining(System.lineSeparator()));
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

public class StreamToString {
    public static String convertStreamToString(InputStream is) {
        StringBuilder sb = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) {
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line).append(System.lineSeparator());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sb.toString();
    }
}

ਵੱਡੀਆਂ ਇਨਪੁਟ ਸਟ੍ਰੀਮਾਂ ਦੀ ਕੁਸ਼ਲ ਹੈਂਡਲਿੰਗ

ਵੱਡੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ InputStreams, ਮੈਮੋਰੀ ਦਾ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਇੱਕ ਪਹੁੰਚ ਨੂੰ ਪੜ੍ਹਨਾ ਹੈ InputStream ਲਾਈਨ ਦਰ ਲਾਈਨ ਦੀ ਬਜਾਏ ਟੁਕੜਿਆਂ ਵਿੱਚ, ਜੋ ਇੱਕ ਬਾਈਟ ਬਫਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਵਿਧੀ ਲਾਭਦਾਇਕ ਹੈ ਜਦੋਂ ਬਾਈਨਰੀ ਡੇਟਾ ਜਾਂ ਵੱਡੀਆਂ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨਾਲ ਨਜਿੱਠਣ ਲਈ ਜਿੱਥੇ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਤੋਂ ਘੱਟ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ. ਇੱਕ ਬਫਰ ਨਿਰਧਾਰਤ ਕਰਕੇ ਅਤੇ ਇਸ ਵਿੱਚ ਡੇਟਾ ਪੜ੍ਹ ਕੇ, ਤੁਸੀਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰ ਸਕਦੇ ਹੋ।

ਇਕ ਹੋਰ ਤਕਨੀਕ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੀ ਹੈ Apache Commons IO ਲਾਇਬ੍ਰੇਰੀ, ਜੋ ਕਿ I/O ਕਾਰਵਾਈਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਉਪਯੋਗਤਾ ਵਿਧੀਆਂ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ। ਦ IOUtils.toString ਵਿਧੀ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਦੇ ਸਿੱਧੇ ਰੂਪਾਂਤਰਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ InputStream ਨੂੰ ਏ String. ਇਹ ਲਾਇਬ੍ਰੇਰੀ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਸਰਲ ਬਣਾ ਸਕਦੀ ਹੈ ਅਤੇ ਪੜ੍ਹਨਯੋਗਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰ ਸਕਦੀ ਹੈ, ਹਾਲਾਂਕਿ ਇਹ ਇੱਕ ਬਾਹਰੀ ਨਿਰਭਰਤਾ ਨੂੰ ਪੇਸ਼ ਕਰਦੀ ਹੈ। ਮਜਬੂਤ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ, ਕੁਸ਼ਲ ਅਤੇ ਸਾਂਭਣਯੋਗ ਕੋਡ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਹਨਾਂ ਪਹੁੰਚਾਂ 'ਤੇ ਵਿਚਾਰ ਕਰੋ।

ਇਨਪੁਟਸਟ੍ਰੀਮ ਪਰਿਵਰਤਨ 'ਤੇ ਅੰਤਿਮ ਵਿਚਾਰ

ਇੱਕ ਨੂੰ ਬਦਲਣਾ InputStream ਨੂੰ ਏ String ਜਾਵਾ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਇੱਕ ਆਮ ਕੰਮ ਹੈ ਜਿਸਨੂੰ ਸਹੀ ਤਕਨੀਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੁਸ਼ਲਤਾ ਨਾਲ ਸੰਭਾਲਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਵਰਗੀਆਂ ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ BufferedReader ਅਤੇ InputStreamReader ਟੈਕਸਟ ਡੇਟਾ ਦੀ ਨਿਰਵਿਘਨ ਪ੍ਰੋਸੈਸਿੰਗ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਵਿਧੀਆਂ ਜਿਵੇਂ ਕਿ Collectors.joining ਅਤੇ Apache Commons IO ਵਰਗੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਕੋਡ ਦੀ ਸਰਲਤਾ ਅਤੇ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਹੋਰ ਵਧਾ ਸਕਦੀਆਂ ਹਨ। ਇਹਨਾਂ ਤਰੀਕਿਆਂ ਦੀ ਪਾਲਣਾ ਕਰਕੇ, ਡਿਵੈਲਪਰ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹਨ ਕਿ ਉਹਨਾਂ ਦੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਇਨਪੁਟ ਸਟ੍ਰੀਮਾਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਅਤੇ ਭਰੋਸੇਮੰਦ ਢੰਗ ਨਾਲ ਸੰਭਾਲਦੀਆਂ ਹਨ।