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
వస్తువులు సృష్టించబడతాయి. వంటి కోడ్ ఉపయోగించి మీరు వస్తువును సృష్టించలేరు .Path
new Path()
ఉదాహరణలు:
కోడ్ | గమనిక |
---|---|
|
ఫైల్కి మార్గం |
|
డైరెక్టరీకి మార్గం |
Path
చెల్లుబాటు అయ్యే వస్తువు ఉనికిలో ఉండటానికి ఫైల్ (లేదా డైరెక్టరీ) ఉండవలసిన అవసరం లేదు . బహుశా మీరు ఫైల్ను సృష్టించాలనుకుంటున్నారు... ఒక Path
వస్తువు సూప్-అప్ లాగా ఉంటుంది String
: ఇది డిస్క్లోని నిర్దిష్ట ఫైల్తో ముడిపడి ఉండదు — ఇది డిస్క్లో ఒక నిర్దిష్ట మార్గాన్ని నిల్వ చేస్తుంది. అంతే.
2. Path
రకం యొక్క పద్ధతులు
ఇంటర్ఫేస్ Path
కొన్ని ఆసక్తికరమైన పద్ధతులను కలిగి ఉంది. అత్యంత ఆసక్తికరమైనవి క్రింది పట్టికలో ప్రదర్శించబడ్డాయి.
పద్ధతి | వివరణ |
---|---|
|
పేరెంట్ డైరెక్టరీని అందిస్తుంది |
|
డైరెక్టరీ లేకుండా ఫైల్ పేరును అందిస్తుంది |
|
మార్గం నుండి రూట్ డైరెక్టరీని అందిస్తుంది |
|
ప్రస్తుత మార్గం ఖచ్చితంగా ఉందో లేదో తనిఖీ చేస్తుంది |
|
మార్గాన్ని సంపూర్ణంగా మారుస్తుంది |
|
డైరెక్టరీ పేరులోని వైల్డ్కార్డ్లను తొలగిస్తుంది. |
|
సంపూర్ణ మరియు సాపేక్ష మార్గాల నుండి కొత్త సంపూర్ణ మార్గాన్ని నిర్మిస్తుంది. |
|
రెండు సంపూర్ణ మార్గాల నుండి సాపేక్ష మార్గాన్ని పొందుతుంది. |
|
ప్రస్తుత మార్గం ఇచ్చిన మార్గంతో ప్రారంభమవుతుందో లేదో తనిఖీ చేస్తుంది |
|
ప్రస్తుత మార్గం ఇచ్చిన మార్గంతో ముగుస్తుందో లేదో తనిఖీ చేస్తుంది |
|
/ డీలిమిటర్గా ఉపయోగించి మార్గాన్ని భాగాలుగా విభజిస్తుంది . భాగాల సంఖ్యను అందిస్తుంది. |
|
/ డీలిమిటర్గా ఉపయోగించి మార్గాన్ని భాగాలుగా విభజిస్తుంది . దాని సూచిక ద్వారా కొంత భాగాన్ని అందిస్తుంది. |
|
/ డీలిమిటర్గా ఉపయోగించి మార్గాన్ని భాగాలుగా విభజిస్తుంది . ఇచ్చిన విరామానికి అనుగుణంగా ఉండే సబ్పాత్ను అందిస్తుంది. |
|
Path వస్తువును నిలిపివేయబడిన File వస్తువుగా మారుస్తుంది |
|
వస్తువును Path వస్తువుగా మారుస్తుందిURI |
ఇప్పటికే ఉన్న పద్ధతుల యొక్క క్లుప్త వివరణ క్రింద ఉంది.
3. మార్గాన్ని భాగాలుగా విభజించడం
getParent()
ప్రస్తుత మార్గం కోసం పేరెంట్ డైరెక్టరీకి సూచించే మార్గాన్ని ఈ పద్ధతి అందిస్తుంది. ఈ మార్గం డైరెక్టరీ లేదా ఫైల్ అనే దానితో సంబంధం లేకుండా:
కోడ్ | విలువ |
---|---|
|
|
|
|
|
|
పద్ధతి getFileName()
ఒకే ఫైల్ (లేదా డైరెక్టరీ) పేరును అందిస్తుంది — చివరి డీలిమిటర్ తర్వాత ఏది వచ్చినా:
కోడ్ | విలువ |
---|---|
|
|
|
|
|
|
పద్ధతి getRoot()
రూట్ డైరెక్టరీకి మార్గాన్ని అందిస్తుంది:
కోడ్ | విలువ |
---|---|
|
|
4. సంపూర్ణ మరియు సంబంధిత మార్గాలు
రెండు రకాల మార్గాలు ఉన్నాయి: సంపూర్ణ మరియు సంబంధిత. ఒక సంపూర్ణ మార్గం రూట్ డైరెక్టరీ నుండి ప్రారంభమవుతుంది. Windows కోసం, ఇది ఫోల్డర్ కావచ్చు c:\
; Linux కోసం — /
డైరెక్టరీ
కొన్ని డైరెక్టరీకి సంబంధించి సాపేక్ష మార్గం అర్థవంతంగా ఉంటుంది. అంటే, ఇది రహదారి ముగింపు లాంటిది, కానీ ప్రారంభం లేకుండా. మీరు సాపేక్ష మార్గాన్ని సంపూర్ణ మార్గంగా మార్చవచ్చు మరియు దీనికి విరుద్ధంగా చేయవచ్చు
boolean isAbsolute()
పద్ధతి
ప్రస్తుత మార్గం ఖచ్చితంగా ఉందో లేదో ఈ పద్ధతి తనిఖీ చేస్తుంది
కోడ్ | విలువ |
---|---|
|
|
|
|
Path toAbsolutePath()
పద్ధతి
మార్గాన్ని సంపూర్ణంగా మారుస్తుంది. అవసరమైతే, దానికి ప్రస్తుత వర్కింగ్ డైరెక్టరీని జోడిస్తుంది:
కోడ్ | విలువ |
---|---|
|
|
|
|
Path normalize()
పద్ధతి
మార్గంలో, డైరెక్టరీ పేరుకు బదులుగా, మీరు ".." అని వ్రాయవచ్చు, అంటే ఒక డైరెక్టరీని వెనక్కి వెళ్ళు . సాధారణీకరణ ఈ విషయాలను తొలగిస్తుంది. ఉదాహరణలు:
కోడ్ | విలువ |
---|---|
|
|
|
|
Path relativize(Path other)
పద్ధతి
ఈ relativize()
పద్ధతి "మార్గాల మధ్య వ్యత్యాసాలు" నిర్మించడానికి మిమ్మల్ని అనుమతిస్తుంది: ఒక మార్గం మరొకదానికి సంబంధించి
కోడ్ | విలువ |
---|---|
|
|
|
|
|
చట్టవిరుద్ధమైన వాదన మినహాయింపు: రెండు మార్గాలు వేర్వేరు "రూట్" (వేర్వేరు డిస్క్లు) కలిగి ఉంటాయి |
Path resolve(Path other)
పద్ధతి
పద్ధతి resolve()
దీనికి విరుద్ధంగా చేస్తుంది relativize()
: ఇది సంపూర్ణ మరియు సాపేక్ష మార్గం నుండి కొత్త సంపూర్ణ మార్గాన్ని నిర్మిస్తుంది.
కోడ్ | విలువ |
---|---|
|
|
|
|
toFile()
పద్ధతి
పద్ధతి ఆబ్జెక్ట్ File
వలె అదే ఫైల్ మార్గాన్ని నిల్వ చేసే నిలిపివేయబడిన వస్తువును తిరిగి అందిస్తుంది Path
.
toURI()
పద్ధతి
పద్ధతి పాత్ను ప్రామాణిక URI కి మారుస్తుంది మరియు ఫైల్కి పాత్ను కలిగి ఉన్న వస్తువును అందిస్తుంది:
ఫైల్కి మార్గం | ఫైల్కి URI |
---|---|
|
|
GO TO FULL VERSION