file 타입 - Java로 파일의 파일 확장자를 얻으려면 어떻게해야합니까?




첨부 업로드 (23)

그냥 분명히하기 위해 MIME 유형을 찾고 있지 않습니다.

다음과 같은 입력이 있다고 가정 해 봅시다 : /path/to/file/foo.txt

이 입력을, 특히 .txt 확장자로 나눌 수있는 방법이 필요합니다. Java에서이 작업을 수행 할 수있는 방법이 있습니까? 나는 내 파서를 쓰는 것을 피하고 싶다.


Answers

다른 모든 대답에서 분명히 알 수 있듯이 적절한 "기본 제공"기능은 없습니다. 이것은 안전하고 간단한 방법입니다.

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

이것을 위해 "파서"가 정말로 필요합니까?

String extension = "";

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

당신이 archive.tar.gz 같은 것이 아닌 단순한 Windows와 비슷한 파일 이름을 다루고 있다고 가정합니다.

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

Guava 라이브러리를 사용하는 경우 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

path = "/Users/test/test.txt"

extension = path.substring(path.lastIndexOf("."), path.length());

return ".txt"

"txt"만 원하면 path.lastIndexOf(".") + 1


방법 (Java 1.5 RegEx 사용) :

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

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

이 시도.

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

Java에는 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;

이 정적 메서드는 여기 에있는 사양을 사용하여 다를 수있는 "콘텐츠 형식"을 검색합니다.


파일 이름에서 파일 확장명 가져 오기

/**
 * 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 클래스에서 복사 됨 - 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

여기에서는 작은 메소드를 만들었지 만 (많은 에러에 대해서는 안전하지 않고 검사하지 않습니다), 일반적인 자바 프로그램을 프로그래밍하는 사람 만이 파일 유형을 찾을 정도로 충분합니다. 이것은 복잡한 파일 형식에서는 작동하지 않지만 일반적으로 많이 사용되지는 않습니다.

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

JFileChooser는 어떻습니까? 최종 결과물을 파싱해야하기 때문에 간단하지 않습니다 ...

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

그것은 MIME 형식입니다 ...

OK ... 나는 당신이 그 MIME 타입을 알고 싶지 않다는 것을 잊는다.

다음 링크의 흥미로운 코드 : http://download.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;
}

관련 질문 : Java의 String에서 파일 확장명을 자르는 방법은 무엇입니까?


라이브러리를 사용하지 않으면 다음과 같이 String 메서드 split을 사용할 수 있습니다.

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

        String extension = "";

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

앞에 문자없이 파일 이름을 고려하려면 허용되는 답변의 약간의 변형을 사용해야합니다.

String extension = "";

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

이 경우 Apache Commons IO의 FilenameUtils.getExtension 을 사용하십시오.

다음은이를 사용하는 방법의 예입니다 (전체 경로 또는 파일 이름을 지정할 수 있음).

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

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

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

// Modified from EboMike's answer

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

실행시 확장자에 ".txt"가 있어야합니다.


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

또는 지원되는 null 확장명 :

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에 대한 결과 :
경로 : / root / docs /
이름 : readme
확장 : txt

윈도우의 경우, parsePath ( "c : \ windows \ readme.txt") :
경로 : c : \ windows \
이름 : readme
확장 : txt


Apache commons-io를 사용하고 파일의 확장자를 확인한 다음 일부 작업을 수행하려는 경우 여기에서 사용할 수 있습니다. this 은 스 니펫입니다.

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

위의 모든 답변을 혼합하여 확장 프로그램을 찾는 더 좋은 방법을 찾았습니다.

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

이 특정 질문은 나에게 많은 문제를 준다. 나는이 문제에 대한 아주 간단한 해결책을 발견했다.

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

그게 전부 야.


그냥 정규식 기반 대안. 그렇게 빠르지도 좋지도 않다.

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

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

JVM에서 사용되는 메모리의 양과 사용 가능한 메모리의 양을 알고 싶다면 다음과 같이 해보십시오.

// Get current size of heap in bytes
long heapSize = Runtime.getRuntime().totalMemory();

// Get maximum size of heap in bytes. The heap cannot grow beyond this size.
// Any attempt will result in an OutOfMemoryException.
long heapMaxSize = Runtime.getRuntime().maxMemory();

// Get amount of free memory within the heap in bytes. This size will increase
// after garbage collection and decrease as new objects are created.
long heapFreeSize = Runtime.getRuntime().freeMemory();

편집 : 질문 저자가 "32MB의 메모리를 사용할 때까지 가능한 한 많은 행을 읽는"논리를 갖고 싶다고 말한 데 도움이 될 것이라고 생각했습니다.







java file io