मुझे जावा में किसी फ़ाइल का फ़ाइल एक्सटेंशन कैसे मिलेगा?

Question

बस स्पष्ट होने के लिए, मुझे MIME प्रकार की तलाश नहीं है।

मान लीजिए कि मेरे पास निम्नलिखित इनपुट हैं: /path/to/file/foo.txt

मैं इस इनपुट को तोड़ने का एक तरीका चाहूंगा, विशेष रूप .txtसे विस्तार के लिए। क्या जावा में ऐसा करने का कोई तरीका है? मैं अपने खुद के पार्सर लिखने से बचना चाहूंगा।

Comments

आप कभी नहीं जानते कि कब कुछ नया प्लेटफॉर्म आने वाला है जो अल्पविराम द्वारा अलग होने के रूप में विस्तार को परिभाषित करता है। अब आपको प्लेटफ़ॉर्म डिपेंडेंट कोड लिखने की ज़रूरत है। जावा फ्रेमवर्क को अधिक आगे की सोच होना चाहिए और एक्सटेंशन प्राप्त करने के लिए एपीआई हैं जहां वे प्लेटफ़ॉर्म निर्भर कोड लिखते हैं और आप, एपीआई के उपयोगकर्ता के रूप में, बस कहते हैं कि एक्सटेंशन प्राप्त करें।

— आर्टऑफवर्फ

@ArtOfWarfare: OMG चलो कई हजारों वर्गों के साथ एक 100MB JRE बनाते हैं, लेकिन कृपया सुनिश्चित करें कि कोई भी विधि लागू न करें जो कि वापस आती "txt"है "filename.txt"क्योंकि कुछ मंच कहीं उपयोग करना चाहते हैं "filename,txt"।

— एरिक डुमिनील

@EricDuminil "किसी भी विधि को लागू नहीं करना सुनिश्चित करें जो" फ़ाइल नाम। Txt "से" txt "लौटाता है ??? कोशिश करो path.substring(path.lastIndexOf("."));..... और हाँ .. वे कुछ भी नहीं के लिए कुछ नकल नहीं कर रहे हैं यकीन है ...

— वेग

ऐसा इसलिए है @VelocityPulse वास्तव में क्या मुझे परेशान। चूंकि फ़ाइल एक्सटेंशन को प्राप्त करने का कोई मानक तरीका नहीं है, इसलिए आपको दर्जनों आधे-गलत उत्तर और थोड़े अलग कार्यान्वयन मिलते हैं। आपका कोड 2 विधियों का उपयोग करता है (मुझे एक सिंगल, स्पष्ट विधि पसंद है ), यह उसी ".txt"से लौटता है "filename.txt", जो वांछित परिणाम नहीं हो सकता है, और सबसे बुरी बात यह है StringIndexOutOfBoundsExceptionकि अगर कोई एक्सटेंशन नहीं है, तो खाली स्ट्रिंग वापस करने के बजाय यह विफल हो जाता है ।

— एरिक डुमिनील

Answer 1

इस स्थिति में, Apache Commons IO से FilenameUtils.getExtension का उपयोग करें

इसका उपयोग कैसे करें (आप पूर्ण पथ या केवल फ़ाइल नाम निर्दिष्ट कर सकते हैं) इसका एक उदाहरण है:

String ext1 = FilenameUtils.getExtension("/path/to/file/foo.txt"); // returns "txt"
String ext2 = FilenameUtils.getExtension("bar.exe"); // returns "exe"

मावेन निर्भरता:

<dependency>
  <groupId>commons-io</groupId>
  <artifactId>commons-io</artifactId>
  <version>2.6</version>
</dependency>

ग्रोले ग्रूवी डी.एस.एल.

implementation 'commons-io:commons-io:2.6'

ग्रेडल कोटलिन डी.एस.एल.

implementation("commons-io:commons-io:2.6")

अन्य https://search.maven.org/artifact/commons-io/commons-io/2.6/jar

Comments

ध्यान दिया जाना चाहिए कि यह आर्काइव.टार.गज़ नामक फ़ाइल के लिए केवल "gz" देता है।

— ज़िट्रैक्स

@Zitrax ऐसा इसलिए है क्योंकि "gz" फाइल एक्सटेंशन है।

— BrainSlugs83

@ BrainSlugs83 तो "टार" का क्या मतलब है?

— TuGordoBello

@zhelon .gz का अर्थ है gnu ज़िप्ड फ़ाइल, और .tar का अर्थ है (t) एप (ar) chive। तो .tar.gz एक gnu ज़िप्ड फ़ाइल के अंदर एक टार फाइल है, जिसमें .gz एक्सटेंशन है।

— cirovladimir

इस सरल कार्य के लिए किसी अन्य पुस्तकालय में लाने का कोई कारण नहीं है।

— मास्टरवॉक

Answer 2

क्या आपको वास्तव में इसके लिए "पार्सर" की आवश्यकता है?

String extension = "";

int i = fileName.lastIndexOf('.');
if (i > 0) {
    extension = fileName.substring(i+1);
}

यह मानते हुए कि आप साधारण विंडोज जैसी फ़ाइल नामों के साथ काम कर रहे हैं, कुछ ऐसा नहीं है archive.tar.gz।

Btw, इस मामले के लिए कि एक निर्देशिका में एक '' हो सकता है, लेकिन फ़ाइल नाम स्वयं (जैसे /path/to.a/file) नहीं है, आप कर सकते हैं

String extension = "";

int i = fileName.lastIndexOf('.');
int p = Math.max(fileName.lastIndexOf('/'), fileName.lastIndexOf('\\'));

if (i > p) {
    extension = fileName.substring(i+1);
}

Comments

धन्यवाद! यकीन है कि आपको इसके लिए एक पार्सर / ऑब्जेक्ट की आवश्यकता हो सकती है, यदि आप केवल विस्तार से अधिक जोड़तोड़ करना चाहते थे ... कहते हैं कि यदि आप सिर्फ पथ चाहते हैं, तो मूल निर्देशिका, फ़ाइल नाम (विस्तार विस्तार), आदि। ' C # और .Net से m आ रहा है जहाँ हमारे पास यह है: msdn.microsoft.com/en-us/library/…

— longda

जैसा कि आप कहते हैं, सोचने के लिए बहुत सारी चीजें हैं, बस भोले-भाले लोगों का उपयोग करने से परे ("।")। मुझे लगता है कि अपाचे कॉमन्स के पास इसके लिए एक तरीका है, जो सभी छोटी मुश्किल संभावित समस्याओं को ध्यान में रखता है।

— MatrixFrog

मुझे लगता है कि i > 0करने के लिए बदला जाना चाहिए i >= 0या i != -1। इस तरह फ़ाइल नाम का ध्यान रखता है .htaccess।

— पीजूस

चाहे कोई भी कोड स्निपेट कितना भी सरल क्यों न हो ... आपको अभी भी इसे अपडेट करने / इसे बनाए रखने / परीक्षण करने / इसे एक सुविधाजनक निर्भरता के रूप में उपलब्ध कराने की आवश्यकता है ... बहुत आसान है अगर पहले से ही उस सभी के लिए एक काम कर रहा है

— डॉन चीडल

अधिक गोच पर यदि फ़ाइल एक बिंदु के साथ समाप्त होती है। एक लिबर में बेहतर। if (i> p && i <(fileName.length () - 1)) {extension = fileName.substring (i + 1);

— tgkprog

Answer 3

private String getFileExtension(File file) {
    String name = file.getName();
    int lastIndexOf = name.lastIndexOf(".");
    if (lastIndexOf == -1) {
        return ""; // empty extension
    }
    return name.substring(lastIndexOf);
}

Comments

ध्यान दिया जाना चाहिए कि यह 'लौटाता है।' साथ ही, इसलिए आपका फ़ाइल एक्सटेंशन कुछ अन्य उत्तरों में 'txt' के विपरीत '। txt' होगा

— NickEntin

बेहतर जवाब और @NickEntin बेहतर टिप्पणी। अवधि निकालने के लिए "।" फ़ाइल के विस्तार से, को अंतिम lastIndexOf = name.lastIndexOf ("।") + 1 के रूप में कोडित किया जा सकता है;

— हनजल्लाह अफ़गन

यह दृष्टिकोण किसी मामले में काम नहीं कर सकता है जैसे /usr/bin/foo.bar/httpconf

— ईमान अकबरी

@ lukasz1985 1. सैकड़ों लिनक्स पैकेज "init.d" जैसे नामों से निर्देशिकाएं बनाते हैं, इसके अलावा, डॉट्स के साथ निर्देशिकाओं के न होने के मार्ग पर भरोसा करना सुरक्षित नहीं है, क्योंकि यह अवैध नहीं है। मैं एंड्रॉइड के लिए कोडिंग कर रहा था इसलिए मैंने अपने एसडीके का उपयोग किया विधि मुझे याद नहीं है लेकिन मुझे लगता है कि stackoverflow.com/a/3571239/2546146 में यह दोष नहीं है

— इमान अकबरी

@ इमान अकबरी: getName () केवल फ़ाइल नाम ही वापस करता है, जो आपके उदाहरण में "httpconf" होगा।

— ड्रीम्सस्पेस के अध्यक्ष

Answer 4

यदि आप अमरूद पुस्तकालय का उपयोग करते हैं , तो आप Filesउपयोगिता वर्ग का सहारा ले सकते हैं । यह एक विशिष्ट विधि है, getFileExtension()। उदाहरण के लिए:

String path = "c:/path/to/file/foo.txt";
String ext = Files.getFileExtension(path);
System.out.println(ext); //prints txt

इसके अलावा आप एक समान फ़ंक्शन के साथ फ़ाइल नाम भी प्राप्त कर सकते हैं, getNameWithoutExtension () :

String filename = Files.getNameWithoutExtension(path);
System.out.println(filename); //prints foo

Comments

वास्तव में? यह एक महान पुस्तकालय है, उपयोगिताओं से भरा है। उनमें से ज्यादातर जावा 8 का हिस्सा होंगे, जैसे शानदार अमरूद फंक्शन ।

— जीनलजेन

सभी लोग यह तय नहीं कर सकते कि कौन से पुस्तकालय का उपयोग करना है, दुर्भाग्य से। कम से कम हमारे पास अपाचे कॉमन्स हैं, भले ही वह एक पुराना हो।

— लूलिस मार्टिनेज

यदि आप getFileExtensionवास्तव में स्रोत कोड देखते हैं int dotIndex = fileName.lastIndexOf('.'); return (dotIndex == -1) ? "" : fileName.substring(dotIndex + 1)तो यह बहुत बड़ी बात नहीं है। यह भी ध्यान दें कि Filesकिसी कारण से "अस्थिर" के रूप में चिह्नित किया गया है।

— अल-मोताफ़र

@ अल-मोताफ़र बहुत सारी कक्षाएं अस्थिर के रूप में चिह्नित की जाती हैं (मल्टीमप बिल्डरों को देखें), मुझे यह भी समझ में नहीं आता है: कई रिलीज़ किए गए हैं, लेकिन वहां कुछ भी नहीं बदला गया है।

— जीनलजेन

Answer 5

यदि Android पर, आप इसका उपयोग कर सकते हैं:

String ext = android.webkit.MimeTypeMap.getFileExtensionFromUrl(file.getName());

Comments

ध्यान दें कि यह काम नहीं करेगा यदि स्ट्रिंग एन्कोडेड नहीं है (जैसे कि कोई स्थान या एक चीनी वर्ण है), देखें: stackoverflow.com/a/14321470/1074998

— फलों का

Answer 6

बिंदु से पहले वर्णों के बिना खाता नाम लेने के लिए , आपको स्वीकृत उत्तर के उस थोड़े बदलाव का उपयोग करना होगा:

String extension = "";

int i = fileName.lastIndexOf('.');
if (i >= 0) {
    extension = fileName.substring(i+1);
}

---

"file.doc" => "doc"
"file.doc.gz" => "gz"
".doc" => "doc"

Comments

शायद "फू" के खिलाफ खुद का बचाव करना चाहिए। इनपुट।

— क्रिस्मसटाउन

Answer 7

यह एक परीक्षित विधि है

public static String getExtension(String fileName) {
    char ch;
    int len;
    if(fileName==null || 
            (len = fileName.length())==0 || 
            (ch = fileName.charAt(len-1))=='/' || ch=='\\' || //in the case of a directory
             ch=='.' ) //in the case of . or ..
        return "";
    int dotInd = fileName.lastIndexOf('.'),
        sepInd = Math.max(fileName.lastIndexOf('/'), fileName.lastIndexOf('\\'));
    if( dotInd<=sepInd )
        return "";
    else
        return fileName.substring(dotInd+1).toLowerCase();
}

और परीक्षण के मामले:

@Test
public void testGetExtension() {
    assertEquals("", getExtension("C"));
    assertEquals("ext", getExtension("C.ext"));
    assertEquals("ext", getExtension("A/B/C.ext"));
    assertEquals("", getExtension("A/B/C.ext/"));
    assertEquals("", getExtension("A/B/C.ext/.."));
    assertEquals("bin", getExtension("A/B/C.bin"));
    assertEquals("hidden", getExtension(".hidden"));
    assertEquals("dsstore", getExtension("/user/home/.dsstore"));
    assertEquals("", getExtension(".strange."));
    assertEquals("3", getExtension("1.2.3"));
    assertEquals("exe", getExtension("C:\\Program Files (x86)\\java\\bin\\javaw.exe"));
}

Answer 8

String.replaceAll का उपयोग करके मेरा गंदा और सबसे नन्हा :

.replaceAll("^.*\\.(.*)$", "$1")

ध्यान दें कि पहले *लालची है इसलिए यह जहाँ तक संभव हो सबसे अधिक वर्णों को हड़प लेगा और फिर अंतिम बिंदु और फ़ाइल एक्सटेंशन को छोड़ दिया जाएगा।

Comments

यदि फ़ाइल का कोई एक्सटेंशन नहीं है, तो यह विफल हो जाता है।

— ज़ैक

हां, दुर्भाग्य से, हालांकि अभी भी सरल परिदृश्यों के लिए उपयोग किया जा सकता है जैसे कि त्वरित फ़ाइल प्रकार का पता लगाना और जैसे कि एक गलत एक्सटेंशन होने से कोई भी अलग नहीं है, या इनपुट के साथ बराबरी का परिणाम होने पर कोई भी एक शर्त रख सकता है।

— अब्राहिम बयागोवी

या उससे भी छोटा.replaceAll(".*\\.", "")

— अब्राहिम बयागोवी

Answer 9

String path = "/Users/test/test.txt";
String extension = "";

if (path.contains("."))
     extension = path.substring(path.lastIndexOf("."));

वापसी ".txt"

यदि आप केवल "txt" चाहते हैं, तो बनाएं path.lastIndexOf(".") + 1

Answer 10

जैसा कि सभी अन्य उत्तरों से स्पष्ट है, कोई पर्याप्त "अंतर्निहित" फ़ंक्शन नहीं है। यह एक सुरक्षित और सरल विधि है।

String getFileExtension(File file) {
    if (file == null) {
        return "";
    }
    String name = file.getName();
    int i = name.lastIndexOf('.');
    String ext = i > 0 ? name.substring(i + 1) : "";
    return ext;
}

Answer 11

कैसे के बारे में (जावा 1.5 RegEx का उपयोग करके):

    String[] split = fullFileName.split("\\.");
    String ext = split[split.length - 1];

Answer 12

आप अपाचे कॉमन्स-कब उपयोग करने के लिए, और सिर्फ फ़ाइल का विस्तार जाँच करना चाहते हैं और फिर कुछ आपरेशन करना चाहते हैं, तो आप उपयोग कर सकते हैं इस के लिए, यहाँ एक टुकड़ा है:

if(FilenameUtils.isExtension(file.getName(),"java")) {
    someoperation();
}

Comments

ध्यान दें कि यह चेक डॉक्स के अनुसार संवेदनशील है।

— बबकेन वर्दयान 11

Answer 13

यहाँ जावा 8 के लिए एक और वन-लाइनर है।

String ext = Arrays.stream(fileName.split("\\.")).reduce((a,b) -> b).orElse(null)

यह निम्नानुसार काम करता है:

1. स्ट्रिंग को "" "का उपयोग करके स्ट्रिंग के एक सरणी में विभाजित करें।
2. सरणी को एक स्ट्रीम में बदलें
3. धारा का अंतिम तत्व, यानी फ़ाइल एक्सटेंशन प्राप्त करने के लिए कम का उपयोग करें

Answer 14

JFileChooser के बारे में कैसे? यह सीधा नहीं है क्योंकि आपको इसके अंतिम आउटपुट को पार्स करने की आवश्यकता होगी ...

JFileChooser filechooser = new JFileChooser();
File file = new File("your.txt");
System.out.println("the extension type:"+filechooser.getTypeDescription(file));

जो MIME प्रकार है ...

ठीक है ... मैं भूल गया कि आप इसके MIME प्रकार को जानना नहीं चाहते हैं।

निम्नलिखित लिंक में दिलचस्प कोड: http://download.oracle.com/javase/tutorial/uiswing/compenders/filechozer.html

/*
 * Get the extension of a file.
 */  
public static String getExtension(File f) {
    String ext = null;
    String s = f.getName();
    int i = s.lastIndexOf('.');

    if (i > 0 &&  i < s.length() - 1) {
        ext = s.substring(i+1).toLowerCase();
    }
    return ext;
}

संबंधित प्रश्न: मैं जावा में स्ट्रिंग से फ़ाइल एक्सटेंशन कैसे ट्रिम कर सकता हूं?

Answer 15

यहां एक विधि है जो ठीक .tar.gzसे संभालती है, यहां तक ​​कि निर्देशिका नामों में डॉट्स के साथ एक पथ में:

private static final String getExtension(final String filename) {
  if (filename == null) return null;
  final String afterLastSlash = filename.substring(filename.lastIndexOf('/') + 1);
  final int afterLastBackslash = afterLastSlash.lastIndexOf('\\') + 1;
  final int dotIndex = afterLastSlash.indexOf('.', afterLastBackslash);
  return (dotIndex == -1) ? "" : afterLastSlash.substring(dotIndex + 1);
}

afterLastSlashयह afterLastBackslashजल्दी से खोजने के लिए बनाया गया है क्योंकि इसमें कुछ स्लैश होने पर पूरे स्ट्रिंग को खोजना नहीं होगा।

char[]मूल के अंदर Stringपुन: उपयोग किया जाता है, वहाँ कोई कचरा जोड़ने, और JVM शायद नोटिस कि afterLastSlashक्रम में तुरंत कचरा है ढेर के बजाय ढेर पर डाल करने के लिए ।

Comments

इस विधि को अमरूद स्रोत कोड से कॉपी किया गया है जिसका आपको यह उल्लेख करना होगा।

— 19

मैंने इसकी नकल नहीं की। यदि यह अमरूद स्रोत कोड में है, तो उन्होंने इसे यहाँ से कॉपी किया। शायद उन्हें सूचित करें।

— ओलथे

इसके लिए खेद है कि यह समान btw नहीं है, इसलिए आप और अमरूद देव बस एक ही विचार कर सकते हैं।

— humazed

वास्तव में "gz" वापसी का सही विस्तार है। यदि कॉलिंग कोड "टार" को भी संभाल सकता है तो इसे अतिरिक्त रूप से जांचना चाहिए, जो एक getExtensionफ़ंक्शन के लिए बाहरी है । यदि उपयोगकर्ता का फ़ाइल नाम है, "my zip. don't touch.tar.gz"तो यह विधि गलत एक्सटेंशन वापस कर देगी।

— इंट्रेपिडिस

Answer 16

// Modified from EboMike's answer

String extension = "/path/to/file/foo.txt".substring("/path/to/file/foo.txt".lastIndexOf('.'));

विस्तार में ".txt" होना चाहिए जब इसे चलाया जाए।

Comments

यदि नाम में एक्सटेंशन नहीं है तो क्रैश हो जाएगा।

— EboMike

Answer 17

वैकल्पिक मान के साथ संस्करण यहां लौटाए गए मान के कारण है (क्योंकि आपको यकीन नहीं हो सकता है कि फ़ाइल का विस्तार है) ... यह भी पवित्रता की जाँच करता है ...

import java.io.File;
import java.util.Optional;

public class GetFileExtensionTool {

    public static Optional<String> getFileExtension(File file) {
        if (file == null) {
            throw new NullPointerException("file argument was null");
        }
        if (!file.isFile()) {
            throw new IllegalArgumentException("getFileExtension(File file)"
                    + " called on File object that wasn't an actual file"
                    + " (perhaps a directory or device?). file had path: "
                    + file.getAbsolutePath());
        }
        String fileName = file.getName();
        int i = fileName.lastIndexOf('.');
        if (i > 0) {
            return Optional.of(fileName.substring(i + 1));
        } else {
            return Optional.empty();
        }
    }
}

Answer 18

REGEX संस्करण के बारे में कैसे :

static final Pattern PATTERN = Pattern.compile("(.*)\\.(.*)");

Matcher m = PATTERN.matcher(path);
if (m.find()) {
    System.out.println("File path/name: " + m.group(1));
    System.out.println("Extention: " + m.group(2));
}

या अशक्त विस्तार के साथ समर्थित:

static final Pattern PATTERN =
    Pattern.compile("((.*\\" + File.separator + ")?(.*)(\\.(.*)))|(.*\\" + File.separator + ")?(.*)");

class Separated {
    String path, name, ext;
}

Separated parsePath(String path) {
    Separated res = new Separated();
    Matcher m = PATTERN.matcher(path);
    if (m.find()) {
        if (m.group(1) != null) {
            res.path = m.group(2);
            res.name = m.group(3);
            res.ext = m.group(5);
        } else {
            res.path = m.group(6);
            res.name = m.group(7);
        }
    }
    return res;
}


Separated sp = parsePath("/root/docs/readme.txt");
System.out.println("path: " + sp.path);
System.out.println("name: " + sp.name);
System.out.println("Extention: " + sp.ext);

परिणाम के लिए * nix:
पथ: / रूट / डॉक्स /
नाम: readme
एक्सटेंशन: txt

विंडोज़ के लिए, parsePath ("c: \ windows \ readme.txt"):
पथ: c: \ windows \
name: readme
एक्सटेंशन: txt

Answer 19

String extension = com.google.common.io.Files.getFileExtension("fileName.jpg");

Answer 20

यहाँ मैंने एक छोटा सा तरीका बनाया (हालाँकि वह सुरक्षित नहीं है और कई त्रुटियों के लिए जाँच नहीं करता है), लेकिन अगर यह केवल आप ही हैं जो एक सामान्य जावा-प्रोग्राम की प्रोग्रामिंग कर रहे हैं, तो यह फ़िलाटाइप खोजने के लिए पर्याप्त से अधिक है। यह जटिल तंतुओं के लिए काम नहीं कर रहा है, लेकिन आमतौर पर इनका उपयोग उतना नहीं किया जाता है।

    public static String getFileType(String path){
       String fileType = null;
       fileType = path.substring(path.indexOf('.',path.lastIndexOf('/'))+1).toUpperCase();
       return fileType;
}

Comments

ओपी निर्मित विधि की तलाश में है

— पैंथर

(1) आपको lastIndexOfऐसे फ़ाइल नामों का उपयोग करना चाहिए जैसे john.smith.report.docठीक से व्यवहार किए जाते हैं। (2) विस्तार न होने पर आपको मामलों को ठीक से संभालना चाहिए। यह विधि ABC/XYZएक ऐसे मार्ग के लिए लौटती है abc/xyz, जिसका कोई मतलब नहीं है। यह वापसी ""या करने के लिए अधिक समझ में आता है null। (3) फ़ाइल विभाजक हमेशा नहीं होता है /।

— रेडियोडेफ़

Answer 21

फ़ाइल नाम से फ़ाइल एक्सटेंशन प्राप्त करना

/**
 * The extension separator character.
 */
private static final char EXTENSION_SEPARATOR = '.';

/**
 * The Unix separator character.
 */
private static final char UNIX_SEPARATOR = '/';

/**
 * The Windows separator character.
 */
private static final char WINDOWS_SEPARATOR = '\\';

/**
 * The system separator character.
 */
private static final char SYSTEM_SEPARATOR = File.separatorChar;

/**
 * Gets the extension of a filename.
 * <p>
 * This method returns the textual part of the filename after the last dot.
 * There must be no directory separator after the dot.
 * <pre>
 * foo.txt      --> "txt"
 * a/b/c.jpg    --> "jpg"
 * a/b.txt/c    --> ""
 * a/b/c        --> ""
 * </pre>
 * <p>
 * The output will be the same irrespective of the machine that the code is running on.
 *
 * @param filename the filename to retrieve the extension of.
 * @return the extension of the file or an empty string if none exists.
 */
public static String getExtension(String filename) {
    if (filename == null) {
        return null;
    }
    int index = indexOfExtension(filename);
    if (index == -1) {
        return "";
    } else {
        return filename.substring(index + 1);
    }
}

/**
 * Returns the index of the last extension separator character, which is a dot.
 * <p>
 * This method also checks that there is no directory separator after the last dot.
 * To do this it uses {@link #indexOfLastSeparator(String)} which will
 * handle a file in either Unix or Windows format.
 * <p>
 * The output will be the same irrespective of the machine that the code is running on.
 *
 * @param filename  the filename to find the last path separator in, null returns -1
 * @return the index of the last separator character, or -1 if there
 * is no such character
 */
public static int indexOfExtension(String filename) {
    if (filename == null) {
        return -1;
    }
    int extensionPos = filename.lastIndexOf(EXTENSION_SEPARATOR);
    int lastSeparator = indexOfLastSeparator(filename);
    return (lastSeparator > extensionPos ? -1 : extensionPos);
}

/**
 * Returns the index of the last directory separator character.
 * <p>
 * This method will handle a file in either Unix or Windows format.
 * The position of the last forward or backslash is returned.
 * <p>
 * The output will be the same irrespective of the machine that the code is running on.
 *
 * @param filename  the filename to find the last path separator in, null returns -1
 * @return the index of the last separator character, or -1 if there
 * is no such character
 */
public static int indexOfLastSeparator(String filename) {
    if (filename == null) {
        return -1;
    }
    int lastUnixPos = filename.lastIndexOf(UNIX_SEPARATOR);
    int lastWindowsPos = filename.lastIndexOf(WINDOWS_SEPARATOR);
    return Math.max(lastUnixPos, lastWindowsPos);
}

क्रेडिट

1. Apache FileNameUtils Class से कॉपी की गई - http://grepcode.com/file/repo1.maven.org/maven2/commons-io/commons-io/1.3.2/org/apache/commons/io/FilenameUtils.java#FilenameUtils। getExtension% 28java.lang.String% 29

Answer 22

किसी भी पुस्तकालय का उपयोग किए बिना, आप स्ट्रिंग विधि को निम्नानुसार विभाजित कर सकते हैं:

        String[] splits = fileNames.get(i).split("\\.");

        String extension = "";

        if(splits.length >= 2)
        {
            extension = splits[splits.length-1];
        }

Answer 23

बस एक नियमित अभिव्यक्ति आधारित विकल्प। वह उपवास नहीं, वह अच्छा नहीं।

Pattern pattern = Pattern.compile("\\.([^.]*)$");
Matcher matcher = pattern.matcher(fileName);

if (matcher.find()) {
    String ext = matcher.group(1);
}

Answer 24

मुझे उपरोक्त सभी उत्तरों को मिलाकर विस्तार खोजने का एक बेहतर तरीका मिला

public static String getFileExtension(String fileLink) {

        String extension;
        Uri uri = Uri.parse(fileLink);
        String scheme = uri.getScheme();
        if (scheme != null && scheme.equals(ContentResolver.SCHEME_CONTENT)) {
            MimeTypeMap mime = MimeTypeMap.getSingleton();
            extension = mime.getExtensionFromMimeType(CoreApp.getInstance().getContentResolver().getType(uri));
        } else {
            extension = MimeTypeMap.getFileExtensionFromUrl(fileLink);
        }

        return extension;
    }

public static String getMimeType(String fileLink) {
        String type = CoreApp.getInstance().getContentResolver().getType(Uri.parse(fileLink));
        if (!TextUtils.isEmpty(type)) return type;
        MimeTypeMap mime = MimeTypeMap.getSingleton();
        return mime.getMimeTypeFromExtension(FileChooserUtil.getFileExtension(fileLink));
    }

Answer 25

मुझे स्पेक्ट्रे के उत्तर की सादगी पसंद है , और उनकी टिप्पणियों में से एक लिंक किसी अन्य उत्तर की लिंक है जो फ़ाइल पथों में डॉट्स को ठीक करता है, एक अन्य प्रश्न पर, इबोमाइक द्वारा बनाया गया ।

तीसरे पक्ष एपीआई के कुछ प्रकार को लागू किए बिना, मेरा सुझाव है:

private String getFileExtension(File file) {

    String name = file.getName().substring(Math.max(file.getName().lastIndexOf('/'),
            file.getName().lastIndexOf('\\')) < 0 ? 0 : Math.max(file.getName().lastIndexOf('/'),
            file.getName().lastIndexOf('\\')));
    int lastIndexOf = name.lastIndexOf(".");
    if (lastIndexOf == -1) {
        return ""; // empty extension
    }
    return name.substring(lastIndexOf + 1); // doesn't return "." with extension
}

कुछ इस तरह से उपयोगी हो सकता है, कहते हैं, ImageIO के किसी भी writeतरीके , जहां फ़ाइल प्रारूप में पारित किया जाना है।

जब आप DIY कर सकते हैं तो पूरे तृतीय पक्ष एपीआई का उपयोग क्यों करें?

Answer 26

इस विशेष प्रश्न ने मुझे बहुत परेशानी दी फिर मुझे इस समस्या का एक बहुत ही सरल समाधान मिला, जो मैं यहाँ पोस्ट कर रहा हूँ।

file.getName().toLowerCase().endsWith(".txt");

बस।

Comments

ओपी को एक्सटेंशन निकालने का एक तरीका चाहिए - एक का परीक्षण करने के लिए नहीं।

— प्रेड्रैग मनोजोविच

वास्तव में जो कुछ भी आप ज्यादातर मामले में विकसित कर रहे हैं, आपको केवल एक विशेष प्रकार की फाइलों से निपटने की आवश्यकता है..तो यदि आपकी समस्या इस क्षेत्र में आती है तो यह आपकी मदद करेगा।

— विक्रम भारद्वाज

जो अपनी आवश्यकताओं को संबोधित नहीं करता है

— प्रेड्रैज मनोजलोविच

यह सवाल का जवाब नहीं है, लेकिन यह वास्तव में मैं क्या देख रहा था।

— 20

Answer 27

इसे इस्तेमाल करे।

String[] extension = "adadad.adad.adnandad.jpg".split("\\.(?=[^\\.]+$)"); // ['adadad.adad.adnandad','jpg']
extension[1] // jpg

Answer 28

  @Test
    public void getFileExtension(String fileName){
      String extension = null;
      List<String> list = new ArrayList<>();
      do{
          extension =  FilenameUtils.getExtension(fileName);
          if(extension==null){
              break;
          }
          if(!extension.isEmpty()){
              list.add("."+extension);
          }
          fileName = FilenameUtils.getBaseName(fileName);
      }while (!extension.isEmpty());
      Collections.reverse(list);
      System.out.println(list.toString());
    }

Answer 29

जावा में java.nio.file.Files वर्ग के साथ इससे निपटने का एक अंतर्निहित तरीका है , जो आपकी आवश्यकताओं के लिए काम कर सकता है:

File f = new File("/path/to/file/foo.txt");
String ext = Files.probeContentType(f.toPath());
if(ext.equalsIgnoreCase("txt")) do whatever;

ध्यान दें कि यह स्थिर विधि "सामग्री प्रकार," को पुनः प्राप्त करने के लिए यहां पाई गई विशिष्टताओं का उपयोग करती है , जो भिन्न हो सकती हैं।

Comments

यह गलत है। जांच के लिए वापसी प्रकारContentType माइम सामग्री प्रकार है, न कि फ़ाइल एक्सटेंशन। यह आमतौर पर विस्तार से मेल नहीं खाता। यह फ़ाइल ब्राउज़र में भी काफी धीमा होगा, क्योंकि यह वास्तव में टाइप को निर्धारित करने के लिए फाइल को खोलता है।

— चार्ल्स