இடையக எழுத்தாளர்

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

நமக்கு ஏன் BufferedWriter தேவை?

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

இது எழுதும் வேகத்தை பெரிதும் அதிகரிக்கிறது. இயல்புநிலை இடையக அளவு 8192 எழுத்துகள், ஆனால் இதை கன்ஸ்ட்ரக்டரில் புதிய அளவைக் குறிப்பிடுவதன் மூலம் மாற்றலாம்:

BufferedWriter(Writer in, int sz)

இங்கே, கட்டமைப்பாளரின் முதல் வாதம், நாம் எழுதும் தரவைப் பெறும் ஸ்ட்ரீம் ஆகும். sz என்பது புதிய இடையகத்தின் அளவு என்று மாறிவிடும் .

ஜாவாவில் ஒரு BufferedReader வகுப்பும் உள்ளது : இது தரவை இடையகப் படிக்கப் பயன்படுகிறது.

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

BufferedWriter வகுப்பின் கட்டமைப்பாளர்கள் மற்றும் முறைகள்

இப்போது BufferedWriter வகுப்பை இன்னும் விரிவாகப் பார்ப்போம் . ஒரு பொருளை உருவாக்க இரண்டு கட்டமைப்பாளர்கள் உள்ளனர்:

public BufferedWriter(Writer out) 
public BufferedWriter(Writer out, int sz)

இரண்டு கன்ஸ்ட்ரக்டர்களிலும் எழுத வேண்டிய ஸ்ட்ரீம் உள்ளது, ஏற்கனவே குறிப்பிட்டுள்ளபடி sz என்பது இடையகத்தின் அளவு.

BufferedWriter வகுப்பிலும் பல முறைகள் உள்ளன . அவற்றில் சிலவற்றை இன்று விரிவாகப் பார்ப்போம்:

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

எங்களின் உதாரணத்திற்கு, கோப்பு பெயரைக் கொண்ட ஒரு கட்டமைப்பாளரைப் பயன்படுத்துவோம்:

try(BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file.txt"))){
	
	String message = "Hello, Amigo! This is a very important message!";
	bufferedWriter.write(message);
	bufferedWritter.flush();
}
catch(IOException ex){
System.out.println(ex.getMessage());
 }

எங்கள் குறியீடு file.txt கோப்பில் str ஐ எழுத எழுத (ஸ்ட்ரிங் str) முறையைப் பயன்படுத்தும் .

எழுதுவதற்கு வேறு வழிகள் உள்ளன:

• எழுது(char[] array ) - இந்த மாறுபாடு ஒரு சார் வரிசையை ஏற்றுக்கொண்டு எழுதுகிறது ;

• எழுது (ஸ்ட்ரிங் கள், இன்ட் ஆஃப், இன்ட் லென்) - இந்த மாறுபாடு ஒரு சரம் s எடுக்கும் ; ஆஃப்செட் ஆஃப் , இது எழுதத் தொடங்கும் பாத்திரத்தின் குறியீடாகும்; மற்றும் len , இது எழுதப்பட வேண்டிய சரத்தின் (சப்ஸ்ட்ரிங்) நீளம்.

try(BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file.txt"))){
	String message = "Hello, Amigo! This is a very important message!";
	bufferedWriter.write(message, 0, 11);
 	bufferedWriter.flush();

} catch(IOException ex) {
System.out.println(ex.getMessage());
}

குறியீட்டு 0 இலிருந்து 11 எழுத்துக்களை எழுதுவதற்கான முறையை நாங்கள் சொன்னதால், இந்தக் குறியீடு கோப்பில் "ஹலோ, அமிக்" என்று எழுதும்.

எங்கள் குறியீட்டில் ஆதாரங்களுடன் முயற்சி செய்யும் தொகுதியும் உள்ளது :

try(BufferedWriter bufferedWritter = new BufferedWriter(new FileWriter("file.txt"))) 

இதன் பொருள் மூட () முறை தானாகவே என் மீது அழைக்கப்படுகிறதுஇடையக எழுத்தாளர்ஆப்ஜெக்ட், ஏனெனில் இது தானாக மூடக்கூடிய இடைமுகத்தை செயல்படுத்துகிறது.

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

BufferedWriter வகுப்பில் புதிய லைன்() முறை உள்ளது , அது எங்கள் செய்தியில் புதிய வரியைச் சேர்க்கிறது:

try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file.txt"))) {
        String message = "Hello, Amigo! This is a very important message!";
        bufferedWriter.write(message, 0, 13);
        bufferedWriter.newLine();
        bufferedWriter.write(message, 15, 33);
    } catch (IOException ex) {
        System.out.println(ex.getMessage());
    }

கோப்பில், நாம் பெறுகிறோம்:

append() முறையின் கையொப்பம் இதுபோல் தெரிகிறது:

public Writer append(CharSequence csq, int start, int end)

இது csq ஐ சேர்க்க பயன்படுகிறது . இங்கே தொடக்கம் என்பது முதல் எழுத்தின் குறியீடாகும், மேலும் முடிவு என்பது செருகப்பட வேண்டிய சரத்தின் (அல்லது சப்ஸ்ட்ரிங்) கடைசி எழுத்தின் குறியீடாகும். குறியீட்டு முனையுடன் கூடிய எழுத்து செருகப்படவில்லை.

try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file.txt"))) {
    String message = "Hello, Amigo! This is a very important message!";
    bufferedWriter.append(message, 0, 7);
    bufferedWriter.flush();
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

இந்த குறியீடு உங்களுக்கு வழங்கும்:

அதாவது, append முறை மூலம், சரத்தின் எந்தப் பகுதியை பஃப்பரில் சேர்க்க வேண்டும் என்பதைக் குறிப்பிடுகிறீர்கள்.

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

இருப்பினும், பிற்சேர்க்கை முறை புதியது மற்றும் சார்சீக்வென்ஸை ஒரு வாதமாக எடுத்துக்கொள்கிறது, மேலும் சரம் சார்சீக்வென்ஸைச் செயல்படுத்துவதால் , நாம் Strings மற்றும் StringBuilders மற்றும் StringBuffers ஆகியவற்றை append முறைக்கு அனுப்பலாம் . ஆனால் எழுதும்() முறை ஒரு சரத்தை மட்டுமே ஏற்கும் .

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