బఫర్డ్ రైటర్

ప్రోగ్రామ్‌లు తరచుగా ఫైల్‌కి లేదా మరెక్కడైనా డేటాను త్వరగా వ్రాయవలసిన అవసరాన్ని కలిగి ఉంటాయి. మరియు ఇది ప్రశ్నలను లేవనెత్తుతుంది: మనం దీన్ని ఎలా చేయాలి? మనం ఏ తరగతిని ఎంచుకోవాలి? ఈ రోజు మనం ఈ పాత్రకు తగిన అభ్యర్థిని తెలుసుకుంటాము — బఫర్డ్ రైటర్ క్లాస్.

మనకు బఫర్డ్ రైటర్ ఎందుకు అవసరం?

బఫర్డ్ రైటర్ అనేది స్ట్రీమ్‌కు బఫర్ చేయబడిన అక్షరాలను వ్రాసే తరగతి. మీరు భౌతిక మీడియాను యాక్సెస్ చేసే సంఖ్యను తగ్గించడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది. అంటే, ప్రతిసారీ ఒకే అక్షరాన్ని వ్రాయడానికి బదులుగా, ఇది డేటాను బఫర్‌కు వ్రాసి, ఆపై అన్ని అక్షరాలను మీడియంకు ఒకేసారి వ్రాస్తుంది.

ఇది వ్రాసే వేగాన్ని బాగా పెంచుతుంది. డిఫాల్ట్ బఫర్ పరిమాణం 8192 అక్షరాలు, కానీ కన్స్ట్రక్టర్‌లో కొత్త పరిమాణాన్ని పేర్కొనడం ద్వారా దీనిని మార్చవచ్చు:

BufferedWriter(Writer in, int sz)

ఇక్కడ, కన్స్ట్రక్టర్ యొక్క మొదటి వాదన మేము వ్రాసే డేటాను స్వీకరించే స్ట్రీమ్. మరియు sz అనేది కొత్త బఫర్ యొక్క పరిమాణం అని తేలింది .

జావాలో బఫర్డ్ రీడర్ క్లాస్ కూడా ఉంది: ఇది డేటా బఫర్ రీడింగ్ కోసం ఉపయోగించబడుతుంది.

సరిగ్గా బఫర్ అంటే ఏమిటి? నిజ జీవిత ఉదాహరణ తీసుకుందాం. బఫర్ అనేది సూపర్ మార్కెట్‌లో బాస్కెట్ లేదా షాపింగ్ కార్ట్ లాంటిది. ఒకే వస్తువుతో చెక్అవుట్ వరకు నడిచి, దాని కోసం చెల్లించి, మీ కారు ట్రంక్‌లో ఉంచి, ఆపై మరొక వస్తువు కోసం తిరిగి వచ్చే బదులు, మేము షాపింగ్ కార్ట్ తీసుకొని, మనకు కావలసినవన్నీ అందులో ఉంచి, ఆపై చెల్లించవచ్చు. చెక్అవుట్ వద్ద. బఫర్ సరిగ్గా ఈ విధంగా పనిచేస్తుంది: ఇది డేటాను సేకరించి, ప్రతి భాగాన్ని విడివిడిగా వ్రాయడానికి బదులుగా ప్రతిదీ తీసుకొని వ్రాస్తుంది.

బఫర్డ్ రైటర్ క్లాస్ యొక్క కన్స్ట్రక్టర్లు మరియు పద్ధతులు

ఇప్పుడు బఫర్డ్ రైటర్ క్లాస్‌ని నిశితంగా పరిశీలిద్దాం . ఒక వస్తువును రూపొందించడానికి ఇద్దరు కన్స్ట్రక్టర్లు ఉన్నారు:

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

రెండు కన్‌స్ట్రక్టర్‌లలో వ్రాయవలసిన స్ట్రీమ్ ఎక్కడ ఉంది మరియు sz , ఇప్పటికే పేర్కొన్నట్లుగా, బఫర్ పరిమాణం.

బఫర్డ్ రైటర్ క్లాస్ కూడా అనేక పద్ధతులను కలిగి ఉంది. వాటిలో కొన్నింటిని ఈరోజు మనం నిశితంగా పరిశీలిస్తాము:

ఫైల్‌కి విలువను వ్రాసే ప్రోగ్రామ్‌ను వ్రాద్దాం. కొరకురచయితపరామితి, మేము 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[] శ్రేణి ) — ఈ రూపాంతరం చార్ శ్రేణిని అంగీకరిస్తుంది మరియు వ్రాస్తుంది;

• వ్రాయండి(స్ట్రింగ్ s, int off, int len) - ఈ వేరియంట్ స్ట్రింగ్ 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());
}

ఈ కోడ్ మీకు అందిస్తుంది:

అంటే, అనుబంధ పద్ధతితో, బఫర్‌కు స్ట్రింగ్‌లోని ఏ భాగాన్ని జోడించాలో మీరు పేర్కొనండి.

వ్రాయడం() మరియు అనుబంధం() మధ్య వ్యత్యాసాన్ని మరింత నిశితంగా పరిశీలిస్తే , అవి రెండూ సూత్రప్రాయంగా ఒకే పని చేస్తున్నాయని మనం మొదట చూస్తాము - అవి విలువలను వ్రాస్తాయి.

అయితే, వ్యత్యాసం ఏమిటంటే, అనుబంధ పద్ధతి కొత్తది మరియు చార్‌సీక్వెన్స్‌ను ఆర్గ్యుమెంట్‌గా తీసుకుంటుంది మరియు స్ట్రింగ్ చార్‌సీక్వెన్స్‌ని అమలు చేస్తుంది కాబట్టి, మేము స్ట్రింగ్స్ మరియు స్ట్రింగ్‌బిల్డర్‌లు మరియు స్ట్రింగ్‌బఫర్‌లను అనుబంధ పద్ధతికి పాస్ చేయవచ్చు . కానీ వ్రాయడం() పద్ధతి స్ట్రింగ్‌ను మాత్రమే అంగీకరిస్తుంది .

ప్రస్తుతానికి అంతే! ఈ రోజు మనం బఫర్‌లు, ఫైల్‌కి బఫర్డ్ రైటింగ్‌ను ఎలా నిర్వహించాలో, అలాగే మీరు దీన్ని చేయడానికి ఉపయోగించే పద్ధతులతో పరిచయం పొందాము.