Java: dividir el nombre del archivo en una base y una extensión

¿Hay una mejor manera de obtener el nombre de base y la extensión del archivo que algo como

File f = ...
String name = f.getName();
int dot = name.lastIndexOf('.');
String base = (dot == -1) ? name : name.substring(0, dot);
String extension = (dot == -1) ? "" : name.substring(dot+1);

Sé que otros han mencionado String.split, pero aquí hay una variante que solo produce dos tokens (la base y la extensión):

String[] tokens = fileName.split("\\.(?=[^\\.]+$)");

Por ejemplo:

"test.cool.awesome.txt".split("\\.(?=[^\\.]+$)");

Rendimientos:

["test.cool.awesome", "txt"]

La expresión regular le dice a Java que se divida en cualquier período seguido por cualquier número de no períodos, seguido del final de la entrada. Solo hay un período que coincide con esta definición (a saber, el último período).

Técnicamente hablando con expresiones regulares, esta técnica se denomina anticipación positiva de ancho cero .

Por cierto, si desea dividir una ruta y obtener el nombre de archivo completo, incluida, entre otras, la extensión de punto, utilizando una ruta con barras diagonales,

    String[] tokens = dir.split(".+?/(?=[^/]+$)");

Por ejemplo:

    String dir = "/foo/bar/bam/boozled"; 
    String[] tokens = dir.split(".+?/(?=[^/]+$)");
    // [ "/foo/bar/bam/" "boozled" ] 

Antigua pregunta pero suelo usar esta solución:

import org.apache.commons.io.FilenameUtils;

String fileName = "/abc/defg/file.txt";

String basename = FilenameUtils.getBaseName(fileName);
String extension = FilenameUtils.getExtension(fileName);
System.out.println(basename); // file
System.out.println(extension); // txt (NOT ".txt" !)

Fuente: http://www.java2s.com/Code/Java/File-Input-Output/Getextensionpathandfilename.htm

tal clase de utilidad:

class Filename {
  private String fullPath;
  private char pathSeparator, extensionSeparator;

  public Filename(String str, char sep, char ext) {
    fullPath = str;
    pathSeparator = sep;
    extensionSeparator = ext;
  }

  public String extension() {
    int dot = fullPath.lastIndexOf(extensionSeparator);
    return fullPath.substring(dot + 1);
  }

  public String filename() { // gets filename without extension
    int dot = fullPath.lastIndexOf(extensionSeparator);
    int sep = fullPath.lastIndexOf(pathSeparator);
    return fullPath.substring(sep + 1, dot);
  }

  public String path() {
    int sep = fullPath.lastIndexOf(pathSeparator);
    return fullPath.substring(0, sep);
  }
}

uso:

public class FilenameDemo {
  public static void main(String[] args) {
    final String FPATH = "/home/mem/index.html";
    Filename myHomePage = new Filename(FPATH, '/', '.');
    System.out.println("Extension = " + myHomePage.extension());
    System.out.println("Filename = " + myHomePage.filename());
    System.out.println("Path = " + myHomePage.path());
  }
}

http://docs.oracle.com/javase/6/docs/api/java/io/File.html#getName ()

De http://www.xinotes.org/notes/note/774/ :

Java tiene funciones integradas para obtener el nombre base y el nombre del directorio para una ruta de archivo determinada, pero los nombres de las funciones no son tan evidentes.

import java.io.File;

public class JavaFileDirNameBaseName {
    public static void main(String[] args) {
    File theFile = new File("../foo/bar/baz.txt");
    System.out.println("Dirname: " + theFile.getParent());
    System.out.println("Basename: " + theFile.getName());
    }
}

Las extensiones de archivo son un concepto roto

Y no existe una función confiable para ello. Considere, por ejemplo, este nombre de archivo:

archive.tar.gz

¿Qué es la extensión? Los usuarios de DOS hubieran preferido el nombre archive.tgz. A veces ves aplicaciones de Windows estúpidas que primero descomprimen el archivo (produciendo un .tararchivo), luego tienes que abrirlo nuevamente para ver el contenido del archivo.

En este caso, una noción más razonable de extensión de archivo habría sido .tar.gz. También hay .tar.bz2, .tar.xz, .tar.lzy .tar.lzma"Extensiones" Archivo en uso. Pero, ¿cómo decidiría si dividir en el último punto o en el penúltimo punto?

En su lugar, utilice tipos de mímica.

La función Files.probeContentType de Java 7 probablemente será mucho más confiable para detectar tipos de archivos que confiar en la extensión del archivo. Prácticamente todo el mundo Unix / Linux, así como su navegador web y su teléfono inteligente, ya lo hacen de esta manera.

¿Qué pasa con tu código? Envuelto en un método de utilidad ordenado, está bien.

Lo que es más importante es qué usar como separador: el primer o el último punto. El primero es malo para nombres de archivo como "setup-2.5.1.exe", el último es malo para nombres de archivo con múltiples extensiones como "mybundle.tar.gz".

También puede utilizar Java Regular Expression. String.split () también usa la expresión internamente. Consulte http://download.oracle.com/javase/1.4.2/docs/api/java/util/regex/Pattern.html

Quizás podrías usar String # split

Para responder a su comentario:

No estoy seguro de si puede haber más de uno. en un nombre de archivo, pero lo que sea, incluso si hay más puntos, puede usar la división. Considere, por ejemplo, que:

String input = "boo.and.foo";

String[] result = input.split(".");

Esto devolverá una matriz que contiene:

{ "boo", "and", "foo" }

Entonces sabrá que el último índice de la matriz es la extensión y todos los demás son la base.