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

அறிமுகம்:

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

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

கட்டளை	விளக்கம்
BufferedReader	பெரிய அளவிலான தரவுகளைப் படிக்கும் போது செயல்திறனை மேம்படுத்தும், உள்ளீட்டைத் தாங்கும் வாசகர்.
InputStreamReader	பைட் ஸ்ட்ரீமை (இன்புட்ஸ்ட்ரீம்) கேரக்டர் ஸ்ட்ரீமாக (ரீடர்) மாற்றுகிறது.
Collectors.joining	விருப்பமான டிலிமிட்டருடன், சரங்களின் ஸ்ட்ரீமை ஒற்றை சரமாக இணைக்கிறது.
lines()	BufferedReader இலிருந்து படிக்கப்பட்ட வரிகளின் ஸ்ட்ரீமை வழங்குகிறது, மேலும் செயலாக்க அனுமதிக்கிறது.
StandardCharsets.UTF_8	குறியாக்கத்திற்கான UTF-8 எழுத்துக்குறியைக் குறிப்பிடுகிறது, எழுத்துத் தரவைச் சரியாகக் கையாளுவதை உறுதி செய்கிறது.
StringBuilder	சரங்களை திறமையாக உருவாக்குவதற்கும் மாற்றியமைப்பதற்கும் பயன்படுத்தப்படும் எழுத்துகளின் மாறக்கூடிய வரிசை.

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

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

இரண்டாவது ஸ்கிரிப்ட் இதேபோன்ற அணுகுமுறையைப் பின்பற்றுகிறது, ஆனால் a ஐப் பயன்படுத்துகிறது இருந்து வாசிக்கப்பட்ட வரிகளை குவிக்க . இந்த முறை அனைத்து வரிகளும் இணைக்கப்படுவதை உறுதி செய்கிறது சரியான வரி பிரிப்பான்களுடன். இரண்டு ஸ்கிரிப்ட்களும் a ஐப் பயன்படுத்தி விதிவிலக்குகளைக் கையாளுகின்றன try-with-resources அறிக்கை, வளங்கள் தானாக மூடப்படுவதை உறுதி செய்கிறது. பயன்பாடு இரண்டாவது ஸ்கிரிப்ட்டில், பிளாட்ஃபார்மின் இயல்புநிலை எழுத்துக்குறியைப் பொருட்படுத்தாமல், உரை சரியாகப் புரிந்து கொள்ளப்படும் என்று உத்தரவாதம் அளிக்கிறது.

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

பெரிய உள்ளீட்டு ஸ்ட்ரீம்களை திறமையான கையாளுதல்

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

மற்றொரு நுட்பம் பயன்படுத்தப்படுகிறது நூலகம், இது I/O செயல்பாடுகளை கையாளும் பயன்பாட்டு முறைகளை வழங்குகிறது. தி முறை, எடுத்துக்காட்டாக, ஒரு நேரடி மாற்ற அனுமதிக்கிறது ஒரு String. இந்த நூலகம் உங்கள் குறியீட்டை எளிதாக்கலாம் மற்றும் வெளிப்புற சார்புநிலையை அறிமுகப்படுத்தினாலும், வாசிப்புத்திறனை மேம்படுத்தலாம். வலுவான பயன்பாடுகளுக்கு, திறமையான மற்றும் பராமரிக்கக்கூடிய குறியீட்டை உறுதிப்படுத்த இந்த அணுகுமுறைகளைக் கவனியுங்கள்.

1. பயன்படுத்துவதன் நோக்கம் என்ன ?
2. தி உள்ளீட்டைத் தாங்கி I/O செயல்பாடுகளின் எண்ணிக்கையைக் குறைப்பதன் மூலம் செயல்திறனை மேம்படுத்துகிறது.
3. ஏன் பயன்படுத்த வேண்டும் உடன் ?
4. தி ஒரு பைட் ஸ்ட்ரீமை எழுத்து ஓட்டமாக மாற்றுகிறது, இது உரைத் தரவைப் படிக்க அனுமதிக்கிறது.
5. என்ன செய்கிறது ஸ்கிரிப்ட்டில் செய்யவா?
6. தி முறையானது ஸ்ட்ரீமின் கோடுகளை ஒற்றையாக இணைக்கிறது ஒரு குறிப்பிட்ட டிலிமிட்டருடன்.
7. எப்படி செய்கிறது செயல்திறனை அதிகரிக்கவா?
8. தி மாறாத சரங்களைப் பயன்படுத்துவதை ஒப்பிடுகையில், சரங்களைத் திறமையாக இணைக்கப் பயன்படுகிறது, நினைவக மேல்நிலையைக் குறைக்கிறது.
9. என்ன பலன்கள் ?
10. தி அறிக்கை வளங்கள் தானாக மூடப்படுவதை உறுதிசெய்து, வள கசிவுகளைத் தடுக்கிறது.
11. ஏன் குறிப்பிட வேண்டும் ?
12. குறிப்பிடுவது வெவ்வேறு தளங்களில் நிலையான எழுத்து குறியாக்கத்தை உறுதி செய்கிறது.
13. முடியும் மாற்றும் செயல்முறையை எளிதாக்கவா?
14. ஆம், பயன்படுத்தி இருந்து முறை ஒரு மாற்றுவதற்கான குறியீட்டை எளிதாக்கலாம் ஒரு String.

இன்புட்ஸ்ட்ரீம் மாற்றத்திற்கான இறுதி எண்ணங்கள்

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