Course జావా కలెక్షన్స్ - Lecture: FileInputStream, FileOutputStream, ZipOutputStream, ZipInputStream

"హాయ్, అమిగో!"

"హాయ్, ఎల్లీ!"

"ఈ రోజు మనం I/O స్ట్రీమ్‌లను అధ్యయనం చేయబోతున్నాం."

"అవును, వాటి గురించి నాకు ఇప్పటికే అన్నీ తెలుసు. మేము ఇక్కడ FileInputStream మరియు FileOutputStream తరగతులను ఉపయోగిస్తాము."

"అవును, మరియు ఈ తరగతుల పద్ధతుల్లో మీకు ఏది తెలుసు?"

"ఖచ్చితంగా. FileInputStream యొక్క పద్ధతులు ఇక్కడ ఉన్నాయి:"

పద్ధతి	వివరణ
`int read()`	ఒక బైట్ చదివి దాన్ని తిరిగి ఇస్తుంది.
`int read(byte b[])`	బైట్ శ్రేణిని చదివి, దాన్ని తిరిగి ఇస్తుంది.
`int read(byte b[], int off, int len)`	స్ట్రీమ్ నుండి బైట్ శ్రేణిని చదువుతుంది.
`long skip(long n)`	స్ట్రీమ్ నుండి చదివేటప్పుడు ఉపయోగించబడే n బైట్‌లను దాటవేస్తుంది.
`int available()`	స్ట్రీమ్ నుండి ఇప్పటికీ చదవగలిగే బైట్‌ల సంఖ్యను అందిస్తుంది.
`void close()`	ప్రవాహాన్ని మూసివేస్తుంది.

"స్పాట్ ఆన్! మరియు ఫైల్అవుట్‌పుట్‌స్ట్రీమ్ యొక్క పద్ధతులు?"

"ఒకసారి చూడు:"

పద్ధతి	వివరణ
`void write(int b)`	స్ట్రీమ్‌కు ఒక బైట్ వ్రాస్తుంది.
`void write(byte b[])`	స్ట్రీమ్‌కు బైట్‌ల శ్రేణిని వ్రాస్తుంది.
`void write(byte b[], int off, int len)`	స్ట్రీమ్‌కు బైట్‌ల శ్రేణిని వ్రాస్తుంది.
`void close()`	ప్రవాహాన్ని మూసివేస్తుంది.

"అమిగో, మీరు నన్ను ఆశ్చర్యపరుస్తారు!"

"మరియు అప్పుడు కొన్ని!"

"సరే, నేను మీకు రెండు కొత్త తరగతులను ఇస్తాను: ZipInputStream మరియు ZipOutputStream."

FileInputStream, FileOutputStream, ZipOutputStream, ZipInputStream - 1

" జిప్ ? అది జిప్ ఫైల్ లాగా ఉందా?"

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

"హోలీ మోలీ! ఎంత ఆసక్తికరంగా ఉంటుంది. కానీ జిప్ ఫైల్‌లో ఒక ఫైల్ కాదు, అనేక ఫైల్‌లు ఉంటాయి. అవి ఎలా పని చేస్తాయి?"

"దాని కోసం, మరొక ప్రత్యేక తరగతి ఉంది: ZipEntry . ఇది ఆర్కైవ్‌లో నిల్వ చేయబడిన ఫైల్‌ను ప్రదర్శిస్తుంది. మీరు ZipEntry ఆబ్జెక్ట్‌లను ZipInputStream నుండి మాత్రమే చదవగలరు మరియు మీరు ZipEntry ఆబ్జెక్ట్‌లను ZipOutputStream కి మాత్రమే వ్రాయగలరు . కానీ మీరు చదవగలరు మరియు సాధారణ ఫైల్ వలె జిప్‌ఎంట్రీకి వ్రాయండి ."

"ఇది ఎలా పని చేస్తుందో మీరు నాకు ఒక ఉదాహరణ ఇవ్వగలరా?"

"అయితే, ఇక్కడ మేము ఆర్కైవ్‌ను సృష్టించి, అందులో ఫైల్‌ను ఉంచే ఉదాహరణ ఉంది:"

కోడ్

// Create an archive
FileOutputStream zipFile = new FileOutputStream("c:/archive.zip");
ZipOutputStream zip = new ZipOutputStream(zipFile);

//Put a ZipEntry into it
zip.putNextEntry(new ZipEntry("document.txt"));

//Copy the file «document-for-archive.txt» to the archive under the name «document.txt»
File file = new File("c:/document-for-archive.txt");
Files.copy(file.toPath(), zip);

// Close the archive
zip.close();

"ఎంత ఆసక్తికరమైనది! మరియు ఫైల్‌లను అన్‌జిప్ చేయడం కూడా అంతే సులభం?"

"అవును. ZipEntry , ZipInputStream మరియు ZipOutputStream తరగతుల పద్ధతుల యొక్క సంక్షిప్త వివరణ ఇక్కడ ఉంది "

" జిప్‌ఇన్‌పుట్‌స్ట్రీమ్ ఒక స్ట్రీమ్, కాబట్టి అన్ని జిప్‌ఎంట్రీలను సీక్వెన్షియల్‌గా మాత్రమే చదవగలరు. దాని పద్ధతులు ఇక్కడ ఉన్నాయి:"

పద్ధతి	వివరణ
`ZipEntry getNextEntry()`	తదుపరి ZipEntryని వివరించే వస్తువును అందిస్తుంది (ప్రస్తుత ఎంట్రీలోని అన్ని బైట్‌లను దాటవేస్తుంది).
`void closeEntry()`	ప్రస్తుత ZipEntryలో ఇన్‌పుట్ స్ట్రీమ్‌ను మూసివేస్తుంది (ప్రస్తుత ఎంట్రీలోని అన్ని బైట్‌లను దాటవేస్తుంది).
`int available()`	రిటర్న్స్ 1 జిప్‌ఎంట్రీలు అందుబాటులో ఉన్నాయి, లేకపోతే 0.
`int read(byte[] b, int off, int len)`	ప్రస్తుత ZipEntry నుండి బైట్‌లను చదువుతుంది.
`long skip(long n)`	స్ట్రీమ్ నుండి చదివేటప్పుడు n బైట్‌లను దాటవేస్తుంది.
`void close()`	ప్రవాహాన్ని మూసివేస్తుంది.

"నాకు నిజంగా అర్థం కాలేదు."

"మీరు టెక్స్ట్ ఫైల్‌ని చదువుతున్నారని ఊహించుకోవడం ఉత్తమమైన పని, మరియు జిప్‌ఎంట్రీలు ఫైల్‌లోని లైన్‌ల వలె ఉంటాయి. మీరు ప్రస్తుత లైన్ (ప్రస్తుత జిప్‌ఎంట్రీ ) నుండి డేటాను చదవవచ్చు లేదా పంక్తి నుండి పంక్తికి వెళ్లవచ్చు ( getNextEntry , closeEntry ) ."

"నేను అర్థం చేసుకున్నాను, కానీ నాకు ఖచ్చితంగా తెలియదు."

"ఇక్కడ ZipOutputStream మరియు దాని పద్ధతులు ఉన్నాయి:"

పద్ధతి	వివరణ
`void setComment(String comment)`	ఆర్కైవ్‌పై వ్యాఖ్యను సెట్ చేస్తుంది.
`void setMethod(int method)`	కుదింపు పద్ధతి (రకం) సెట్ చేస్తుంది.
`void setLevel(int level)`	కుదింపు స్థాయిని సెట్ చేస్తుంది. అధిక కుదింపు, అది నెమ్మదిగా వెళుతుంది.
`void putNextEntry(ZipEntry e)`	కొత్త జిప్‌ఎంట్రీని జోడిస్తుంది.
`void closeEntry()`	ప్రస్తుత జిప్‌ఎంట్రీని మూసివేస్తుంది
`void write(byte[] b, int off, int len)`	ప్రస్తుత జిప్‌ఎంట్రీకి బైట్‌ల సమితిని వ్రాస్తుంది.
`void close()`	ప్రవాహాన్ని మూసివేస్తుంది.

"కానీ పై ఉదాహరణలో మేము దాదాపు ఏదీ ఉపయోగించలేదు."

"ఇవి ఐచ్ఛిక పద్ధతులు. మీరు కుదింపు స్థాయి మరియు పద్ధతిని పేర్కొనవలసిన అవసరం లేదు-డిఫాల్ట్ సెట్టింగ్‌లు ఉపయోగించబడతాయి."

"హ్మ్. అది అంత చెడ్డది కాదు. మరియు జిప్‌ఎంట్రీ?"

"ఖచ్చితంగా. జిప్‌ఎంట్రీలో ఉన్న ఏకైక ఇతర సమాచారం హౌస్‌కీపింగ్ సమాచారం:"

పద్ధతి	వివరణ
`String getName(), setName(String)`	అంతర్గత పేరు ఫైల్.
`long getTime(), setTime(long)`	చివరిసారి ఎంట్రీ సవరించబడింది.
`long getCRC(), setCRC(long)`	చెక్సమ్.
`long getSize(), setSize(long)`	కంప్రెషన్ ముందు పరిమాణం.
`int getMethod(), setMethod(int)`	కుదింపు పద్ధతి.
`long get/setCompressedSize()`	జిప్ చేసిన తర్వాత పరిమాణం.
`boolean isDirectory()`	ఎంట్రీ డైరెక్టరీనా?

"అది చాలా కష్టంగా అనిపించదు. ప్రేమించడానికి ఏమి లేదు!"

"అద్భుతం, అప్పుడు డియెగో మీకు ఈ అంశంపై టాస్క్‌లను కూడా ఇస్తాడు."

"నేను నోరు మూసుకుని ఉండాల్సింది."