ఫైల్‌లను పరిచయం చేస్తోంది

1. Pathతరగతి

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

జావా యొక్క ప్రారంభ సంస్కరణలు ఫైల్‌లతో పనిచేయడం Fileవంటి తరగతులను ఉపయోగించాయి. FileInputStreamఅయినప్పటికీ, Fileతరగతి ఇప్పుడు నిలిపివేయబడింది మరియు ఉపయోగం కోసం సిఫార్సు చేయబడలేదు. వాస్తవానికి, మీరు దీన్ని ఇప్పటికీ కోడ్, మెథడ్ పారామీటర్‌లు లేదా క్లాస్ కన్‌స్ట్రక్టర్‌లలో ఎదుర్కోవచ్చు.

ప్రారంభం నుండే, క్లాస్‌ని ఉపయోగించి ఫైల్‌లతో ఎలా పని చేయాలో నేర్చుకోవడం ప్రారంభిస్తాము Path. Pathభర్తీ చేసిన తరగతి File. ఇది సురక్షితమైనది మరియు మరింత సమర్థవంతమైనది.

Pathతరగతి

సాంకేతికంగా, Pathతరగతి కాదు - ఇది ఇంటర్‌ఫేస్. ప్రతి ఆపరేటింగ్ సిస్టమ్ (మరియు ఫైల్ సిస్టమ్) కోసం క్లాస్ యొక్క వారసుల రచనను అనుమతించడానికి ఇది జరుగుతుంది Path.

ఫైల్ పాత్‌లను వ్రాయడానికి విండోస్‌కు ఒక ప్రమాణం ఉంది మరియు లైనక్స్‌లో మరొకటి ఉంది. వాస్తవానికి, ప్రపంచంలో అనేక ఇతర ఆపరేటింగ్ సిస్టమ్‌లు ఉన్నాయి మరియు ప్రతి దాని స్వంత ప్రమాణం ఉంది.

అందుకే Pathఫైల్‌లతో పనిచేసే పద్ధతుల్లో ఇంటర్‌ఫేస్ ప్రతిచోటా ఉపయోగించబడుతుంది, అయితే వాస్తవానికి పని దాని సంతతి తరగతుల ద్వారా జరుగుతుంది: WindowsPath, UnixPath, ...

Pathఒక వస్తువును సృష్టించడం

ఒక ఆబ్జెక్ట్‌ను సృష్టించడానికి Path(ఇది వాస్తవానికి వంశపారంపర్య తరగతికి చెందిన వస్తువు అవుతుంది WindowsPath), మీరు ఇలాంటి స్టేట్‌మెంట్‌ను ఉపయోగించాలి:

Path name = Path.of(path);

nameవేరియబుల్ పేరు ఎక్కడ ఉంది Pathమరియు pathఫైల్ (లేదా డైరెక్టరీ) పేరుతో సహా ఫైల్ (లేదా డైరెక్టరీ)కి మార్గం. మరియు ofఇది తరగతి యొక్క స్టాటిక్ పద్ధతి Path.

ప్రోగ్రామ్ విండోస్‌లో రన్ అవుతున్నట్లయితే ఆబ్జెక్ట్‌లను రూపొందించడానికి ఈ of()పద్ధతి ఉపయోగించబడుతుంది . WindowsPathప్రోగ్రామ్ Linuxలో నడుస్తుంటే, UnixPathవస్తువులు సృష్టించబడతాయి. వంటి కోడ్ ఉపయోగించి మీరు వస్తువును సృష్టించలేరు .Pathnew Path()

ఉదాహరణలు:

Path file = Path.of("c:\\projects\\note.txt");

Path directory = Path.of("c:\\projects\\");

Pathచెల్లుబాటు అయ్యే వస్తువు ఉనికిలో ఉండటానికి ఫైల్ (లేదా డైరెక్టరీ) ఉండవలసిన అవసరం లేదు . బహుశా మీరు ఫైల్‌ను సృష్టించాలనుకుంటున్నారు... ఒక Pathవస్తువు సూప్-అప్ లాగా ఉంటుంది String: ఇది డిస్క్‌లోని నిర్దిష్ట ఫైల్‌తో ముడిపడి ఉండదు — ఇది డిస్క్‌లో ఒక నిర్దిష్ట మార్గాన్ని నిల్వ చేస్తుంది. అంతే.

2. Pathరకం యొక్క పద్ధతులు

ఇంటర్ఫేస్ Pathకొన్ని ఆసక్తికరమైన పద్ధతులను కలిగి ఉంది. అత్యంత ఆసక్తికరమైనవి క్రింది పట్టికలో ప్రదర్శించబడ్డాయి.

Path getParent()

Path getFileName()

Path getRoot()

boolean isAbsolute()

Path toAbsolutePath()

Path normalize()

Path resolve(Path other)

Path relativize(Path other)

boolean startsWith(Path other)

boolean endsWith(Path other)

int getNameCount()

Path getName(int index)

Path subpath(int beginIndex, int endIndex)

File toFile()

URI toUri()

ఇప్పటికే ఉన్న పద్ధతుల యొక్క క్లుప్త వివరణ క్రింద ఉంది.

3. మార్గాన్ని భాగాలుగా విభజించడం

getParent()ప్రస్తుత మార్గం కోసం పేరెంట్ డైరెక్టరీకి సూచించే మార్గాన్ని ఈ పద్ధతి అందిస్తుంది. ఈ మార్గం డైరెక్టరీ లేదా ఫైల్ అనే దానితో సంబంధం లేకుండా:

String str = "c:\\windows\\projects\\note.txt";
Path path = Path.of(str).getParent();

"c:\\windows\\projects\\"

String str = "c:\\windows\\projects\\";
Path path = Path.of(str).getParent();

"c:\\windows\\"

String str = "c:\\";
Path path = Path.of(str).getParent();

null

పద్ధతి getFileName()ఒకే ఫైల్ (లేదా డైరెక్టరీ) పేరును అందిస్తుంది — చివరి డీలిమిటర్ తర్వాత ఏది వచ్చినా:

String str = "c:\\windows\\projects\\note.txt";
Path path = Path.of(str).getFileName();

"note.txt"

String str = "c:\\windows\\projects\\";
Path path = Path.of(str).getFileName();

"projects"

String str = "c:\\";
Path path = Path.of(str).getFileName();

null

పద్ధతి getRoot()రూట్ డైరెక్టరీకి మార్గాన్ని అందిస్తుంది:

String str = "c:\\windows\\projects\\";
Path path = Path.of(str).getRoot();

"c:\\"

4. సంపూర్ణ మరియు సంబంధిత మార్గాలు

రెండు రకాల మార్గాలు ఉన్నాయి: సంపూర్ణ మరియు సంబంధిత. ఒక సంపూర్ణ మార్గం రూట్ డైరెక్టరీ నుండి ప్రారంభమవుతుంది. Windows కోసం, ఇది ఫోల్డర్ కావచ్చు c:\; Linux కోసం — /డైరెక్టరీ

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

boolean isAbsolute()పద్ధతి

ప్రస్తుత మార్గం ఖచ్చితంగా ఉందో లేదో ఈ పద్ధతి తనిఖీ చేస్తుంది

String str = "c:\\windows\\projects\\note.txt";
boolean abs = Path.of(str).isAbsolute();

true

String str = "src\\com\\codegym\\Main.java";
boolean abs = Path.of(str).isAbsolute();

false

Path toAbsolutePath()పద్ధతి

మార్గాన్ని సంపూర్ణంగా మారుస్తుంది. అవసరమైతే, దానికి ప్రస్తుత వర్కింగ్ డైరెక్టరీని జోడిస్తుంది:

String str = "c:\\windows\\projects\\note.txt";
Path path = Path.of(str).toAbsolutePath();

"c:\\windows\\projects\\note.txt"

String str = "src\\com\\codegym\\Main.java";
Path path = Path.of(str).toAbsolutePath();

"d:\\work\\src\\com\\codegym\\Main.java"

Path normalize()పద్ధతి

మార్గంలో, డైరెక్టరీ పేరుకు బదులుగా, మీరు ".." అని వ్రాయవచ్చు, అంటే ఒక డైరెక్టరీని వెనక్కి వెళ్ళు . సాధారణీకరణ ఈ విషయాలను తొలగిస్తుంది. ఉదాహరణలు:

String str = "c:\\windows\\..\\projects\\note.txt";
Path path = Path.of(str).normalize();

"c:\\projects\\note.txt"

String str = "src\\com\\codegym\\..\\Main.java";
Path path = Path.of(str).normalize();

"src\\com\\Main.java"

Path relativize(Path other)పద్ధతి

ఈ relativize()పద్ధతి "మార్గాల మధ్య వ్యత్యాసాలు" నిర్మించడానికి మిమ్మల్ని అనుమతిస్తుంది: ఒక మార్గం మరొకదానికి సంబంధించి

Path path1 = Path.of("c:\\windows\\projects\\note.txt");
Path path2 = Path.of("c:\\windows\\");
Path result = path2.relativize(path1);

"projects\\note.txt"

Path path1 = Path.of("c:\\windows\\projects\\note.txt");
Path path2 = Path.of("c:\\windows\\");
Path result = path1.relativize(path2);

"..\\.."

Path path1 = Path.of("c:\\aaa\\bbb\\1.txt");
Path path2 = Path.of("d:\\zzz\\y.jpg");
Path result = path1.relativize(path2);

చట్టవిరుద్ధమైన వాదన మినహాయింపు:
రెండు మార్గాలు వేర్వేరు "రూట్" (వేర్వేరు డిస్క్‌లు) కలిగి ఉంటాయి

Path resolve(Path other)పద్ధతి

పద్ధతి resolve()దీనికి విరుద్ధంగా చేస్తుంది relativize(): ఇది సంపూర్ణ మరియు సాపేక్ష మార్గం నుండి కొత్త సంపూర్ణ మార్గాన్ని నిర్మిస్తుంది.

Path path1 = Path.of("projects\\note.txt");
Path path2 = Path.of("c:\\windows\\");
Path result = path1.resolve(path2);

"c:\\windows"

Path path1 = Path.of("projects\\note.txt");
Path path2 = Path.of("c:\\windows\\");
Path result = path2.resolve(path1);

"c:\\windows\\projects\\note.txt"

toFile()పద్ధతి

పద్ధతి ఆబ్జెక్ట్ Fileవలె అదే ఫైల్ మార్గాన్ని నిల్వ చేసే నిలిపివేయబడిన వస్తువును తిరిగి అందిస్తుంది Path.

toURI()పద్ధతి

పద్ధతి పాత్‌ను ప్రామాణిక URI కి మారుస్తుంది మరియు ఫైల్‌కి పాత్‌ను కలిగి ఉన్న వస్తువును అందిస్తుంది:

c:\windows\projects\note.txt

file:///c:/windows/projects/note.txt