Wie bekomme ich den Dateinamen ohne die Erweiterung in Java?

Kann mir jemand sagen, wie ich den Dateinamen ohne die Erweiterung bekomme? Beispiel:

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

Wenn Sie, wie ich, lieber einen Bibliothekscode verwenden möchten, bei dem sie wahrscheinlich an alle Sonderfälle gedacht haben, z. B. was passiert, wenn Sie Null oder Punkte im Pfad, aber nicht im Dateinamen übergeben, können Sie Folgendes verwenden:

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

Am einfachsten ist es, einen regulären Ausdruck zu verwenden.

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

Der obige Ausdruck entfernt den letzten Punkt, gefolgt von einem oder mehreren Zeichen. Hier ist ein grundlegender Komponententest.

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

Siehe folgendes Testprogramm:

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

welche Ausgänge:

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

Hier ist die konsolidierte Listenreihenfolge nach meinen Wünschen.

Verwenden von Apache Commons

import org.apache.commons.io.FilenameUtils;

String fileNameWithoutExt = FilenameUtils.getBaseName(fileName);

                           OR

String fileNameWithOutExt = FilenameUtils.removeExtension(fileName);

Verwenden von Google Guava (Wenn Sie es bereits verwenden)

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

Oder mit 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("");
}

Liferay API

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

Wenn Ihr Projekt Guava (14.0 oder neuer) verwendet, können Sie mit gehen Files.getNameWithoutExtension().

(Im Wesentlichen dasselbe wie FilenameUtils.removeExtension()bei Apache Commons IO, wie aus der Antwort mit der höchsten Bewertung hervorgeht. Ich wollte nur darauf hinweisen, dass Guava dies auch tut. Persönlich wollte ich Commons keine Abhängigkeit hinzufügen - was ich für ein Relikt halte - nur deswegen.)

Unten finden Sie eine Referenz von 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);
    }
}

Wenn Sie nicht die vollständige Datei apache.commons importieren möchten, habe ich dieselbe Funktionalität extrahiert:

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

Während ich fest an die Wiederverwendung von Bibliotheken glaube , ist die JAR org.apache.commons.io glaube, beträgt org.apache.commons.io KB, was für eine mobile App bemerkenswert groß ist.

Wenn Sie den Quellcode herunterladen und einen Blick auf die FilenameUtils-Klasse werfen, sehen Sie, dass es viele zusätzliche Dienstprogramme gibt, die Windows- und Unix-Pfade verarbeiten, was alles sehr schön ist.

Wenn Sie jedoch nur einige statische Dienstprogrammmethoden zur Verwendung mit Pfaden im Unix-Stil (mit einem "/" -Trennzeichen) benötigen, ist der folgende Code möglicherweise hilfreich.

Die removeExtensionMethode behält den Rest des Pfads zusammen mit dem Dateinamen bei. Es gibt auch eine ähnliche 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("."));
    }

Der einfachste Weg, um einen Namen vom relativen oder vollständigen Pfad zu erhalten, ist die Verwendung

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

Sie können es durch "." Teilen. und auf Index 0 ist Dateiname und auf 1 ist Erweiterung, aber ich würde für die beste Lösung mit FileNameUtils von apache.commons-io neigen, wie es im ersten Artikel erwähnt wurde. Es muss nicht entfernt werden, aber ausreichend ist:

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

Verwendung FilenameUtils.removeExtensionvon Apache Commons IO

Beispiel:

Sie können den vollständigen Pfadnamen oder nur den Dateinamen angeben .

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

Hoffe das hilft ..

Der fließende Weg:

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

Verwenden Sie die String.replaceAll () -Methode von Java wie folgt:

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

Dies funktioniert auch, wenn fileNameWithExt den vollständig qualifizierten Pfad enthält.

Sie können die Java-Split-Funktion verwenden, um den Dateinamen von der Erweiterung zu trennen, wenn Sie sicher sind, dass der Dateiname nur einen Punkt für die Erweiterung enthält.

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

Das split[0]wird also "test" zurückgeben und split [1] wird "txt" zurückgeben.

Versuchen Sie den folgenden Code. Verwenden der grundlegenden Java-Grundfunktionen. Es kümmert sich um Strings mit Erweiterung und ohne Erweiterung (ohne den '.'Charakter). Der Fall der Mehrfachbehandlung '.'wird ebenfalls behandelt.

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

Sie können es anpassen, um mit nullZeichenfolgen zu arbeiten .