Comment obtenir le nom de fichier sans l'extension en Java?

Quelqu'un peut-il me dire comment obtenir le nom de fichier sans l'extension? Exemple:

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

Si vous, comme moi, préférez utiliser du code de bibliothèque où ils ont probablement pensé à tous les cas spéciaux, tels que ce qui se passe si vous passez null ou des points dans le chemin mais pas dans le nom de fichier, vous pouvez utiliser ce qui suit:

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

Le moyen le plus simple consiste à utiliser une expression régulière.

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

L'expression ci-dessus supprimera le dernier point suivi d'un ou plusieurs caractères. Voici un test unitaire de base.

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

Voir le programme de test suivant:

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

qui génère:

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

Voici l'ordre de la liste consolidée par ma préférence.

Utilisation d'apache commons

import org.apache.commons.io.FilenameUtils;

String fileNameWithoutExt = FilenameUtils.getBaseName(fileName);

                           OR

String fileNameWithOutExt = FilenameUtils.removeExtension(fileName);

Utilisation de Google Guava (si vous l'utilisez déjà)

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

Ou en utilisant 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 Liferay

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

Si votre projet utilise Guava (14.0 ou plus récent), vous pouvez continuer Files.getNameWithoutExtension().

(Essentiellement le même que FilenameUtils.removeExtension()pour Apache Commons IO, comme le suggère la réponse la plus votée . Je voulais juste souligner que la goyave le fait aussi. Personnellement, je ne voulais pas ajouter de dépendance à Commons — ce qui me semble un peu une relique— juste à cause de cela.)

Ci-dessous est la référence 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 vous n'aimez pas importer la version complète d'apache.commons, j'ai extrait la même fonctionnalité:

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

Alors que je suis un grand partisan de la réutilisation des bibliothèques, le JAR org.apache.commons.io est de 174 Ko, ce qui est notablement important pour une application mobile.

Si vous téléchargez le code source et jetez un oeil à leur classe FilenameUtils, vous pouvez voir qu'il existe de nombreux utilitaires supplémentaires, et il prend en charge les chemins Windows et Unix, ce qui est très agréable.

Cependant, si vous voulez juste quelques méthodes utilitaires statiques à utiliser avec les chemins de style Unix (avec un séparateur "/"), vous pouvez trouver le code ci-dessous utile.

La removeExtensionméthode conserve le reste du chemin avec le nom de fichier. Il y a aussi un similaire 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("."));
    }

Le moyen le plus simple d'obtenir le nom d'un chemin relatif ou d'un chemin complet consiste à utiliser

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

Vous pouvez le diviser par "." et sur l'index 0 est le nom du fichier et sur 1 est l'extension, mais j'inclinerais pour la meilleure solution avec FileNameUtils de apache.commons-io comme cela a été mentionné dans le premier article. Il n'est pas nécessaire de le supprimer, mais il suffit:

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

Utilisation FilenameUtils.removeExtensiondepuis Apache Commons IO

Exemple:

Vous pouvez fournir le nom de chemin complet ou uniquement le nom de fichier .

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

J'espère que cela t'aides ..

La manière fluide:

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

Pour rester simple, utilisez la méthode String.replaceAll () de Java comme suit:

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

Cela fonctionne également lorsque fileNameWithExt inclut le chemin d'accès complet.

Vous pouvez utiliser la fonction de division Java pour séparer le nom de fichier de l'extension, si vous êtes sûr qu'il n'y a qu'un seul point dans le nom de fichier pour l'extension.

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

donc le split[0]retournera "test" et split [1] retournera "txt"

Essayez le code ci-dessous. Utilisation des fonctions de base de Java. Il prend en charge les Strings avec extension, et sans extension (sans le '.'caractère). Le cas du multiple '.'est également couvert.

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

Vous pouvez l'adapter pour travailler avec des nullchaînes.