ஜாவாவில் உள்ளீட்டு ஸ்ட்ரீமை சரமாக மாற்றுவது எப்படி

அறிமுகம்:

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

இந்தக் கட்டுரையில், InputStream ஐ String ஆக மாற்றுவதற்கான மிகவும் நேரடியான மற்றும் திறமையான வழியை ஆராய்வோம். இந்தப் படிகளைப் பின்பற்றுவதன் மூலம், ஜாவாவில் உங்கள் தரவு கையாளுதல் பயனுள்ளதாகவும் நம்பகமானதாகவும் இருப்பதை உறுதிசெய்யலாம்.

மாற்று செயல்முறையைப் புரிந்துகொள்வது

வழங்கப்பட்டுள்ள ஸ்கிரிப்டுகள் ஒரு ஐ எவ்வாறு திறமையாக மாற்றுவது என்பதை விளக்குகின்றன InputStream ஒரு String ஜாவாவில். முதல் ஸ்கிரிப்ட் a ஐப் பயன்படுத்துகிறது 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 போன்ற நூலகங்கள் குறியீட்டின் எளிமை மற்றும் செயல்திறனை மேலும் மேம்படுத்த முடியும். இந்த முறைகளைப் பின்பற்றுவதன் மூலம், டெவலப்பர்கள் தங்கள் பயன்பாடுகள் உள்ளீட்டு ஸ்ட்ரீம்களை திறம்பட மற்றும் நம்பகத்தன்மையுடன் கையாளுவதை உறுதிசெய்ய முடியும்.