Comment découper une extension de fichier d'une chaîne en Java?

Quel est le moyen le plus efficace de couper le suffixe en Java, comme ceci:

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

C'est le genre de code que nous ne devrions pas faire nous-mêmes. Utilisez des bibliothèques pour les choses banales, gardez votre cerveau pour les choses difficiles.

Dans ce cas, je recommande d'utiliser FilenameUtils.removeExtension () d' Apache Commons IO

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

Comme l'utilisation de String.substringet String.lastIndexdans une seule ligne est une bonne chose, il y a quelques problèmes en termes de capacité à gérer certains chemins de fichiers.

Prenons par exemple le chemin suivant:

a.b/c

L'utilisation du one-liner entraînera:

a

C'est incorrect.

Le résultat aurait dû être c, mais comme le fichier n'avait pas d'extension, mais que le chemin avait un répertoire avec un .dans le nom, la méthode one-liner a été trompée en donnant une partie du chemin comme nom de fichier, ce qui n'est pas correct.

Besoin de chèques

Inspiré par la réponse de skaffman , j'ai jeté un coup d'œil à la FilenameUtils.removeExtensionméthode de l' Apache Commons IO .

Afin de recréer son comportement, j'ai écrit quelques tests que la nouvelle méthode devrait remplir, qui sont les suivants:

Nom de fichier du chemin
-------------- --------
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

(Et c'est tout ce que j'ai vérifié - il y a probablement d'autres contrôles qui devraient être en place que j'ai négligés.)

La mise en oeuvre

Voici mon implémentation pour la removeExtensionméthode:

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

L'exécution de cette removeExtensionméthode avec les tests ci-dessus donne les résultats énumérés ci-dessus.

La méthode a été testée avec le code suivant. Comme cela a été exécuté sous Windows, le séparateur de chemin est un \qui doit être échappé avec un \lorsqu'il est utilisé dans le cadre d'un Stringlittéral.

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

Les résultats ont été:

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

Les résultats sont les résultats souhaités décrits dans le test que la méthode doit remplir.

BTW, dans mon cas, lorsque je voulais une solution rapide pour supprimer une extension spécifique, c'est à peu près ce que j'ai fait:

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

Est-ce une question piège? : p

Je ne peux pas penser à un guichet automatique plus rapide.

Utilisez une méthode en com.google.common.io.Filesclasse si votre projet dépend déjà de la bibliothèque principale de Google. La méthode dont vous avez besoin est getNameWithoutExtension.

vous pouvez essayer cette fonction, très basique

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

J'ai trouvé la réponse de coolbird particulièrement utile.

Mais j'ai changé les dernières déclarations de résultat en:

if (extensionIndex == -1)
  return s;

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

car je voulais que le nom complet du chemin soit renvoyé.

Ainsi "C: \ Users \ mroh004.COM \ Documents \ Test \ Test.xml" devient 
   "C: \ Users \ mroh004.COM \ Documents \ Test \ Test" et non
   "Tester"

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

Utilisez une expression régulière. Celui-ci remplace le dernier point, et tout ce qui suit.

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

Vous pouvez également créer un objet Pattern si vous souhaitez précompiler le regex.

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

créer un nouveau fichier avec le chemin de l'image de chaîne

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 version 2.4 donne la réponse suivante

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

Je voudrais faire comme ceci:

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

De la fin jusqu'au '.' puis appelez substring.

Edit: Ce n'est peut-être pas un golf mais c'est efficace :)

En gardant à l'esprit les scénarios où il n'y a pas d'extension de fichier ou il y a plus d'une extension de fichier

exemple Nom de fichier: fichier | 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();
}

Cela affichera un exemple pour img et imgLink

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