from - string[] java

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

Question

¿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

Answer 1

Como usar String.substring y String.lastIndex en una línea es bueno, existen algunos problemas en términos de poder hacer frente a ciertas rutas de archivos.

Tomemos, por ejemplo, la siguiente ruta:

a.b/c

El uso del 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 a . en el nombre, el método one-liner fue engañado para dar parte del camino como el nombre de archivo, que no es correcto.

Necesidad de cheques

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

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

Path Filename -------------- -------- a/b/c c a/b/c.jpg c a/b/c.jpg.jpg c.jpg a.b/c c a.b/c.jpg c a.b/c.jpg.jpg c.jpg c c c.jpg c c.jpg.jpg c.jpg

(Y eso es todo lo que he revisado, probablemente haya otros controles que deberían haberse implementado y que he pasado por alto).

La implementación

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

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

La ejecución de este método removeExtension con las pruebas anteriores arroja 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 / que debe escaparse con un / cuando se usa como parte de un literal String .

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.

Answer 2

Este es el tipo de código que no deberíamos hacer nosotros mismos. Utiliza las bibliotecas para lo mundano, guarda tu cerebro para las cosas difíciles.

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

Answer 3

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 llama a subcadena.

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

Answer 4

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;

Answer 5

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

Answer 6

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

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

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

Answer 7

Utilice un método en la clase com.google.common.io.Files si su proyecto ya depende de la biblioteca principal de Google. El método que necesita es getNameWithoutExtension .

Answer 8

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

Answer 9

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 = ''//';

Answer 10

puedes probar esta función, muy básico

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

Answer 11

Encontré la respuesta de coolbird particularmente útil.

Pero cambié los últimos 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.

So "C:/Users/mroh004.COM/Documents/Test/Test.xml" becomes "C:/Users/mroh004.COM/Documents/Test/Test" and not "Test"

Answer 12

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

Answer 13

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? :pag

No puedo pensar en un cajero automático de manera más rápida.

Answer 14

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

Answer 15

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

Answer 16

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

Answer 17

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