ಜಾವಾದಲ್ಲಿ ಇನ್‌ಪುಟ್‌ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪರಿವರ್ತಿಸುವುದು ಹೇಗೆ

ಪರಿಚಯ:

ಜಾವಾದಲ್ಲಿ ಇನ್‌ಪುಟ್‌ಸ್ಟ್ರೀಮ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಸಾಮಾನ್ಯ ಕಾರ್ಯವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ಫೈಲ್‌ಗಳು, ನೆಟ್‌ವರ್ಕ್ ಸಂಪರ್ಕಗಳು ಅಥವಾ ಇತರ ಇನ್‌ಪುಟ್ ಚಾನಲ್‌ಗಳಂತಹ ಬಾಹ್ಯ ಮೂಲಗಳಿಂದ ಡೇಟಾದೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ. ಮಾಹಿತಿಯನ್ನು ಲಾಗಿಂಗ್ ಮಾಡಲು, ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಅಥವಾ ಪ್ರದರ್ಶಿಸಲು ಈ ಡೇಟಾವನ್ನು ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟ್‌ಗೆ ಪರಿವರ್ತಿಸುವುದು ಅತ್ಯಗತ್ಯವಾಗಿರುತ್ತದೆ.

ಈ ಲೇಖನದಲ್ಲಿ, ಇನ್‌ಪುಟ್‌ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಪರಿವರ್ತಿಸುವ ಅತ್ಯಂತ ಸರಳ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ಜಾವಾದಲ್ಲಿ ನಿಮ್ಮ ಡೇಟಾ ನಿರ್ವಹಣೆ ಪರಿಣಾಮಕಾರಿ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿದೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು.

ಪರಿವರ್ತನೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಒದಗಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಎ ಅನ್ನು ಹೇಗೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪರಿವರ್ತಿಸುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ InputStream ಗೆ a 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 ಗೆ a String. ಈ ಲೈಬ್ರರಿಯು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ, ಆದರೂ ಇದು ಬಾಹ್ಯ ಅವಲಂಬನೆಯನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ದೃಢವಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ, ಸಮರ್ಥ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಈ ವಿಧಾನಗಳನ್ನು ಪರಿಗಣಿಸಿ.

ಇನ್‌ಪುಟ್‌ಸ್ಟ್ರೀಮ್ ಪರಿವರ್ತನೆಯ ಅಂತಿಮ ಆಲೋಚನೆಗಳು

ಪರಿವರ್ತಿಸುವುದು ಒಂದು InputStream ಗೆ a String ಜಾವಾ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಸಾಮಾನ್ಯ ಕಾರ್ಯವಾಗಿದ್ದು, ಸರಿಯಾದ ತಂತ್ರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸಬಹುದಾಗಿದೆ. ಮುಂತಾದ ತರಗತಿಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುವುದು BufferedReader ಮತ್ತು InputStreamReader ಪಠ್ಯ ಡೇಟಾದ ಮೃದುವಾದ ಪ್ರಕ್ರಿಯೆಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ವಿಧಾನಗಳಂತಹ ವಿಧಾನಗಳು Collectors.joining ಮತ್ತು Apache Commons IO ನಂತಹ ಗ್ರಂಥಾಲಯಗಳು ಕೋಡ್ ಸರಳತೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಇನ್ನಷ್ಟು ಹೆಚ್ಚಿಸಬಹುದು. ಈ ವಿಧಾನಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ತಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಇನ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿ ನಿರ್ವಹಿಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು.