జావాలో ఇన్‌పుట్/అవుట్‌పుట్. FileInputStream, FileOutputStream మరియు BufferedInputStream తరగతులు

"హాయ్! నేటి పాఠంలో, మేము జావాలో ఇన్‌పుట్ మరియు అవుట్‌పుట్ స్ట్రీమ్‌ల గురించి మా సంభాషణను కొనసాగిస్తాము ( జావా I/O ). ఇది ఈ అంశంపై మొదటి పాఠం కాదు మరియు ఇది ఖచ్చితంగా చివరిది కాదు :) జరుగుతుంది, జావా భాష I/Oతో పని చేయడానికి అనేక మార్గాలను అందిస్తుంది. ఈ కార్యాచరణను అమలు చేసే కొన్ని తరగతులు ఉన్నాయి, కాబట్టి మేము వాటిని అనేక పాఠాలుగా విభజించాము — కాబట్టి మీరు మొదటి నుండి గందరగోళం చెందరు :) గతంలో పాఠాలు, మేము స్పర్శించాము BufferedReader, అలాగే InputStreamమరియు OutputStreamవియుక్త తరగతులు మరియు అనేక మంది వారసులు. ఈ రోజు మనం 3 కొత్త తరగతులను పరిశీలిస్తాము: FileInputStream,  FileOutputStream, మరియు  BufferedInputStream.

FileOutputStream క్లాస్

FileOutputStreamఫైల్‌కి బైట్‌లను వ్రాయడం తరగతి యొక్క ముఖ్య ఉద్దేశ్యం . సంక్లిష్టంగా ఏమీ లేదు :) వియుక్త తరగతి FileOutputStreamయొక్క అమలులలో ఒకటి OutputStream. కన్స్ట్రక్టర్‌లో, ఈ తరగతికి చెందిన ఆబ్జెక్ట్‌లు లక్ష్య ఫైల్‌కి (బైట్‌లు వ్రాయవలసిన చోట) లేదా ఆబ్జెక్ట్‌కి మార్గాన్ని తీసుకుంటాయి File. మేము ప్రతి ఉదాహరణలను పరిశీలిస్తాము:

public class Main { 

   public static void main(String[] args) throws IOException { 

       File file = new File("C:\\Users\\Username\\Desktop\\test.txt"); 
       FileOutputStream fileOutputStream = new FileOutputStream(file); 

       String greetings = "Hi! Welcome to CodeGym — The best site for would-be programmers!"; 

       fileOutputStream.write(greetings.getBytes()); 
       fileOutputStream.close(); 
   } 
}

వస్తువును సృష్టించేటప్పుడు File, మేము కన్స్ట్రక్టర్‌కు కావలసిన మార్గాన్ని ఆమోదించాము. మేము దీన్ని ముందుగానే సృష్టించాల్సిన అవసరం లేదు: అది ఉనికిలో లేకుంటే, ప్రోగ్రామ్ దానిని సృష్టిస్తుంది. మీరు అదనపు ఆబ్జెక్ట్‌ను సృష్టించకుండా, మార్గంతో స్ట్రింగ్‌ను పాస్ చేయడం ద్వారా కూడా పొందవచ్చు:

public class Main { 

    public static void main(String[] args) throws IOException { 

       FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Username\\Desktop\\test.txt"); 
       String greetings = "Hi! Welcome to CodeGym — The best site for would-be programmers!"; 

       fileOutputStream.write(greetings.getBytes()); 
       fileOutputStream.close(); 
   } 
} 

రెండు సందర్భాల్లోనూ ఫలితం ఒకేలా ఉంటుంది. మేము మా ఫైల్‌ని తెరిచి, కింది వాటిని అక్కడ చూడవచ్చు:

Hi! Welcome to CodeGym — The best site for would-be programmers!

కానీ ఇక్కడ ఒక స్వల్పభేదం ఉంది. ఎగువ ఉదాహరణ నుండి కోడ్‌ను వరుసగా అనేకసార్లు అమలు చేయడానికి ప్రయత్నించండి. అప్పుడు ఫైల్‌లో చూడండి మరియు ఈ ప్రశ్నకు సమాధానం ఇవ్వండి: దీనికి ఎన్ని లైన్లు ఉన్నాయి? కేవలం ఒకటి. కానీ మీరు అనేక సార్లు కోడ్‌ని అమలు చేసారు. డేటా ప్రతిసారీ ఓవర్‌రైట్ చేయబడుతుందని తేలింది - పాతది కొత్తది ద్వారా భర్తీ చేయబడుతుంది. అది మనకు సరిపోకపోతే మరియు ఫైల్‌కి వరుసగా వ్రాయవలసి వస్తే మనం ఏమి చేస్తాము? ఒక ఫైల్‌కి మన గ్రీటింగ్‌ని వరుసగా మూడుసార్లు రాయాలనుకుంటే? ఇది అన్ని చాలా సులభం. ప్రతి సందర్భంలో మనకు ఎలాంటి ప్రవర్తన అవసరమో భాష తెలుసుకోలేనందున, FileOutputStreamకంట్రక్యూటర్ అదనపు పరామితిని తీసుకోవచ్చు —boolean append. దాని విలువ నిజమైతే, డేటా ఫైల్ చివరి వరకు వ్రాయబడుతుంది. ఇది తప్పు అయితే (మరియు డిఫాల్ట్‌గా ఇది తప్పు), ఏదైనా పాత డేటా తొలగించబడుతుంది మరియు కొత్త డేటాతో భర్తీ చేయబడుతుంది. మా సవరించిన కోడ్‌ను మూడుసార్లు అమలు చేయడం ద్వారా దీన్ని తనిఖీ చేద్దాం:

public class Main { 

   public static void main(String[] args) throws IOException { 

       FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Username\\Desktop\\test.txt", true); 
       String greetings = "Hi! Welcome to CodeGym — The best site for would-be programmers!\r\n"; 

       fileOutputStream.write(greetings.getBytes()); 
       fileOutputStream.close(); 
   } 
} 

ఫైల్ కంటెంట్‌లు:

Hi! Welcome to CodeGym — The best site for would-be programmers! 
Hi! Welcome to CodeGym — The best site for would-be programmers! 
Hi! Welcome to CodeGym — The best site for would-be programmers!

ఇప్పుడు అది వేరు! I/O తరగతులను ఉపయోగిస్తున్నప్పుడు ఈ ఫీచర్ గురించి మర్చిపోవద్దు. నేను టాస్క్‌ల కోసం గంటలు గడిపిన సమయం ఉంది, నా మెదడును గంటల తరబడి ర్యాక్ చేయడం, ఫైల్‌ల నుండి నా డేటా ఎలా అదృశ్యమవుతుందో అర్థం చేసుకోవడానికి ప్రయత్నించడం :) మరియు ఇతర I/O తరగతుల మాదిరిగానే, పద్ధతిని ఉపయోగించడం close()మర్చిపోవద్దు ఉచిత వనరులకు.

FileInputStream తరగతి

దీనికి FileInputStreamవ్యతిరేక ప్రయోజనం ఉంది - ఫైల్ నుండి బైట్‌లను చదవడం. వారసత్వంగా , ఈ తరగతి నైరూప్య తరగతి నుండి FileOutputStreamఉద్భవించింది . మేము మా " test.txt " ఫైల్‌లో వచనం యొక్క కొన్ని పంక్తులను వ్రాస్తాము : OutputStreamInputStream

"So close no matter how far 
Couldn't be much more from the heart 
Forever trusting who we are 
And nothing else matters"

దీన్ని ఉపయోగించి ఫైల్ నుండి డేటాను చదవడం ఎలా కనిపిస్తుంది FileInputStream:

public class Main { 

   public static void main(String[] args) throws IOException { 

       FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Username\\Desktop\\test.txt"); 

       int i; 

       while((i=fileInputStream.read())!= -1){ 

           System.out.print((char)i); 

       } 
   } 
}

మేము ఫైల్ నుండి ఒక బైట్‌ని చదివాము, రీడ్ బైట్‌లను అక్షరాలుగా మారుస్తాము మరియు వాటిని కన్సోల్‌లో ప్రదర్శిస్తాము. మరియు ఇక్కడ కన్సోల్ అవుట్‌పుట్ ఉంది:

So close no matter how far 
Couldn't be much more from the heart 
Forever trusting who we are 
And nothing else matters

బఫర్డ్‌ఇన్‌పుట్‌స్ట్రీమ్ క్లాస్

BufferedInputStreamగత పాఠాల నుండి వచ్చిన జ్ఞానాన్ని బట్టి, మాకు క్లాస్ ఎందుకు అవసరమో మరియు దానితో పోలిస్తే దాని ప్రయోజనాలు ఏమిటో మీరు సులభంగా చెప్పగలరని నేను అనుకుంటున్నాను FileInputStream:) మేము ఇప్పటికే బఫర్డ్ స్ట్రీమ్‌లను ఎదుర్కొన్నాము, కాబట్టి మీరు చదవడం కొనసాగించే ముందు ఊహించడానికి (లేదా గుర్తుంచుకోండి) ప్రయత్నించండి :) I/Oని ఆప్టిమైజ్ చేయడానికి ప్రధానంగా బఫర్డ్ స్ట్రీమ్‌లు అవసరం. ఫైల్ నుండి చదవడం వంటి డేటా మూలాన్ని యాక్సెస్ చేయడం పనితీరు పరంగా ఖరీదైన ఆపరేషన్ మరియు ప్రతి బైట్‌ని చదవడానికి ఫైల్‌ను యాక్సెస్ చేయడం వృధా. అందుకే BufferedInputStreamడేటాను ఒక సమయంలో ఒక బైట్ కాకుండా బ్లాక్‌లలో రీడ్ చేస్తుంది మరియు వాటిని తాత్కాలికంగా ప్రత్యేక బఫర్‌లో నిల్వ చేస్తుంది. ఇది మనం ఫైల్‌ని యాక్సెస్ చేసే సంఖ్యను తగ్గించడం ద్వారా ప్రోగ్రామ్‌ను ఆప్టిమైజ్ చేయడానికి అనుమతిస్తుంది. ఇది ఎలా ఉంటుందో చూద్దాం:

public class Main { 

   public static void main(String[] args) throws IOException { 

       FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Username\\Desktop\\test.txt"); 

       BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream, 200); 

       int i; 

       while((i = bufferedInputStream.read())!= -1){ 

           System.out.print((char)i); 
       } 
   } 
} 

ఇక్కడ మేము ఒక BufferedInputStreamవస్తువును సృష్టించాము. InputStreamదీని కన్స్ట్రక్టర్ క్లాస్ లేదా దాని వారసుల్లో ఎవరినైనా ఉదాహరణగా తీసుకుంటుంది , అలా FileInputStreamచేస్తుంది. అదనపు వాదనగా, ఇది బఫర్ పరిమాణాన్ని బైట్‌లలో తీసుకుంటుంది. ఈ వాదనకు ధన్యవాదాలు, డేటా ఇప్పుడు ఫైల్ నుండి ఒక సమయంలో ఒక బైట్ కాదు, కానీ ఒకేసారి 200 బైట్‌లు చదవబడుతుంది! ఫైల్ యాక్సెస్‌ల సంఖ్యను మనం ఎంత తగ్గించామో ఊహించండి. పనితీరును సరిపోల్చడానికి, మీరు ఒక పెద్ద టెక్స్ట్ ఫైల్‌ని (అనేక మెగాబైట్‌ల టెక్స్ట్) తీసుకోవచ్చు మరియు ఉపయోగించి కన్సోల్‌కి రీడ్ చేయడానికి మరియు అవుట్‌పుట్ చేయడానికి మిల్లీసెకన్లలో ఎంత సమయం పడుతుందో సరిపోల్చండి FileInputStreamమరియు BufferedInputStream. రెండు ఎంపికలను ప్రదర్శించే కోడ్ ఇక్కడ ఉంది:

public class Main { 

   public static void main(String[] args) throws IOException { 

       Date date = new Date(); 

       FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Username\\Desktop\\textBook.rtf"); 
       BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream); 

       int i; 
       while((i = bufferedInputStream.read())!= -1){ 

           System.out.print((char)i); 
       } 

       Date date1 = new Date(); 
       System.out.println((date1.getTime() - date.getTime())); 
   } 
} 

 
public class Main { 

   public static void main(String[] args) throws IOException { 

       Date date = new Date(); 
       FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Username\\Desktop\\26951280.rtf"); 

       int i; 
       while((i = fileInputStream.read())!= -1){ 

           System.out.print((char)i); 
       } 


       Date date1 = new Date(); 
       System.out.println((date1.getTime() - date.getTime())); 
   }
}

నా కంప్యూటర్‌లో 1.5 MB ఫైల్‌ని చదివినప్పుడు, FileInputStreamపనిని ~3500 మిల్లీసెకన్లలో పూర్తి చేసాను, కానీ BufferedInputStreamదానిని ~1700 మిల్లీసెకన్లలో నిర్వహించాను. మీరు చూడగలిగినట్లుగా, బఫర్ చేయబడిన స్ట్రీమ్ పనిని ఆప్టిమైజ్ చేసి, దానిని సగానికి తగ్గించింది! :) మేము I/O తరగతులను చదవడం కొనసాగిస్తాము — త్వరలో కలుద్దాం!