జావాలో ఫైల్ హ్యాండ్లింగ్ - జావా ఫైళ్ళతో ఎలా పని చేయాలి?

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

ఈ వ్యాసంలో క్రింద విషయాలు ఉన్నాయి:

Android స్టూడియో దశల వారీగా

• జావాలో ఫైల్ హ్యాండ్లింగ్ అంటే ఏమిటి?
• స్ట్రీమ్ అంటే ఏమిటి?
• జావా ఫైల్ పద్ధతులు
• జావాలో ఫైల్ ఆపరేషన్లు

జావాలో ఫైల్ హ్యాండ్లింగ్ అంటే ఏమిటి?

జావాలో ఫైల్ నిర్వహణ ఒక ఫైల్ నుండి డేటాను చదవడం మరియు వ్రాయడం సూచిస్తుంది. నుండి ఫైల్ క్లాస్ java.io ప్యాకేజీ , ఫైళ్ళ యొక్క వివిధ ఫార్మాట్లతో పనిచేయడానికి అనుమతిస్తుంది. ఫైల్ క్లాస్‌ని ఉపయోగించడానికి, మీరు యొక్క ఒక వస్తువును సృష్టించాలి మరియు ఫైల్ పేరు లేదా డైరెక్టరీ పేరును పేర్కొనండి.

ఉదాహరణకి:

// ఫైల్ క్లాస్ దిగుమతిని దిగుమతి చేయండి java.io.File // ఫైల్ పేరును పేర్కొనండి ఫైల్ obj = new file ('filename.txt')

ఫైల్‌లో I / O ఆపరేషన్లు చేయడానికి జావా స్ట్రీమ్ యొక్క భావనను ఉపయోగిస్తుంది. కాబట్టి జావాలో స్ట్రీమ్ అంటే ఏమిటో ఇప్పుడు అర్థం చేసుకుందాం.

స్ట్రీమ్ అంటే ఏమిటి?

జావాలో, స్ట్రీమ్ అనేది డేటా యొక్క క్రమం, ఇది రెండు రకాలుగా ఉంటుంది.

1. బైట్ స్ట్రీమ్

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

2. అక్షర ప్రవాహం

అక్షర స్ట్రీమ్ అనేది అక్షరాలతో కూడిన స్ట్రీమ్. అక్షరంతో ఇన్‌పుట్ డేటాను ప్రాసెస్ చేయడం అక్షర స్ట్రీమ్‌తో ఫైల్ హ్యాండ్లింగ్ ప్రాసెస్ అంటారు.

స్ట్రీమ్ అంటే ఏమిటో మీకు ఇప్పుడు తెలుసు, జావాలో ఫైల్ హ్యాండ్లింగ్ పై ఈ కథనాన్ని లోతుగా డైవ్ చేద్దాం మరియు ఫైళ్ళపై ఆపరేషన్లకు ఉపయోగపడే వివిధ పద్ధతులను సృష్టించడం, చదవడం మరియు రాయడం వంటివి తెలుసుకుందాం.

జావా ఫైల్ పద్ధతులు

దిగువ పట్టిక జావా ఫైళ్ళపై కార్యకలాపాలు నిర్వహించడానికి ఉపయోగించే వివిధ పద్ధతులను వర్ణిస్తుంది.

జావాలోని వివిధ ఫైల్ ఆపరేషన్లు ఏమిటి మరియు వాటిని ఎలా చేయాలో ఇప్పుడు అర్థం చేసుకుందాం.

జావాలో ఫైల్ ఆపరేషన్లు

సాధారణంగా, మీరు ఫైల్‌లో నాలుగు ఆపరేషన్లు చేయవచ్చు. అవి ఈ క్రింది విధంగా ఉన్నాయి:

1. 1. ఫైల్‌ను సృష్టించండి
   2. ఫైల్ సమాచారం పొందండి
   3. ఒక ఫైల్‌కు వ్రాయండి
   4. ఫైల్ నుండి చదవండి

ఇప్పుడు, ఈ ప్రతి ఆపరేషన్ యొక్క వివరాలను తెలుసుకుందాం

1. ఫైల్ను సృష్టించండి

ఈ సందర్భంలో, ఒక ఫైల్ను సృష్టించడానికి మీరు ఉపయోగించవచ్చు createNewFile () పద్ధతి. ఈ పద్ధతి తిరిగి వస్తుంది నిజం ఫైల్ విజయవంతంగా సృష్టించబడితే, మరియు తప్పుడు ఫైల్ ఇప్పటికే ఉంటే.

లో ఫైల్‌ను ఎలా సృష్టించాలో ఉదాహరణ చూద్దాం జావా .

ప్యాకేజీ ఫైల్హ్యాండ్లింగ్ // ఫైల్ క్లాస్ దిగుమతి java.io.File // లోపాలను పరిష్కరించడానికి IOException తరగతిని దిగుమతి చేయండి java.io.IOException పబ్లిక్ క్లాస్ క్రియేట్ ఫైల్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {ప్రయత్నించండి {// ఒక ఫైల్ యొక్క వస్తువు myObj = క్రొత్త ఫైల్ ('D: FileHandlingNewFilef1.txt') if (myObj.createNewFile ()) {System.out.println ('ఫైల్ సృష్టించబడింది:' + myObj.getName ())} else {సిస్టమ్. out.println ('ఫైల్ ఇప్పటికే ఉంది.')}} క్యాచ్ (IOException ఇ) {System.out.println ('లోపం సంభవించింది.') e.printStackTrace ()}}}

పై కోడ్‌లో, పేరు పెట్టబడిన ఫైల్ న్యూఫైల్ఫ్ 1 పేర్కొన్న ప్రదేశంలో సృష్టించబడుతుంది. లోపం ఉంటే, అది . పై కోడ్‌ను అమలు చేయడంలో అవుట్‌పుట్‌ను తనిఖీ చేద్దాం:

అవుట్పుట్:

ఫైల్ సృష్టించబడింది: NewFilef1.txt

దీన్ని అర్థం చేసుకున్న తరువాత, ఫైల్ సమాచారాన్ని ఎలా పొందాలో చూద్దాం.

2. ఫైల్ సమాచారం పొందండి

దిగువ ఉదాహరణ కోడ్ సహాయంతో వివిధ పద్ధతులను ఉపయోగించి ఫైల్ సమాచారాన్ని ఎలా పొందాలో చూద్దాం

ప్యాకేజీ ఫైల్హ్యాండ్లింగ్ దిగుమతి java.io.File // ఫైల్ క్లాస్ పబ్లిక్ క్లాస్ ఫైల్ ఇన్ఫర్మేషన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {// ఫైల్ యొక్క వస్తువును సృష్టించడం ఫైల్ myObj = కొత్త ఫైల్ ('NewFilef1.txt') ఉంటే (myObj.exists ()) {// సిస్టమ్ పేరును తిరిగి ఇవ్వడం System.out.println ('ఫైల్ పేరు:' + myObj.getName ()) // ఫైల్ యొక్క మార్గాన్ని తిరిగి ఇస్తుంది System.out.println ('సంపూర్ణ మార్గం: '+ myObj.getAbsolutePath ()) // ఫైల్ వ్రాయగలదా అని ప్రదర్శిస్తుంది System.out.println (' వ్రాయదగినది: '+ myObj.canWrite ()) // ఫైల్ చదవగలిగేదా కాదా అని ప్రదర్శిస్తుంది System.out.println (' చదవగలిగే '+ myObj.canRead ()) // ఫైల్ యొక్క పొడవును బైట్‌లలో తిరిగి ఇస్తుంది System.out.println (' బైట్‌లలో ఫైల్ పరిమాణం '+ myObj.length ())} else {System.out.println (' ఫైల్ ఉనికిలో లేదు.') } } }

మీరు పై ప్రోగ్రామ్‌ను అమలు చేసినప్పుడు, దిగువ అవుట్‌పుట్‌లో చూపిన విధంగా మీరు ఫైల్ సమాచారాన్ని పొందుతారు:

అవుట్పుట్:

ఫైల్ పేరు: NewFilef1.txt సంపూర్ణ మార్గం: D: FileHandlingNewFilef1.txt వ్రాయదగినది: నిజమైన చదవగలిగే నిజమైన ఫైల్ పరిమాణం బైట్లలో 52

నిర్దిష్ట ఫైల్ యొక్క సమాచారాన్ని పొందడానికి మీరు ఈ విధంగా ప్రోగ్రామ్ రాయాలి. ఇప్పుడు మరింత ముందుకు వెళ్దాం మరియు ఫైల్‌లో మరో రెండు ఆపరేషన్లను చూద్దాం. అనగా ఆపరేషన్లను చదవడం మరియు వ్రాయడం.

3. ఒక ఫైల్‌కు వ్రాయండి

కింది ఉదాహరణలో, నేను ఉపయోగించాను ఫైల్ రైటర్ దానితో కలిసి తరగతి వ్రాయడానికి() ఫైల్‌లో కొంత వచనాన్ని వ్రాసే పద్ధతి. కోడ్ సహాయంతో దీన్ని అర్థం చేసుకుందాం.

ప్యాకేజీ ఫైల్‌హ్యాండ్లింగ్ // ఫైల్‌రైటర్ క్లాస్ దిగుమతి java.io.FileWriter // లోపాలను పరిష్కరించడానికి IOException తరగతిని దిగుమతి చేయండి java.io.IOException పబ్లిక్ క్లాస్ రైట్‌టోఫైల్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {ప్రయత్నించండి {ఫైల్ రైటర్ myWriter = new ఫైల్ రైటర్ ('D: FileHandlingNewFilef1.txt') // ఈ కంటెంట్‌ను పేర్కొన్న ఫైల్‌లో myWriter.write (జావా అనేది మిలీనియం యొక్క ప్రముఖ ప్రోగ్రామింగ్ భాష! ') వ్రాస్తుంది // కేటాయించిన వనరులను తిరిగి పొందడానికి మూసివేత అవసరం myWriter.close () System.out.println ('ఫైల్‌కు విజయవంతంగా వ్రాశారు.')} క్యాచ్ (IOException ఇ) {System.out.println ('లోపం సంభవించింది.') E.printStackTrace ()}}}

అవుట్పుట్:

xml మరియు html మధ్య వ్యత్యాసం

విజయవంతంగా ఫైల్‌కు రాశారు

మీరు ఫైల్‌ను అమలు చేస్తున్నప్పుడు, పై వచనం, “ జావా సహస్రాబ్ది యొక్క ప్రముఖ ప్రోగ్రామింగ్ భాష! ”మీరు సృష్టించిన ఫైల్‌లో నమోదు చేయబడుతుంది. పేర్కొన్న ప్రదేశంలో ఫైల్ను తెరవడం ద్వారా మీరు దాన్ని క్రాస్ చెక్ చేయవచ్చు.

ఇప్పుడు మరింత ముందుకు వెళ్లి, ఫైల్‌లోని చివరి ఆపరేషన్‌ను అర్థం చేసుకుందాం, అనగా ఫైల్‌ను చదవండి

4. ఫైల్ నుండి చదవండి

కింది ఉదాహరణలో, టెక్స్ట్ ఫైల్ యొక్క విషయాలను చదవడానికి నేను స్కానర్ తరగతిని ఉపయోగించాను.

ప్యాకేజీ ఫైల్‌హ్యాండ్లింగ్ // ఫైల్ క్లాస్ దిగుమతి java.io.File // లోపాలను పరిష్కరించడానికి ఈ తరగతిని దిగుమతి చేయండి java.io.FileNotFoundException // టెక్స్ట్ ఫైళ్ళను చదవడానికి స్కానర్ క్లాస్‌ను దిగుమతి చేయండి java.util.Scanner పబ్లిక్ క్లాస్ ReadFromFile {పబ్లిక్ స్టాటిక్ void main (స్ట్రింగ్ [] అర్గ్స్) {try {// డేటాను చదవడానికి ఫైల్ యొక్క ఒక వస్తువును సృష్టించడం ఫైల్ myObj = new File ('D: FileHandlingNewFilef1.txt') స్కానర్ myReader = new Scanner (myObj) అయితే (myReader.hasNextLine ()) {స్ట్రింగ్ డేటా = myReader.nextLine () System.out.println (డేటా)} myReader.close ()} క్యాచ్ (FileNotFoundException e) {System.out.println ('లోపం సంభవించింది.') E.printStackTrace ( )}}}

మీరు పై ప్రోగ్రామ్‌ను అమలు చేసినప్పుడు, అది ఇచ్చిన ఫైల్‌లోని కంటెంట్‌ను ప్రదర్శిస్తుంది.

అవుట్పుట్:

జావా సహస్రాబ్ది యొక్క ప్రముఖ ప్రోగ్రామింగ్ భాష!

ఇది ఎలా పనిచేస్తుంది. కాబట్టి, ఇదంతా జావాలోని వివిధ ఫైల్ ఆపరేషన్ల గురించి. దీనితో, మేము జావాలో ఫైల్ హ్యాండ్లింగ్ పై ఈ వ్యాసం చివరకి వచ్చాము. మీరు దానిని సమాచారంగా కనుగొన్నారని నేను ఆశిస్తున్నాను. మీరు మరింత తెలుసుకోవాలనుకుంటే, మీరు మా తనిఖీ చేయవచ్చు అలాగే.

చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. మీ ప్రయాణంలో అడుగడుగునా మీకు సహాయం చేయడానికి మేము ఇక్కడ ఉన్నాము, ఈ జావా ఇంటర్వ్యూ ప్రశ్నలతో పాటుగా, మేము జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించిన ఒక పాఠ్యాంశంతో ముందుకు వచ్చాము.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావాలో ఫైల్ హ్యాండ్లింగ్” వ్యాసంలోని వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.