வெளியீடு ஸ்ட்ரீம்கள்

1. OutputStreamவர்க்கம்

உள்ளீட்டு ஸ்ட்ரீம்களை சமீபத்தில் ஆராய்ந்தோம். வெளியீட்டு ஸ்ட்ரீம்களைப் பற்றி பேச வேண்டிய நேரம் இது.

வகுப்பு OutputStreamஎன்பது பைட் வெளியீட்டை ஆதரிக்கும் அனைத்து வகுப்புகளுக்கும் பெற்றோர் வகுப்பாகும். இது ஒரு சுருக்க வகுப்பாகும், அது சொந்தமாக எதையும் செய்யாது, ஆனால் இது ஒவ்வொரு சந்தர்ப்பத்திற்கும் சந்ததி வகுப்புகளைக் கொண்டுள்ளது.

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

ஆனால் மீண்டும் வகுப்பிற்கு OutputStream. இந்த வகுப்பில் அதன் அனைத்து சந்ததி வகுப்புகளும் செயல்படுத்த வேண்டிய முறைகள் உள்ளன. இங்கே முதன்மையானவை:

void write(int b)

void write(byte[] buffer)

void write(byte[] buffer, off, len)

void flush()

void close()

மரபுரிமையாகப் பெறும் ஒரு வகுப்பின் பொருளை நீங்கள் உருவாக்கும்போது InputStream, ​​தரவைப் படிக்கும் ஒரு மூலப் பொருளை நீங்கள் வழக்கமாகக் குறிப்பிடுவீர்கள் InputStream. மரபுரிமையாகப் பெறும் ஒரு வகுப்பின் பொருளை நீங்கள் உருவாக்கும்போது OutputStream, ​​தரவு எழுதப்படும் இலக்கு பொருள் அல்லது ஸ்ட்ரீமையும் குறிப்பிடுவீர்கள்.

வகுப்பின் அனைத்து முறைகளையும் சுருக்கமாகப் பார்ப்போம் OutputStream:

write(int b)முறை

intஇந்த முறை வெளியீடு ஸ்ட்ரீமில் ஒரு பைட்டை (ஒரு அல்ல) எழுதுகிறது . அனுப்பப்பட்ட மதிப்பு ஒரு பைட்டிற்கு அனுப்பப்படுகிறது, மேலும் int இன் முதல் மூன்று பைட்டுகள் நிராகரிக்கப்படும்.

write(byte[] buffer)முறை

கொடுக்கப்பட்ட பைட்டுகளின் வரிசையை வெளியீட்டு ஸ்ட்ரீமில் எழுதுகிறது. அவ்வளவுதான்.

write(byte[] buffer, int offset, int length)முறை

அனுப்பப்பட்ட பைட்டுகளின் வரிசையின் ஒரு பகுதியை வெளியீட்டு ஸ்ட்ரீமுக்கு எழுதுகிறது. ஆஃப்செட் மாறி வரிசையின் முதல் உறுப்பின் குறியீட்டைக் குறிக்கிறது, மேலும் lengthஇது எழுதப்பட வேண்டிய துணைக்குழுவின் நீளமாகும்.

flush()முறை

flush()தற்போதைய ஸ்ட்ரீமில் இடையகப்படுத்தப்பட்ட எந்தத் தரவையும் இலக்கு ஸ்ட்ரீமில் எழுதும்படி கட்டாயப்படுத்த இந்த முறை பயன்படுத்தப்படுகிறது. ஒரு சங்கிலியில் ஏற்பாடு செய்யப்பட்ட இடையக மற்றும்/அல்லது பல ஸ்ட்ரீம் பொருட்களைப் பயன்படுத்தும் போது இது பொருத்தமானது.

close()முறை

எந்த எழுதப்படாத தரவையும் இலக்கு பொருளுக்கு எழுதுகிறது. நீங்கள் ஒரு தொகுதியைப் பயன்படுத்தினால், முறை close()அழைக்கப்பட வேண்டியதில்லை try-with-resources.

ஒரு கோப்பை நகலெடுப்பதற்கான எடுத்துக்காட்டு

String src = "c:\\projects\\log.txt";
String dest = "c:\\projects\\copy.txt";

try(FileInputStream input = new FileInputStream(src);
FileOutputStream output = new FileOutputStream(dest))
{
   byte[] buffer = new byte[65536]; // 64Kb
   while (input.available() > 0)
   {
      int real = input.read(buffer);
      output.write(buffer, 0, real);
   }
}

2. Writerவர்க்கம்

வகுப்பானது வகுப்பைப் Writerபோலவே உள்ளது OutputStream, ஆனால் மீண்டும் ஒரு வித்தியாசம்: இது charபைட்டுகளுக்குப் பதிலாக ( ) எழுத்துகளுடன் வேலை செய்கிறது.

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

வகுப்பின் முறைகள் Writer(மற்றும் அதன் அனைத்து சந்ததி வகுப்புகள்):

void write(int b)

void write(char[] buffer)

void write(char[] buffer, off, len)

void write(String str)

void write(String str, off, len)

void flush()

void close()

முறைகள் வகுப்பின் முறைகளைப் போலவே இருக்கின்றன OutputStream, ஆனால் அவை பைட்டுகளுக்குப் பதிலாக எழுத்துகளுடன் வேலை செய்கின்றன.

முறைகளின் விளக்கம்:

write(int b)முறை

இந்த முறை வெளியீட்டு ஸ்ட்ரீமில் ஒரு எழுத்தை ( char— a அல்ல ) எழுதுகிறது. intஅனுப்பப்பட்ட மதிப்பு a க்கு அனுப்பப்பட்டு char, முதல் இரண்டு பைட்டுகள் நிராகரிக்கப்படும்.

write(char[] buffer)முறை

அவுட்புட் ஸ்ட்ரீமில் கொடுக்கப்பட்ட எழுத்துக்களின் வரிசையை எழுதுகிறது.

write(char[] buffer, int offset, int length)முறை

அனுப்பப்பட்ட எழுத்துக்களின் வரிசையின் ஒரு பகுதியை வெளியீட்டு ஸ்ட்ரீமில் எழுதுகிறது. மாறியானது offsetவரிசையின் முதல் உறுப்பின் குறியீட்டைக் குறிக்கிறது, மேலும் lengthஇது எழுதப்பட வேண்டிய துணைக்குழுவின் நீளமாகும்.

write(String str)முறை

கொடுக்கப்பட்ட சரத்தை அவுட்புட் ஸ்ட்ரீமில் எழுதுகிறது.

write(String str, int offset, int length)முறை

கொடுக்கப்பட்ட சரத்தின் ஒரு பகுதியை அவுட்புட் ஸ்ட்ரீமுக்கு எழுதுகிறது: சரம் எழுத்துகளின் வரிசையாக மாற்றப்படுகிறது. மாறியானது offsetவரிசையின் முதல் உறுப்பின் குறியீட்டைக் குறிக்கிறது, மேலும் lengthஇது எழுதப்பட வேண்டிய துணைக்குழுவின் நீளமாகும்.

flush()முறை

flush()தற்போதைய ஸ்ட்ரீமில் இடையகப்படுத்தப்பட்ட எந்தத் தரவையும் இலக்கு ஸ்ட்ரீமில் எழுதும்படி கட்டாயப்படுத்த இந்த முறை பயன்படுத்தப்படுகிறது. ஒரு சங்கிலியில் ஏற்பாடு செய்யப்பட்ட இடையக மற்றும்/அல்லது பல ஸ்ட்ரீம் பொருட்களைப் பயன்படுத்தும் போது இது பொருத்தமானது.

close()முறை

எந்த எழுதப்படாத தரவையும் இலக்கு பொருளுக்கு எழுதுகிறது. நீங்கள் ஒரு தொகுதியைப் பயன்படுத்தினால், முறை close()அழைக்கப்பட வேண்டியதில்லை try-with-resources.

உரை கோப்பை நகலெடுக்கும் நிரலின் எடுத்துக்காட்டு:

String src = "c:\\projects\\log.txt";
String dest = "c:\\projects\\copy.txt";

try(FileReader reader = new FileReader(src);
FileWriter writer = new FileWriter(dest))
{
   char[] buffer = new char[65536]; // 128Kb
   while (reader.ready())
   {
      int real = reader.read(buffer);
      writer.write(buffer, 0, real);
   }
}

StringWriterவர்க்கம்

வகுப்பை மரபுரிமையாகக் கொண்ட மற்றொரு சுவாரஸ்யமான வகுப்பு உள்ளது Writer: இது அழைக்கப்படுகிறது StringWriter. இது ஒரு மாறக்கூடிய சரத்தைக் கொண்டுள்ளது - ஒரு StringBufferபொருள். ஒவ்வொரு முறையும் நீங்கள் பொருளுக்கு எதையாவது "எழுதும்போது" StringWriter, உரை அதன் உள் தாங்கலில் சேர்க்கப்படும்.

உதாரணமாக:

StringWriter writer = new StringWriter();
writer.write("Hello");
writer.write(String.valueOf(123));

String result = writer.toString();

இந்த வழக்கில், StringWriterவர்க்கம் அடிப்படையில் வகுப்பின் மேல் ஒரு ரேப்பர் ஆகும் StringBuffer, ஆனால் StringWriterவகுப்பு ஸ்ட்ரீம் வகுப்பின் வழித்தோன்றலாகும் Writer, மேலும் இது ஸ்ட்ரீம் பொருள்களின் சங்கிலிகளில் பயன்படுத்தப்படலாம். இது நடைமுறையில் மிகவும் பயனுள்ள சொத்து.

3. PrintStreamவர்க்கம்

வெளியீட்டு ஸ்ட்ரீம் வகுப்புகள் அவர்களுக்கு அனுப்பப்பட்ட இலக்கு ஸ்ட்ரீமில் தரவை எழுதும் இடைநிலை ஸ்ட்ரீம்களுடன் ஒரு சங்கிலியில் வைக்கப்படலாம். இந்த ஸ்ட்ரீம்களின் தொடர்புகளின் பொதுவான பார்வை இதுபோல் தெரிகிறது:

அனைத்து இடைநிலை வெளியீட்டு ஸ்ட்ரீம்களிலும் மிகவும் சுவாரஸ்யமானது மற்றும் பல்துறை PrintStream. இது பல்லாயிரக்கணக்கான முறைகள் மற்றும் 12 கட்டமைப்பாளர்களைக் கொண்டுள்ளது.

வர்க்கம் வர்க்கத்தை PrintStreamமரபுரிமையாகப் பெறுகிறது FilterOutputStream, இது மரபுரிமையாகும் OutputStream. அதாவது வகுப்பு அதன் சொந்த முறைகள் தவிர பெற்றோர் வகுப்புகளின் அனைத்து முறைகளையும்PrintStream கொண்டுள்ளது . மிகவும் சுவாரஸ்யமானவை இங்கே:

void print(obj)

void println(obj)

void println()

PrintStream format(String format, args...)

இந்த பத்து முறைகள் எங்கே என்று நீங்கள் கேட்கிறீர்களா?

சரி, இது பல்வேறு அளவுருக்கள் print()மற்றும் முறைகளின் பல வகைகளைக் கொண்டுள்ளது. println()அவற்றை இந்த அட்டவணையில் சுருக்கமாகக் கூறலாம்.

இந்த முறைகளில் நாங்கள் மூழ்க மாட்டோம், ஏனென்றால் நீங்கள் ஏற்கனவே அவற்றை நன்கு அறிவீர்கள். நான் எதைப் பெறுகிறேன் என்று உங்களால் யூகிக்க முடியுமா?

நினைவிருக்கிறதா System.out.println()? ஆனால் அதை இரண்டு வரிகளில் எழுதலாம்:

PrintStream stream = System.out;
stream.println("Hello!");

Hello!

எங்கள் விருப்பமான கட்டளையானது வகுப்பின் நிலையான மாறியின் முறைக்கான அழைப்பு . இந்த மாறியின் வகை .System.out.println()println()outSystemPrintStream

PrintStreamநிறைய கோட்ஜிம் நிலைகளிலும், கிட்டத்தட்ட ஒவ்வொரு பணியிலும், வகுப்பின் முறைகளை நீங்கள் அறியாமலேயே அழைக்கிறீர்கள் !

நடைமுறை பயன்பாடு

ஜாவாவில் இந்த சுவாரஸ்யமான வகுப்பு உள்ளது ByteArrayOutputStream, இது பரம்பரையாக வளரும் பைட் வரிசையாகும் OutputStream.

ஒரு ByteArrayOutputStreamபொருளையும் PrintStreamபொருளையும் இவ்வாறு சங்கிலியால் பிணைக்க முடியும்:

ByteArrayOutputStream baos = new ByteArrayOutputStream();

try(PrintStream stream = new PrintStream(baos))
{
   stream.println("Hello");
   stream.println(123);
}

String result = baos.toString();

System.out.println(result);

Hello!
123