¿Cómo recorto una extensión de archivo de una cadena en Java?

¿Cuál es la forma más eficiente de recortar el sufijo en Java, así:

title part1.txt
title part2.html
=>
title part1
title part2

Este es el tipo de código que no deberíamos estar haciendo nosotros mismos. Usa bibliotecas para las cosas mundanas, guarda tu cerebro para las cosas difíciles.

En este caso, recomiendo usar FilenameUtils.removeExtension () de Apache Commons IO

str.substring(0, str.lastIndexOf('.'))

Como usar el String.substringy String.lastIndexen un one-liner es bueno, hay algunos problemas en términos de poder hacer frente a ciertas rutas de archivo.

Tome por ejemplo la siguiente ruta:

a.b/c

Usar el one-liner dará como resultado:

a

Eso es incorrecto

El resultado debería haber sido c, pero dado que el archivo carecía de una extensión, pero la ruta tenía un directorio con un .nombre, el método de una línea fue engañado para que diera parte de la ruta como nombre de archivo, lo cual no es correcto.

Necesidad de cheques

Inspirado por la respuesta de skaffman , eché un vistazo al FilenameUtils.removeExtensionmétodo de Apache Commons IO .

Para recrear su comportamiento, escribí algunas pruebas que el nuevo método debería cumplir, que son las siguientes:

Nombre de archivo de ruta
-------------- --------
a / b / cc
a / b / c.jpg c
a / b / c.jpg.jpg c.jpg

ab / cc
ab / c.jpg c
ab / c.jpg.jpg c.jpg

cc
c.jpg c
c.jpg.jpg c.jpg

(Y eso es todo lo que he verificado, probablemente haya otras comprobaciones que deberían estar en su lugar que he pasado por alto).

La implementación

La siguiente es mi implementación para el removeExtensionmétodo:

public static String removeExtension(String s) {

    String separator = System.getProperty("file.separator");
    String filename;

    // Remove the path upto the filename.
    int lastSeparatorIndex = s.lastIndexOf(separator);
    if (lastSeparatorIndex == -1) {
        filename = s;
    } else {
        filename = s.substring(lastSeparatorIndex + 1);
    }

    // Remove the extension.
    int extensionIndex = filename.lastIndexOf(".");
    if (extensionIndex == -1)
        return filename;

    return filename.substring(0, extensionIndex);
}

Ejecutar este removeExtensionmétodo con las pruebas anteriores produce los resultados enumerados anteriormente.

El método fue probado con el siguiente código. Como esto se ejecutó en Windows, el separador de ruta es un elemento \que debe escaparse con un \cuando se usa como parte de un Stringliteral.

System.out.println(removeExtension("a\\b\\c"));
System.out.println(removeExtension("a\\b\\c.jpg"));
System.out.println(removeExtension("a\\b\\c.jpg.jpg"));

System.out.println(removeExtension("a.b\\c"));
System.out.println(removeExtension("a.b\\c.jpg"));
System.out.println(removeExtension("a.b\\c.jpg.jpg"));

System.out.println(removeExtension("c"));
System.out.println(removeExtension("c.jpg"));
System.out.println(removeExtension("c.jpg.jpg"));

Los resultados fueron:

c
c
c.jpg
c
c
c.jpg
c
c
c.jpg

Los resultados son los resultados deseados descritos en la prueba que el método debe cumplir.

Por cierto, en mi caso, cuando quería una solución rápida para eliminar una extensión específica, esto es aproximadamente lo que hice:

  if (filename.endsWith(ext))
    return filename.substring(0,filename.length() - ext.length());
  else
    return filename;

String foo = "title part1.txt";
foo = foo.substring(0, foo.lastIndexOf('.'));

String fileName="foo.bar";
int dotIndex=fileName.lastIndexOf('.');
if(dotIndex>=0) { // to prevent exception if there is no dot
  fileName=fileName.substring(0,dotIndex);
}

¿Es esta una pregunta con trampa? :pags

No puedo pensar en un cajero automático más rápido.

Use un método en com.google.common.io.Filesclase si su proyecto ya depende de la biblioteca principal de Google. El método que necesitas es getNameWithoutExtension.

puedes probar esta función, muy básica

public String getWithoutExtension(String fileFullPath){
    return fileFullPath.substring(0, fileFullPath.lastIndexOf('.'));
}

He encontrado la respuesta de coolbird particularmente útil.

Pero cambié las últimas declaraciones de resultados a:

if (extensionIndex == -1)
  return s;

return s.substring(0, lastSeparatorIndex+1) 
         + filename.substring(0, extensionIndex);

ya que quería que se devolviera el nombre completo de la ruta.

Entonces "C: \ Users \ mroh004.COM \ Documents \ Test \ Test.xml" se convierte en 
   "C: \ Users \ mroh004.COM \ Documents \ Test \ Test" y no
   "Prueba"

filename.substring(filename.lastIndexOf('.'), filename.length()).toLowerCase();

Usa una expresión regular. Este reemplaza el último punto, y todo lo que sigue.

String baseName = fileName.replaceAll("\\.[^.]*$", "");

También puede crear un objeto Patrón si desea precompilar la expresión regular.

String[] splitted = fileName.split(".");
String fileNameWithoutExtension = fileName.replace("." + splitted[splitted.length - 1], "");

crear un nuevo archivo con ruta de imagen de cadena

String imagePath;
File test = new File(imagePath);
test.getName();
test.getPath();
getExtension(test.getName());


public static String getExtension(String uri) {
        if (uri == null) {
            return null;
        }

        int dot = uri.lastIndexOf(".");
        if (dot >= 0) {
            return uri.substring(dot);
        } else {
            // No extension.
            return "";
        }
    }

org.apache.commons.io.FilenameUtils versión 2.4 da la siguiente respuesta

public static String removeExtension(String filename) {
    if (filename == null) {
        return null;
    }
    int index = indexOfExtension(filename);
    if (index == -1) {
        return filename;
    } else {
        return filename.substring(0, index);
    }
}

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

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

public static final char EXTENSION_SEPARATOR = '.';
private static final char UNIX_SEPARATOR = '/';
private static final char WINDOWS_SEPARATOR = '\\';

 private String trimFileExtension(String fileName)
  {
     String[] splits = fileName.split( "\\." );
     return StringUtils.remove( fileName, "." + splits[splits.length - 1] );
  }

Me gustaría hacer esto:

String title_part = "title part1.txt";
int i;
for(i=title_part.length()-1 ; i>=0 && title_part.charAt(i)!='.' ; i--);
title_part = title_part.substring(0,i);

Comenzando hasta el final hasta el '.' luego llame a la subcadena.

Editar: Puede que no sea un golf pero es efectivo :)

Teniendo en cuenta los escenarios donde no hay extensión de archivo o hay más de una extensión de archivo

ejemplo Nombre de archivo: archivo | file.txt | file.tar.bz2

/**
 *
 * @param fileName
 * @return file extension
 * example file.fastq.gz => fastq.gz
 */
private String extractFileExtension(String fileName) {
    String type = "undefined";
    if (FilenameUtils.indexOfExtension(fileName) != -1) {
        String fileBaseName = FilenameUtils.getBaseName(fileName);
        int indexOfExtension = -1;
        while (fileBaseName.contains(".")) {
            indexOfExtension = FilenameUtils.indexOfExtension(fileBaseName);
            fileBaseName = FilenameUtils.getBaseName(fileBaseName);
        }
        type = fileName.substring(indexOfExtension + 1, fileName.length());
    }
    return type;
}

String img = "example.jpg";
// String imgLink = "http://www.example.com/example.jpg";
URI uri = null;

try {
    uri = new URI(img);
    String[] segments = uri.getPath().split("/");
    System.out.println(segments[segments.length-1].split("\\.")[0]);
} catch (Exception e) {
    e.printStackTrace();
}

Esto generará ejemplos para img e imgLink

public static String removeExtension(String file) {
    if(file != null && file.length() > 0) {
        while(file.contains(".")) {
            file = file.substring(0, file.lastIndexOf('.'));
        }
    }
    return file;
}