இன்புட்ஸ்ட்ரீம் தரவைச் செயலாக்குகிறது
ஜாவாவில், இன்புட்ஸ்ட்ரீமை சரமாக மாற்றுவது டெவலப்பர்கள் எதிர்கொள்ளும் பொதுவான பணியாகும். உள்நுழைய, காண்பிக்க அல்லது மேலும் செயலாக்க வேண்டிய உரைத் தரவைக் கையாளும் போது இந்த மாற்றம் மிகவும் பயனுள்ளதாக இருக்கும். பணி எளிமையானதாகத் தோன்றலாம், ஆனால் இதை அடைய பல வழிகள் உள்ளன, ஒவ்வொன்றும் அதன் சொந்த நன்மைகளைக் கொண்டுள்ளன.
இந்த வழிகாட்டியில், InputStream ஐ String ஆக மாற்றுவதற்கான மிகச் சிறந்த வழிகளை ஆராய்வோம். இந்த முறைகளைப் புரிந்துகொள்வது உங்கள் குறிப்பிட்ட பயன்பாட்டுக்கான சிறந்த அணுகுமுறையைத் தேர்வுசெய்ய உதவும், உங்கள் தரவு செயலாக்கம் பயனுள்ளதாகவும் உகந்ததாகவும் இருப்பதை உறுதிசெய்யும்.
கட்டளை | விளக்கம் |
---|---|
BufferedReader | எழுத்துகளை இடையகப்படுத்துவதன் மூலம் உள்ளீட்டு ஸ்ட்ரீமில் இருந்து உரையை திறம்பட படிக்க ஒரு வகுப்பு பயன்படுத்தப்படுகிறது. |
InputStreamReader | பைட் ஸ்ட்ரீம்களில் இருந்து கேரக்டர் ஸ்ட்ரீம்களுக்கு ஒரு பாலம். இது பைட்டுகளைப் படித்து, குறிப்பிட்ட எழுத்துக்குறியைப் பயன்படுத்தி அவற்றை எழுத்துகளாக டிகோட் செய்கிறது. |
Collectors.joining() | ஜாவா ஸ்ட்ரீம் ஏபிஐயில் உள்ள ஒரு முறை, இது ஸ்ட்ரீமின் கூறுகளை ஒரு குறிப்பிட்ட டிலிமிட்டருடன் ஒற்றை சரமாக இணைக்கிறது. |
Scanner.useDelimiter() | இன்புட்ஸ்ட்ரீமில் இருந்து டோக்கன்களை பாகுபடுத்தும் போது ஸ்கேனர் பயன்படுத்துவதற்கு டிலிமிட்டர் பேட்டர்னை அமைக்கிறது. |
IOUtils.toString() | அப்பாச்சி காமன்ஸ் ஐஓ லைப்ரரியில் இருந்து ஒரு முறை, இது ஒரு குறிப்பிட்ட எழுத்துக்குறி குறியாக்கத்தைப் பயன்படுத்தி இன்புட்ஸ்ட்ரீமை ஒரு சரமாக மாற்றுகிறது. |
Stream.collect() | கலெக்டரைப் பயன்படுத்தி ஸ்ட்ரீமின் உறுப்புகளில் மாறக்கூடிய குறைப்பு செயல்பாட்டைச் செய்யும் முனைய செயல்பாடு. |
System.lineSeparator() | கணினி சார்ந்த வரி பிரிப்பான் சரத்தை வழங்குகிறது, பொதுவாக குறுக்கு-தளம் இணக்கத்தன்மையை பராமரிக்க உரை செயலாக்கத்தில் பயன்படுத்தப்படுகிறது. |
இன்புட்ஸ்ட்ரீமை சரம் மாற்றத்தைப் புரிந்துகொள்வது
வழங்கப்பட்ட ஸ்கிரிப்டுகள் ஒரு மாற்றுவதற்கான பல்வேறு முறைகளை நிரூபிக்கின்றன InputStream ஒரு String ஜாவாவில். முதல் ஸ்கிரிப்ட் பயன்படுத்துகிறது BufferedReader மற்றும் InputStreamReader InputStream வரியை வரியாகப் படித்து, இந்த வரிகளை ஒரு சரமாக இணைக்கவும். தி Collectors.joining(System.lineSeparator()) கணினி சார்ந்த வரி பிரிப்பானுடன் வரிகளை இணைக்க முறை பயன்படுத்தப்படுகிறது. இந்த முறை பெரிய ஸ்ட்ரீம்களைக் கையாள்வதில் திறமையானது மற்றும் முழு உள்ளடக்கமும் சரியாகப் பிடிக்கப்படுவதை உறுதி செய்கிறது.
இரண்டாவது ஸ்கிரிப்ட் பயன்படுத்துகிறது Scanner உடன் useDelimiter("\\A") முறை, இது டிலிமிட்டரை ஸ்ட்ரீமின் தொடக்கத்திற்கு அமைக்கிறது. இந்த அணுகுமுறை முழு ஸ்ட்ரீமையும் ஒரே டோக்கனாகப் படிக்கிறது, இது InputStream ஐ ஒரு சரமாக மாற்றுவதற்கான ஒரு சுருக்கமான வழியாகும். மூன்றாவது உதாரணம் பயன்படுத்துகிறது Apache Commons IO நூலகம் IOUtils.toString() முறை, குறியீட்டின் ஒரு வரியில் மாற்றத்தைக் கையாள்வதன் மூலம் செயல்முறையை எளிதாக்குகிறது. இந்த முறை மிகவும் வசதியானது, ஆனால் கூடுதல் நூலக சார்பு தேவைப்படுகிறது.
BufferedReader ஐப் பயன்படுத்தி InputStream ஐ String ஆக மாற்றுகிறது
ஜாவா செயல்படுத்தல்
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) throws IOException {
try (BufferedReader reader = new BufferedReader(new InputStreamReader(is))) {
return reader.lines().collect(Collectors.joining(System.lineSeparator()));
}
}
}
ஸ்கேனர் மூலம் இன்புட்ஸ்ட்ரீமைப் படித்தல்
ஜாவா அணுகுமுறை
import java.io.InputStream;
import java.util.Scanner;
public class InputStreamToString {
public static String convertStreamToString(InputStream is) {
Scanner scanner = new Scanner(is).useDelimiter("\\A");
return scanner.hasNext() ? scanner.next() : "";
}
}
InputStream ஐ மாற்ற Apache Commons IO ஐப் பயன்படுத்துதல்
அப்பாச்சி காமன்ஸ் IO உடன் ஜாவா
import java.io.IOException;
import java.io.InputStream;
import org.apache.commons.io.IOUtils;
public class InputStreamToStringApache {
public static String convertStreamToString(InputStream is) throws IOException {
return IOUtils.toString(is, "UTF-8");
}
}
ஜாவா 8 ஸ்ட்ரீம் ஏபிஐ பயன்படுத்தி மாற்றம்
ஸ்ட்ரீம் API உடன் ஜாவா
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.stream.Collectors;
public class InputStreamConverterStream {
public static String convertStreamToString(InputStream is) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
return reader.lines().collect(Collectors.joining(System.lineSeparator()));
}
}
இன்புட்ஸ்ட்ரீம் முதல் சரம் மாற்றத்திற்கான மேம்பட்ட நுட்பங்கள்
அடிப்படை முறைகள் கூடுதலாக, மாற்ற மற்றொரு அணுகுமுறை InputStream ஒரு String பயன்படுத்துகிறது NIO (New Input/Output) ஜாவாவில் தொகுப்பு. தி Files வர்க்கம் எனப்படும் ஒரு முறையை வழங்குகிறது readAllBytes(), உடன் இணைந்து பயன்படுத்தலாம் Paths InputStream இன் உள்ளடக்கத்தை ஒரு பைட் வரிசையாகப் படித்து, அதை ஒரு சரமாக மாற்ற. கோப்பு ஸ்ட்ரீம்களைக் கையாளும் போது இந்த முறை மிகவும் பயனுள்ளதாக இருக்கும், ஜாவாவில் I/O செயல்பாடுகளைக் கையாள நவீன மற்றும் திறமையான வழியை வழங்குகிறது.
மற்றொரு குறிப்பிடத்தக்க முறை பயன்பாட்டை உள்ளடக்கியது ByteArrayOutputStream. InputStream ஐ ஒரு ByteArrayOutputStream ஆக எழுதுவதன் மூலம், அதன் விளைவாக வரும் பைட் வரிசையை ஒரு சரமாக மாற்றலாம். இந்த முறை பன்முகத்தன்மை வாய்ந்தது மற்றும் பைட் தரவை சரமாக மாற்றுவதற்கு முன் அதை கையாள வேண்டிய சூழ்நிலைகளில் பயனுள்ளதாக இருக்கும். இந்த இரண்டு நுட்பங்களும் கூடுதல் நெகிழ்வுத்தன்மையை வழங்குகின்றன மற்றும் தேவைகளைப் பொறுத்து குறிப்பிட்ட பயன்பாட்டு சந்தர்ப்பங்களில் விரும்பப்படலாம்.
InputStream to String Conversion பற்றி அடிக்கடி கேட்கப்படும் கேள்விகள்
- InputStream ஐ String ஆக மாற்றுவதற்கான எளிதான வழி எது?
- பயன்படுத்தி Scanner உடன் useDelimiter("\\A") ஒரு சுருக்கமான மற்றும் எளிதான முறையாகும்.
- NIO ஐப் பயன்படுத்தி ஒரு InputStream ஐ சரமாக மாற்றுவது எப்படி?
- பயன்படுத்தவும் Files.readAllBytes(Paths.get("path")) மற்றும் பைட் வரிசையை சரமாக மாற்றவும்.
- Apache Commons IOஐப் பயன்படுத்தும் முறை உள்ளதா?
- ஆம், IOUtils.toString() Apache Commons IO நூலகத்திலிருந்து பயன்படுத்தலாம்.
- நான் மாற்றுவதற்கு ByteArrayOutputStream ஐப் பயன்படுத்தலாமா?
- ஆம், InputStream ஐ எழுதவும் ByteArrayOutputStream பின்னர் அதை ஒரு சரமாக மாற்றவும்.
- BufferedReader ஐப் பயன்படுத்துவதன் நன்மைகள் என்ன?
- இது இன்புட்ஸ்ட்ரீமை வரிக்கு வரியாக திறம்பட படிக்கிறது, இது பெரிய உரை தரவுகளுக்கு பயனுள்ளதாக இருக்கும்.
- எழுத்துக்குறி குறியாக்க சிக்கல்களை நான் எவ்வாறு கையாள்வது?
- எழுத்துக்குறியைக் குறிப்பிடவும் InputStreamReader அல்லது IOUtils.toString() முறை.
- மாற்றுவதில் System.lineSeparator()ன் பங்கு என்ன?
- வரிகளை ஒரு சரத்தில் இணைக்கும்போது சரியான வரி பிரிப்பான் பயன்படுத்தப்படுவதை இது உறுதி செய்கிறது.
- குறியீட்டின் ஒரு வரியில் உள்ள InputStream ஐ சரமாக மாற்ற முடியுமா?
- ஆம், பயன்படுத்தி IOUtils.toString(InputStream, "UTF-8") மாற்றத்திற்கான ஒரு-லைனர் ஆகும்.
- IOUtils.toString()க்கு என்ன நூலகத்தைச் சேர்க்க வேண்டும்?
- உங்கள் திட்ட சார்புகளில் அப்பாச்சி காமன்ஸ் ஐஓ நூலகத்தைச் சேர்க்கவும்.
இன்புட்ஸ்ட்ரீம் முதல் சரம் மாற்றத்திற்கான மேம்பட்ட நுட்பங்கள்
அடிப்படை முறைகள் கூடுதலாக, மாற்ற மற்றொரு அணுகுமுறை InputStream ஒரு String பயன்படுத்துகிறது NIO (New Input/Output) ஜாவாவில் தொகுப்பு. தி Files வர்க்கம் எனப்படும் ஒரு முறையை வழங்குகிறது readAllBytes(), உடன் இணைந்து பயன்படுத்தலாம் Paths InputStream இன் உள்ளடக்கத்தை ஒரு பைட் வரிசையாகப் படித்து, அதை ஒரு சரமாக மாற்ற. கோப்பு ஸ்ட்ரீம்களைக் கையாளும் போது இந்த முறை மிகவும் பயனுள்ளதாக இருக்கும், ஜாவாவில் I/O செயல்பாடுகளைக் கையாள நவீன மற்றும் திறமையான வழியை வழங்குகிறது.
மற்றொரு குறிப்பிடத்தக்க முறை பயன்பாட்டை உள்ளடக்கியது ByteArrayOutputStream. InputStream ஐ ஒரு ByteArrayOutputStream ஆக எழுதுவதன் மூலம், அதன் விளைவாக வரும் பைட் வரிசையை ஒரு சரமாக மாற்றலாம். இந்த முறை பன்முகத்தன்மை வாய்ந்தது மற்றும் பைட் தரவை சரமாக மாற்றுவதற்கு முன் அதை கையாள வேண்டிய சூழ்நிலைகளில் பயனுள்ளதாக இருக்கும். இந்த இரண்டு நுட்பங்களும் கூடுதல் நெகிழ்வுத்தன்மையை வழங்குகின்றன மற்றும் தேவைகளைப் பொறுத்து குறிப்பிட்ட பயன்பாட்டு சந்தர்ப்பங்களில் விரும்பப்படலாம்.
InputStream to String Conversion பற்றி அடிக்கடி கேட்கப்படும் கேள்விகள்
- InputStream ஐ String ஆக மாற்றுவதற்கான எளிதான வழி எது?
- பயன்படுத்தி Scanner உடன் useDelimiter("\\A") ஒரு சுருக்கமான மற்றும் எளிதான முறையாகும்.
- NIO ஐப் பயன்படுத்தி ஒரு InputStream ஐ சரமாக மாற்றுவது எப்படி?
- பயன்படுத்தவும் Files.readAllBytes(Paths.get("path")) மற்றும் பைட் வரிசையை சரமாக மாற்றவும்.
- Apache Commons IO ஐப் பயன்படுத்தும் முறை உள்ளதா?
- ஆம், IOUtils.toString() Apache Commons IO நூலகத்திலிருந்து பயன்படுத்தலாம்.
- நான் மாற்றுவதற்கு ByteArrayOutputStream ஐப் பயன்படுத்தலாமா?
- ஆம், InputStream ஐ எழுதவும் ByteArrayOutputStream பின்னர் அதை ஒரு சரமாக மாற்றவும்.
- BufferedReader ஐப் பயன்படுத்துவதன் நன்மைகள் என்ன?
- இது இன்புட்ஸ்ட்ரீமை வரிக்கு வரியாக திறம்பட படிக்கிறது, இது பெரிய உரை தரவுகளுக்கு பயனுள்ளதாக இருக்கும்.
- எழுத்துக்குறி குறியாக்க சிக்கல்களை நான் எவ்வாறு கையாள்வது?
- எழுத்துக்குறியைக் குறிப்பிடவும் InputStreamReader அல்லது IOUtils.toString() முறை.
- மாற்றுவதில் System.lineSeparator()ன் பங்கு என்ன?
- வரிகளை ஒரு சரத்தில் இணைக்கும்போது சரியான வரி பிரிப்பான் பயன்படுத்தப்படுவதை இது உறுதி செய்கிறது.
- குறியீட்டின் ஒரு வரியில் உள்ள InputStream ஐ சரமாக மாற்ற முடியுமா?
- ஆம், பயன்படுத்தி IOUtils.toString(InputStream, "UTF-8") மாற்றத்திற்கான ஒரு-லைனர் ஆகும்.
- IOUtils.toString()க்கு என்ன நூலகத்தைச் சேர்க்க வேண்டும்?
- உங்கள் திட்ட சார்புகளில் அப்பாச்சி காமன்ஸ் ஐஓ நூலகத்தைச் சேர்க்கவும்.
இன்புட்ஸ்ட்ரீம் முதல் சரம் மாற்றத்திற்கான இறுதி எண்ணங்கள்
InputStream ஐ ஜாவாவில் சரமாக மாற்றுவது பல்வேறு முறைகள் மூலம் அடையப்படலாம், ஒவ்வொன்றும் அதன் சொந்த நன்மைகள் மற்றும் பொருத்தமான பயன்பாட்டு நிகழ்வுகள். நீங்கள் பயன்படுத்த தேர்வு செய்தாலும் சரி BufferedReader, Scanner, Apache Commons IO, அல்லது NIO, இந்த நுட்பங்களைப் புரிந்துகொள்வது உங்கள் குறிப்பிட்ட தேவைகளுக்கு சிறந்த அணுகுமுறையைத் தேர்ந்தெடுக்க உதவும். திறமையான மற்றும் துல்லியமான மாற்றத்தை உறுதி செய்வது மிகவும் முக்கியமானது, குறிப்பாக பெரிய அளவிலான உரைத் தரவைக் கையாளும் போது.
இந்த வெவ்வேறு முறைகளில் தேர்ச்சி பெறுவதன் மூலம், டெவலப்பர்கள் தங்கள் ஜாவா பயன்பாடுகளில் உள்ளீட்டு ஸ்ட்ரீம் மாற்றங்களை திறம்பட கையாள முடியும், இது உரை தரவை செயலாக்க மற்றும் கையாளும் திறனை மேம்படுத்துகிறது. பதிவுசெய்தல், உள்ளடக்கத்தைக் காண்பித்தல் அல்லது உள்ளீட்டு ஸ்ட்ரீமில் இருந்து உரைத் தரவைப் படித்து ஒரு பயன்பாட்டிற்குள் பயன்படுத்த வேண்டிய எந்தவொரு சூழ்நிலையிலும் இந்த அறிவு அவசியம்.