జావాలో ఫైల్‌ను ఎలా సృష్టించాలి? - ఫైల్ హ్యాండ్లింగ్ కాన్సెప్ట్స్

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

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

• జావా అంటే ఏమిటి?
• జావాలో ప్రోగ్రామ్‌ను అమలు చేయడానికి దశలు
  
• జావాలో ఫైల్ అంటే ఏమిటి?
  
• జావాలో ఫైల్‌ను సృష్టించే పద్ధతులు

ప్రారంభిద్దాం.

జావా అంటే ఏమిటి?

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

జావా అంత ప్రాచుర్యం పొందటానికి అతిపెద్ద కారణం దాని వేదిక స్వాతంత్ర్యం. జావా ఇప్పటికీ సంబంధిత ప్రోగ్రామింగ్ భాష, ఇది జనాదరణ క్షీణించిన సంకేతాలను చూపించదు మరియు అందువల్ల ఇది నేర్చుకోవడం విలువ. చాలా మంది డెవలపర్లు దీన్ని వారి మొదటి ప్రోగ్రామింగ్ భాషగా ఎంచుకుంటారు ఎందుకంటే ఇది నేర్చుకోవడం సులభం.

ఇప్పుడు మరింత ముందుకు వెళ్లి జావా ప్రోగ్రామ్ యొక్క అమలు ప్రవాహాన్ని అర్థం చేసుకుందాం.

జావా ప్రోగ్రామ్ యొక్క అమలు ప్రవాహం

కింది బొమ్మను అమలు చేయడంలో పాల్గొన్నట్లు చూపిస్తుంది :

అన్ని ఉన్నత స్థాయి (మూడవ తరం అని కూడా పిలుస్తారు) ప్రోగ్రామింగ్ భాషలు సహజ భాష కంటే సమానమైన (చాలా సరళమైనవి అయినప్పటికీ) ప్రోగ్రామ్‌లను వ్రాయడానికి మిమ్మల్ని అనుమతిస్తాయి. ఉన్నత-స్థాయి కార్యక్రమాన్ని అంటారు సోర్స్ కోడ్.

దశ 1: సోర్స్ కోడ్ రాయండి.TO కంపైలర్ సోర్స్ లాంగ్వేజ్‌లో వ్రాసిన కంప్యూటర్ కోడ్‌ను లక్ష్య భాషలోకి అనువదించే కంప్యూటర్ ప్రోగ్రామ్.

దశ 2: కంపైల్ సోర్స్ కోడ్‌ను మెషిన్ కోడ్‌లోకి అనువదిస్తుంది.

దశ 3 : జావా ప్రోగ్రామ్ కంపైల్ చేసిన వెంటనే, తదుపరి దశ జావా బైట్‌కోడ్‌ను రూపొందించడం. జావా బైట్‌కోడ్ a రూపంలో మెషిన్ కోడ్ అని కూడా మనం చెప్పగలం .క్లాస్ ఫైల్. అందువల్ల, జావా బైట్‌కోడ్ అనేది జావా ప్రోగ్రామ్ యొక్క సంకలనం యొక్క ఫలితం, ఇది యంత్రం-స్వతంత్రమైన ప్రోగ్రామ్ యొక్క ఇంటర్మీడియట్ ప్రాతినిధ్యం.

దశ 4: అమలు చేయడానికి మీరు దీన్ని యంత్ర భాషగా మార్చాలి. దీని కోసం, మాకు కంపైలర్ మరియు వ్యాఖ్యాత అవసరం. ఒక వ్యాఖ్యాత ఒక సమయంలో ప్రోగ్రామ్‌ను ఒక స్టేట్‌మెంట్‌గా అనువదిస్తుంది. అయితే, ఒక కంపైలర్ మొత్తం ప్రోగ్రామ్‌ను స్కాన్ చేసి, మొత్తంగా మెషిన్ కోడ్‌లోకి అనువదిస్తుంది, కాబట్టి ఇది అన్ని ప్రోగ్రామ్ ఎగ్జిక్యూట్ అయిన తర్వాత లోపాలను ఇస్తుంది, అయితే లైన్ కోడ్ ద్వారా ఇంటర్‌ప్రెటర్ చెక్ లైన్ మరియు మీకు లోపాలను ఇస్తుంది.

జావా ఉదాహరణలో మార్చగల తరగతి

దశ 5: చివరి దశలో కంపైలర్ బైట్‌కోడ్ మొత్తం కోడ్‌ను మెషిన్ కోడ్‌లోకి అనువదిస్తుంది.

జావా యొక్క ప్రాథమిక అంశాలు మీకు ఇప్పుడు తెలుసు, మరింత ముందుకు వెళ్లి జావాలోని ఫైల్ ఏమిటో అర్థం చేసుకుందాం.

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

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

ఇప్పుడు జావాలో ఫైల్‌ను సృష్టించడానికి వివిధ పద్ధతులను అర్థం చేసుకుందాం.

జావాలో ఫైల్‌ను సృష్టించే పద్ధతులు

1. java.io.File Class తో ఫైల్‌ను సృష్టించండి

క్రొత్త ఫైల్‌ను సృష్టించడానికి, మీరు ఉపయోగించాలి File.createNewFile () పద్ధతి. ఈ పద్ధతి బూలియన్ విలువను అందిస్తుంది:

• నిజం ఫైల్ సాధించినట్లయితే.

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

  జావాలో ప్రోగ్రామ్ నుండి నిష్క్రమించండి

ఈ పద్ధతి java.io.IOException ను ఫైల్‌ను సృష్టించలేనప్పుడు విసిరివేస్తుంది.

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

ఇప్పుడు, ఒక చిన్న ఉదాహరణ తీసుకుందాం మరియు ఇది ఎలా పనిచేస్తుందో అర్థం చేసుకుందాం.

ఫైల్ ఫైల్ = క్రొత్త ఫైల్ ('c: //temp//testFile1.txt') // ఫైల్‌ను సృష్టించండి. if (file.createNewFile ()) {System.out.println ('ఫైల్ సృష్టించబడింది!')} else {System.out.println ('ఫైల్ ఇప్పటికే ఉంది.')} // కంటెంట్ రాయండి ఫైల్ రైటర్ రైటర్ = కొత్త ఫైల్ రైటర్ (ఫైల్ ) writer.write ('టెస్ట్ డేటా') writer.close ()

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

2. java.io.FileOutputStream క్లాస్‌తో ఫైల్‌ను సృష్టించండి

మీరు క్రొత్త ఫైల్‌ను సృష్టించాలనుకుంటే, అదే సమయంలో మీరు కొంత డేటాను రాయాలనుకుంటే, మీరు aFileOutputStreamవ్రాసే పద్ధతి.జావాలో, ఫైల్ ut ట్‌పుట్ స్ట్రీమ్ a బైట్ స్ట్రీమ్ తరగతి. డేటాను ఫైల్‌కు వ్రాయడానికి, మీరు డేటాను బైట్‌లుగా మార్చాలి మరియు దానిని ఫైల్‌లో సేవ్ చేయాలి.

ఉదాహరణకి:

స్ట్రింగ్ డేటా = 'టెస్ట్ డేటా' ఫైల్ ut ట్‌పుట్ స్ట్రీమ్ అవుట్ = కొత్త ఫైల్ ut ట్‌పుట్ స్ట్రీమ్ ('సి: //temp//testFile2.txt') out.write (data.getBytes ())out.close ()

ఫైల్ ut ట్‌పుట్ స్ట్రీమ్ క్లాస్ డేటాను వ్యక్తిగత బైట్ల రూపంలో నిల్వ చేస్తుంది. టెక్స్ట్ ఫైళ్ళను సృష్టించడానికి దీనిని ఉపయోగించవచ్చు. హార్డ్ డిస్క్ లేదా సిడి వంటి రెండవ నిల్వ మాధ్యమంలో డేటా నిల్వను ఫైల్ సూచిస్తుంది. FileOutputStream.write () పద్ధతి స్వయంచాలకంగా క్రొత్త ఫైల్‌ను సృష్టించి దానికి కంటెంట్ రాయండి.

3. Java.nio.file.Files - Java NIO తో ఫైల్‌ను సృష్టించండి

Files.write () ఫైల్‌ను సృష్టించడానికి ఉత్తమ మార్గం మరియు మీరు ఇప్పటికే ఉపయోగించకపోతే భవిష్యత్తులో ఇది మీకు ఇష్టమైన విధానం.ఇది మంచి ఎంపిక ఎందుకంటే మేము IO వనరులను మూసివేయడం గురించి ఆందోళన చెందాల్సిన అవసరం లేదు.ప్రతి పంక్తి చార్ సీక్వెన్స్ మరియు ప్లాట్‌ఫాం యొక్క పంక్తి ద్వారా ముగించబడిన ప్రతి పంక్తికి అనుగుణంగా ఫైల్‌కు వ్రాయబడుతుంది సెపరేటర్

విధానం :

పబ్లిక్ స్టాటిక్ పాత్ క్రియేట్ ఫైల్ (పాత్ పాత్, ఫైల్అట్రిబ్యూట్ ... అట్టర్స్) IOException విసురుతుంది

క్రొత్త మరియు ఖాళీ ఫైల్‌ను సృష్టిస్తుంది మరియు ఫైల్ ఇప్పటికే ఉంటే ఇది విఫలమవుతుంది.

పారామితులు:

మార్గం - ఫైల్‌ను సృష్టించే మార్గం.

attrs - ఫైల్‌ను సృష్టించేటప్పుడు అణుపరంగా సెట్ చేయడానికి ఫైల్ లక్షణాల ఐచ్ఛిక జాబితా.

ఉదాహరణకి:

స్ట్రింగ్ డేటా = 'టెస్ట్ డేటా' Files.write (Paths.get ('c: //temp//testFile3.txt') data.getBytes ()) // లేదా జాబితా పంక్తులు = Arrays.asList ('1st line', ' 2 వ పంక్తి ') Files.write (Paths.get (' file6.txt ') పంక్తులు, StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.APPEND)

మీరు దీన్ని ఎలా సృష్టించాలి. తరువాత, తాత్కాలిక ఫైల్ సృష్టిని చూద్దాం.

4. జావా తాత్కాలిక ఫైల్‌ను కూడా సృష్టించగలదు

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

ఉపయోగించి తాత్కాలిక ఫైల్‌ను సృష్టిస్తోంది java.io.File.createTempFile ()

పబ్లిక్ క్లాస్ తాత్కాలిక ఫైల్ ఉదాహరణ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {ప్రయత్నించండి {తుది మార్గం మార్గం = Files.createTempFile ('myTempFile', '. Txt') System.out.println ('టెంప్ ఫైల్:' + మార్గం) // ఉన్న ఫైల్‌ను తొలగించండి. path.toFile (). deleteonExit ()} క్యాచ్ (IOException ఇ) {e.printStackTrace ()}}}

NIO ఉపయోగించి తాత్కాలిక ఫైల్‌ను సృష్టిస్తోంది

పబ్లిక్ క్లాస్ టెంపరరీ ఫైల్ఎక్సాంపుల్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {ఫైల్ టెంప్ ప్రయత్నించండి {temp = File.createTempFile ('myTempFile', '.txt') System.out.println ('టెంప్ ఫైల్ సృష్టించబడింది:' + టెంప్ ())} క్యాచ్ (IOException ఇ) {e.printStackTrace ()}}}

తాత్కాలిక ఫైల్‌ను సృష్టించడానికి, ఈ క్రింది రెండు పద్ధతులు ఉపయోగించబడతాయి.

ఒకటి .createTempFile (మార్గం, స్ట్రింగ్, స్ట్రింగ్, ఫైల్అట్రిబ్యూట్ & హెల్ప్ అట్టర్స్)- పేర్కొన్న డైరెక్టరీలో tmp ఫైల్‌ను సృష్టిస్తుంది.

పై పద్ధతి నాలుగు వాదనలను అంగీకరిస్తుంది.

మార్గం -> ఫైల్ సృష్టించవలసిన డైరెక్టరీని పేర్కొనడానికి.

స్ట్రింగ్ -> ఫైల్ పేరు యొక్క ఉపసర్గను పేర్కొనడానికి. ఉపసర్గను నివారించడానికి శూన్యతను ఉపయోగించండి.

స్ట్రింగ్ -> ఫైల్ పేరు యొక్క ప్రత్యయం పేర్కొనడానికి. అనగా ఫైల్ పొడిగింపు. .Tmp ని పొడిగింపుగా ఉపయోగించడానికి శూన్యతను ఉపయోగించండి.

attrs -> ఫైల్‌ను సృష్టించేటప్పుడు అణుపరంగా సెట్ చేయవలసిన ఫైల్ లక్షణాల జాబితాను పేర్కొనడం ఐచ్ఛికం

ఉదా. Files.createTempFile (మార్గం, శూన్య, శూన్య)- పేర్కొన్న మార్గంలో .tmp పొడిగింపుతో తాత్కాలిక ఫైల్‌ను సృష్టిస్తుంది

2. createTempFile (స్ట్రింగ్, స్ట్రింగ్, ఫైల్అట్రిబ్యూట్)- సిస్టమ్ / సర్వర్ యొక్క డిఫాల్ట్ తాత్కాలిక డైరెక్టరీలో తాత్కాలిక ఫైల్‌ను సృష్టిస్తుంది.

ఉదా: Files.createTempFile (శూన్య, శూన్య) - సిస్టమ్ యొక్క డిఫాల్ట్ టెంప్ ఫోల్డర్‌లో ఒక తాత్కాలిక ఫైల్‌ను సృష్టిస్తుంది. విండోస్‌లో, తాత్కాలిక ఫోల్డర్ ఉండవచ్చు సి: యూజర్‌సెర్నేమ్అప్డేటా లోకల్టెంప్ , ఇక్కడ వినియోగదారు పేరు మీ విండోస్ లాగిన్ ఐడి

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

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

జావాలో పోజో క్లాస్ అంటే ఏమిటి

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