¿Cómo obtener el nombre de archivo sin la extensión en Java?

¿Alguien puede decirme cómo obtener el nombre de archivo sin la extensión? Ejemplo:

fileNameWithExt = "test.xml";
fileNameWithOutExt = "test";

Si usted, como yo, prefiere usar algún código de biblioteca donde probablemente hayan pensado en todos los casos especiales, como lo que sucede si pasa puntos o nulos en la ruta pero no en el nombre del archivo, puede usar lo siguiente:

import org.apache.commons.io.FilenameUtils;
String fileNameWithOutExt = FilenameUtils.removeExtension(fileNameWithExt);

La forma más fácil es usar una expresión regular.

fileNameWithOutExt = "test.xml".replaceFirst("[.][^.]+$", "");

La expresión anterior eliminará el último punto seguido de uno o más caracteres. Aquí hay una prueba de unidad básica.

public void testRegex() {
    assertEquals("test", "test.xml".replaceFirst("[.][^.]+$", ""));
    assertEquals("test.2", "test.2.xml".replaceFirst("[.][^.]+$", ""));
}

Vea el siguiente programa de prueba:

public class javatemp {
    static String stripExtension (String str) {
        // Handle null case specially.

        if (str == null) return null;

        // Get position of last '.'.

        int pos = str.lastIndexOf(".");

        // If there wasn't any '.' just return the string as is.

        if (pos == -1) return str;

        // Otherwise return the string, up to the dot.

        return str.substring(0, pos);
    }

    public static void main(String[] args) {
        System.out.println ("test.xml   -> " + stripExtension ("test.xml"));
        System.out.println ("test.2.xml -> " + stripExtension ("test.2.xml"));
        System.out.println ("test       -> " + stripExtension ("test"));
        System.out.println ("test.      -> " + stripExtension ("test."));
    }
}

que salidas:

test.xml   -> test
test.2.xml -> test.2
test       -> test
test.      -> test

Aquí está el orden de la lista consolidada por mi preferencia.

Usando apache commons

import org.apache.commons.io.FilenameUtils;

String fileNameWithoutExt = FilenameUtils.getBaseName(fileName);

                           OR

String fileNameWithOutExt = FilenameUtils.removeExtension(fileName);

Usando Google Guava (si ya lo estás usando)

import com.google.common.io.Files;
String fileNameWithOutExt = Files.getNameWithoutExtension(fileName);

O usando Core Java

1)

String fileName = file.getName();
int pos = fileName.lastIndexOf(".");
if (pos > 0 && pos < (fileName.length() - 1)) { // If '.' is not the first or last character.
    fileName = fileName.substring(0, pos);
}

2)

if (fileName.indexOf(".") > 0) {
   return fileName.substring(0, fileName.lastIndexOf("."));
} else {
   return fileName;
}

3)

private static final Pattern ext = Pattern.compile("(?<=.)\\.[^.]+$");

public static String getFileNameWithoutExtension(File file) {
    return ext.matcher(file.getName()).replaceAll("");
}

API de Liferay

import com.liferay.portal.kernel.util.FileUtil; 
String fileName = FileUtil.stripExtension(file.getName());

Si su proyecto usa guayaba (14.0 o más reciente), puede ir con Files.getNameWithoutExtension().

(Esencialmente lo mismo que FilenameUtils.removeExtension()de Apache Commons IO, como sugiere la respuesta más votada . Solo quería señalar que Guava hace esto también. Personalmente no quería agregar dependencia a Commons, lo cual creo que es un poco una reliquia) solo por esto)

A continuación se muestra una referencia de https://android.googlesource.com/platform/tools/tradefederation/+/master/src/com/android/tradefed/util/FileUtil.java

/**
 * Gets the base name, without extension, of given file name.
 * <p/>
 * e.g. getBaseName("file.txt") will return "file"
 *
 * @param fileName
 * @return the base name
 */
public static String getBaseName(String fileName) {
    int index = fileName.lastIndexOf('.');
    if (index == -1) {
        return fileName;
    } else {
        return fileName.substring(0, index);
    }
}

Si no desea importar los apache.commons completos, he extraído la misma funcionalidad:

public class StringUtils {
    public static String getBaseName(String filename) {
        return removeExtension(getName(filename));
    }

    public static int indexOfLastSeparator(String filename) {
        if(filename == null) {
            return -1;
        } else {
            int lastUnixPos = filename.lastIndexOf(47);
            int lastWindowsPos = filename.lastIndexOf(92);
            return Math.max(lastUnixPos, lastWindowsPos);
        }
    }

    public static String getName(String filename) {
        if(filename == null) {
            return null;
        } else {
            int index = indexOfLastSeparator(filename);
            return filename.substring(index + 1);
        }
    }

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

    public static int indexOfExtension(String filename) {
        if(filename == null) {
            return -1;
        } else {
            int extensionPos = filename.lastIndexOf(46);
            int lastSeparator = indexOfLastSeparator(filename);
            return lastSeparator > extensionPos?-1:extensionPos;
        }
    }
}

Si bien creo firmemente en la reutilización de bibliotecas, el org.apache.commons.io JAR es 174 KB, que es notablemente grande para una aplicación móvil.

Si descarga el código fuente y echa un vistazo a su clase FilenameUtils, puede ver que hay muchas utilidades adicionales, y hace frente a las rutas de Windows y Unix, lo cual es encantador.

Sin embargo, si solo desea un par de métodos de utilidad estática para usar con rutas de estilo Unix (con un separador "/"), puede encontrar útil el siguiente código.

El removeExtensionmétodo conserva el resto de la ruta junto con el nombre del archivo. También hay un similar getExtension.

/**
 * Remove the file extension from a filename, that may include a path.
 * 
 * e.g. /path/to/myfile.jpg -> /path/to/myfile 
 */
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);
    }
}

/**
 * Return the file extension from a filename, including the "."
 * 
 * e.g. /path/to/myfile.jpg -> .jpg
 */
public static String getExtension(String filename) {
    if (filename == null) {
        return null;
    }

    int index = indexOfExtension(filename);

    if (index == -1) {
        return filename;
    } else {
        return filename.substring(index);
    }
}

private static final char EXTENSION_SEPARATOR = '.';
private static final char DIRECTORY_SEPARATOR = '/';

public static int indexOfExtension(String filename) {

    if (filename == null) {
        return -1;
    }

    // Check that no directory separator appears after the 
    // EXTENSION_SEPARATOR
    int extensionPos = filename.lastIndexOf(EXTENSION_SEPARATOR);

    int lastDirSeparator = filename.lastIndexOf(DIRECTORY_SEPARATOR);

    if (lastDirSeparator > extensionPos) {
        LogIt.w(FileSystemUtil.class, "A directory separator appears after the file extension, assuming there is no file extension");
        return -1;
    }

    return extensionPos;
}

public static String getFileExtension(String fileName) {
        if (TextUtils.isEmpty(fileName) || !fileName.contains(".") || fileName.endsWith(".")) return null;
        return fileName.substring(fileName.lastIndexOf(".") + 1);
    }

    public static String getBaseFileName(String fileName) {
        if (TextUtils.isEmpty(fileName) || !fileName.contains(".") || fileName.endsWith(".")) return null;
        return fileName.substring(0,fileName.lastIndexOf("."));
    }

La forma más simple de obtener el nombre de la ruta relativa o la ruta completa es usar

import org.apache.commons.io.FilenameUtils; FilenameUtils.getBaseName(definitionFilePath)

Puedes dividirlo por "." y en el índice 0 está el nombre del archivo y en 1 es la extensión, pero me inclinaría por la mejor solución con FileNameUtils de apache.commons-io como se mencionó en el primer artículo. No es necesario eliminarlo, pero es suficiente:

String fileName = FilenameUtils.getBaseName("test.xml");

Uso FilenameUtils.removeExtensionde Apache Commons IO

Ejemplo:

Puede proporcionar el nombre completo de la ruta o solo el nombre del archivo .

String myString1 = FilenameUtils.removeExtension("helloworld.exe"); // returns "helloworld"
String myString2 = FilenameUtils.removeExtension("/home/abc/yey.xls"); // returns "yey"

Espero que esto ayude ..

La forma fluida:

public static String fileNameWithOutExt (String fileName) {
    return Optional.of(fileName.lastIndexOf(".")).filter(i-> i >= 0)
            .map(i-> fileName.substring(0, i)).orElse(fileName);
}

Manteniéndolo simple, use el método String.replaceAll () de Java de la siguiente manera:

String fileNameWithExt = "test.xml";
String fileNameWithoutExt
   = fileNameWithExt.replaceAll( "^.*?(([^/\\\\\\.]+))\\.[^\\.]+$", "$1" );

Esto también funciona cuando fileNameWithExt incluye la ruta completa.

Puede usar la función de división de Java para dividir el nombre de archivo de la extensión, si está seguro de que solo hay un punto en el nombre de archivo para la extensión.

File filename = new File('test.txt'); File.getName().split("[.]");

así split[0]que devolverá "test" y split [1] devolverá "txt"

Prueba el siguiente código. Uso de funciones básicas de Java básicas. Se ocupa de Strings con extensión, y sin extensión (sin el '.'carácter). El caso de múltiples '.'también está cubierto.

String str = "filename.xml";
if (!str.contains(".")) 
    System.out.println("File Name=" + str); 
else {
    str = str.substring(0, str.lastIndexOf("."));
    // Because extension is always after the last '.'
    System.out.println("File Name=" + str);
}

Puede adaptarlo para trabajar con nullcadenas.