Làm cách nào để có được phần mở rộng tệp của một tệp trong Java?

Nói rõ hơn, tôi không tìm kiếm loại MIME.

Giả sử tôi có đầu vào sau: /path/to/file/foo.txt

Tôi muốn một cách để phá vỡ đầu vào này, đặc biệt là .txtcho phần mở rộng. Có cách xây dựng nào để làm điều này trong Java không? Tôi muốn tránh viết trình phân tích cú pháp của riêng tôi.

Trong trường hợp này, sử dụng FilenameUtils.getExtension từ Apache Commons IO

Dưới đây là một ví dụ về cách sử dụng nó (bạn có thể chỉ định đường dẫn đầy đủ hoặc chỉ tên tệp):

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

Phụ thuộc Maven:

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

Lớp Groovy DSL

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

Lớp DSLlin DSL

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

Những người khác https://search.maven.org/artifact/commons-io/commons-io/2.6/jar

Bạn có thực sự cần một "trình phân tích cú pháp" cho việc này không?

String extension = "";

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

Giả sử rằng bạn đang xử lý các tên tệp đơn giản giống như Windows, không phải như thế archive.tar.gz.

Btw, trong trường hợp thư mục có thể có '.', Nhưng tên tệp không có (như /path/to.a/file), bạn có thể làm

String extension = "";

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

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

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

Nếu bạn sử dụng thư viện Guava , bạn có thể dùng đến Fileslớp tiện ích. Nó có một phương pháp cụ thể getFileExtension(),. Ví dụ:

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

Ngoài ra, bạn cũng có thể có được tên tệp có chức năng tương tự, getNameWithoutExtension () :

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

Nếu trên Android, bạn có thể sử dụng điều này:

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

Để đưa vào tài khoản tên tệp không có ký tự trước dấu chấm, bạn phải sử dụng biến thể nhỏ của câu trả lời được chấp nhận:

String extension = "";

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

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

Đây là một phương pháp đã được thử nghiệm

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();
}

Và trường hợp thử nghiệm:

@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"));
}

Tôi bẩn và có thể tin tưởng nhất khi sử dụng String.replaceAll :

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

Lưu ý rằng đầu tiên *là tham lam vì vậy nó sẽ lấy hầu hết các ký tự có thể càng xa càng tốt và sau đó chỉ là dấu chấm cuối cùng và phần mở rộng tệp sẽ được để lại.

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

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

trả về ".txt"

nếu bạn chỉ muốn "txt", hãy thực hiện path.lastIndexOf(".") + 1

Rõ ràng từ tất cả các câu trả lời khác, không có chức năng "tích hợp" đầy đủ. Đây là một phương pháp an toàn và đơn giản.

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;
}

Còn về (sử dụng Java 1.5 RegEx):

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

Nếu bạn dự định sử dụng Apache commons-io và chỉ muốn kiểm tra phần mở rộng của tệp và sau đó thực hiện một số thao tác, bạn có thể sử dụng điều này , đây là đoạn trích:

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

Đây là một lớp lót khác cho Java 8.

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

Nó hoạt động như sau:

1. Chia chuỗi thành một chuỗi các chuỗi bằng cách sử dụng "."
2. Chuyển đổi mảng thành một luồng
3. Sử dụng less để lấy phần tử cuối cùng của luồng, tức là phần mở rộng tệp

Làm thế nào về JFileChooser? Nó không đơn giản vì bạn sẽ cần phân tích đầu ra cuối cùng của nó ...

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

đó là loại MIME ...

OK ... Tôi quên rằng bạn không muốn biết loại MIME của nó.

Mã thú vị trong liên kết sau: http://doad.oracle.com/javase/tutorial/uiswing/components/filechooser.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;
}

Câu hỏi liên quan: Làm cách nào để cắt bớt phần mở rộng tệp từ Chuỗi trong Java?

Đây là một phương thức xử lý .tar.gzđúng cách, ngay cả trong một đường dẫn có dấu chấm trong tên thư mục:

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được tạo để làm cho việc tìm kiếm afterLastBackslashnhanh hơn vì nó sẽ không phải tìm kiếm toàn bộ chuỗi nếu có một số dấu gạch chéo trong đó.

Bên char[]trong bản gốc Stringđược sử dụng lại, không thêm rác ở đó và JVM có thể sẽ nhận thấy đó afterLastSlashlà rác ngay lập tức để đặt nó vào ngăn xếp thay vì đống .

// Modified from EboMike's answer

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

tiện ích mở rộng nên có ".txt" trong đó khi chạy.

Đây là phiên bản có Tùy chọn là giá trị trả về (vì bạn không thể chắc chắn tệp có phần mở rộng) ... cũng kiểm tra độ tỉnh táo ...

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();
        }
    }
}

Làm thế nào về phiên bản 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));
}

hoặc với phần mở rộng null được hỗ trợ:

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);

kết quả cho * nix:
path: / root / docs /
name: readme
Gia hạn: txt

đối với windows, parsePath ("c: \ windows \ readme.txt"):
path: c: \ windows \
name: readme
Gia hạn: txt

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

Ở đây tôi đã thực hiện một phương thức nhỏ (tuy nhiên không an toàn và không kiểm tra nhiều lỗi), nhưng nếu chỉ có bạn đang lập trình một chương trình java chung, thì điều này là quá đủ để tìm ra kiểu tệp. Điều này không làm việc cho các kiểu tệp phức tạp, nhưng chúng thường không được sử dụng nhiều.

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

Nhận phần mở rộng tệp từ tên tệp

/**
 * 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);
}

Tín dụng

1. Sao chép từ Lớp FileNameUtils của Apache - 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

Không sử dụng bất kỳ thư viện nào, bạn có thể sử dụng phân tách phương thức String như sau:

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

        String extension = "";

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

Chỉ là một thay thế dựa trên biểu thức thông thường. Không nhanh, không tốt.

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

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

Tôi tìm thấy một cách tốt hơn để tìm phần mở rộng bằng cách trộn tất cả các câu trả lời ở trên

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));
    }

Tôi thích sự đơn giản của câu trả lời của quang phổ và được liên kết trong một trong những bình luận của anh ấy là một liên kết đến một câu trả lời khác sửa các dấu chấm trong đường dẫn tệp, trong một câu hỏi khác, do EboMike thực hiện .

Không triển khai một số loại API của bên thứ ba, tôi đề nghị:

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
}

Một cái gì đó như thế này có thể hữu ích trong bất kỳ writephương thức nào của ImageIO , nơi định dạng tệp phải được truyền vào.

Tại sao nên sử dụng toàn bộ API của bên thứ ba khi bạn có thể DIY?

Câu hỏi đặc biệt này đã cho tôi rất nhiều rắc rối sau đó tôi đã tìm thấy một giải pháp rất đơn giản cho vấn đề này mà tôi đang đăng ở đây.

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

Đó là nó.

thử cái này.

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

  @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());
    }

Java có một cách tích hợp để xử lý vấn đề này, trong lớp java.nio.file.Files , có thể hoạt động cho nhu cầu của bạn:

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

Lưu ý rằng phương pháp tĩnh này sử dụng các thông số kỹ thuật được tìm thấy ở đây để truy xuất "loại nội dung", có thể thay đổi.