How to get the filename without the extension in Java?

The easiest way is to use a regular expression.

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

The above expression will remove the last dot followed by one or more characters. Here's a basic unit test.

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

Here is the consolidated list order by my preference.

Using apache commons

import org.apache.commons.io.FilenameUtils; String fileNameWithoutExt = FilenameUtils.getBaseName(fileName); OR String fileNameWithOutExt = FilenameUtils.removeExtension(fileName); 

Using Google Guava (If u already using it)

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

Files.getNameWithoutExtension

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

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

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

See the following test program:

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

which outputs:

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

If your project uses Guava (14.0 or newer), you can go with Files.getNameWithoutExtension().

(Essentially the same as FilenameUtils.removeExtension() from Apache Commons IO, as the highest-voted answer suggests. Just wanted to point out Guava does this too. Personally I didn't want to add dependency to Commons—which I feel is a bit of a relic—just because of this.)

Below is reference from 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); } } 

If you don't like to import the full apache.commons, I've extracted the same functionality:

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

For Kotlin it's now simple as:

val fileNameStr = file.nameWithoutExtension 

While I am a big believer in reusing libraries, the org.apache.commons.io JAR is 174KB, which is noticably large for a mobile app.

If you download the source code and take a look at their FilenameUtils class, you can see there are a lot of extra utilities, and it does cope with Windows and Unix paths, which is all lovely.

However, if you just want a couple of static utility methods for use with Unix style paths (with a "/" separator), you may find the code below useful.

The removeExtension method preserves the rest of the path along with the filename. There is also a 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; } 

Given the String filename, you can do:

String filename = "test.xml"; filename.substring(0, filename.lastIndexOf(".")); // Output: test filename.split("\\.")[0]; // Output: test 

fileEntry.getName().substring(0, fileEntry.getName().lastIndexOf(".")); 

Simplest way to get name from relative path or full path is using

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

You can use java split function to split the filename from the extension, if you are sure there is only one dot in the filename which for extension.

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

so the split[0] will return "test" and split[1] will return "txt"

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

Use FilenameUtils.removeExtension from Apache Commons IO

Example:

You can provide full path name or only the file name.

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

Hope this helps ..

The fluent way:

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

You can split it by "." and on index 0 is file name and on 1 is extension, but I would incline for the best solution with FileNameUtils from apache.commons-io like it was mentioned in the first article. It does not have to be removed, but sufficent is:

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

Keeping it simple, use Java's String.replaceAll() method as follows:

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

This also works when fileNameWithExt includes the fully qualified path.

My solution needs the following import.

import java.io.File; 

The following method should return the desired output string:

private static String getFilenameWithoutExtension(File file) throws IOException { String filename = file.getCanonicalPath(); String filenameWithoutExtension; if (filename.contains(".")) filenameWithoutExtension = filename.substring(filename.lastIndexOf(System.getProperty("file.separator"))+1, filename.lastIndexOf('.')); else filenameWithoutExtension = filename.substring(filename.lastIndexOf(System.getProperty("file.separator"))+1); return filenameWithoutExtension; } 

com.google.common.io.Files

Files.getNameWithoutExtension(sourceFile.getName())

can do a job as well

file name only, where full path is also included. No need for external libs, regex...etc

 public class MyClass { public static void main(String args[]) { String file = "some/long/directory/blah.x.y.z.m.xml"; System.out.println(file.substring(file.lastIndexOf("/") + 1, file.lastIndexOf("."))); //outputs blah.x.y.z.m } } 

If your project uses Spring you can use:

import org.springframework.util.StringUtils; // … StringUtils.stripFilenameExtension("/tmp/myFile.txt") // → "/tmp/myFile" 

NB: This method has its limitations when it comes to dotfiles, where it will return /tmp/ for /tmp/.config (getBaseName() from commons-io has the same problem btw).

This Baeldung article proposes a nifty two-liner that claims to work for all cases:

public static String removeFileExtension(String filename, boolean removeAllExtensions) { if (filename == null || filename.isEmpty()) return filename; return filename.replaceAll("(?<!^)[.]" + (removeAllExtensions ? ".*" : "[^.]*$"), ""); } 

Just put following methods in an helper class.

public static String getFilenameWithoutExtension(final File file) { final String filename = file.getName(); final int pointIndex = filename.lastIndexOf('.'); if (pointIndex > 0) { return filename.substring(0, pointIndex); } else { return filename; } } public static String getFilenameWithoutExtension(String filePath) { int charIndex = filePath.lastIndexOf(java.nio.file.FileSystems.getDefault().getSeparator()); if (charIndex > 0) { filePath = filePath.substring(charIndex + 1); } charIndex = filePath.lastIndexOf('.'); if (charIndex > 0) { return filePath.substring(0, charIndex); } else { return filePath; } } 

Still actual

Stripping all single extensions like .txt and double extensions like .min.js / .tar.gz
I have ignored 0-9 numbers from file extension, as not my case, you can add if required:

public static String getFileNameWithoutExtension(String fileName) { if (StringUtils.isBlank(fileName) || fileName.startsWith(".")) { return fileName; } final String file = fileName.trim().replaceFirst("(?i)(?:\\.[A-Za-z]{1,4})?\\.[A-Za-z]{1,5}$", ""); return file.trim(); } 

and test:

@Test public void test_getFileNameWithoutExtension() { assertThat(getFileNameWithoutExtension("file")).isEqualTo("file"); assertThat(getFileNameWithoutExtension("file.txt")).isEqualTo("file"); assertThat(getFileNameWithoutExtension("FILE.TXT")).isEqualTo("FILE"); assertThat(getFileNameWithoutExtension("File.xml")).isEqualTo("File"); assertThat(getFileNameWithoutExtension("file.conf")).isEqualTo("file"); assertThat(getFileNameWithoutExtension("file.exe")).isEqualTo("file"); assertThat(getFileNameWithoutExtension("file.tar")).isEqualTo("file"); assertThat(getFileNameWithoutExtension("file.js.map")).isEqualTo("file"); assertThat(getFileNameWithoutExtension("file.js.bck")).isEqualTo("file"); assertThat(getFileNameWithoutExtension("file.")).isEqualTo("file."); assertThat(getFileNameWithoutExtension("file.tar.gz")).isEqualTo("file"); assertThat(getFileNameWithoutExtension(" file .tar.gz ")).isEqualTo("file"); assertThat(getFileNameWithoutExtension(".file")).isEqualTo(".file"); assertThat(getFileNameWithoutExtension(".file.txt")).isEqualTo(".file.txt"); assertThat(getFileNameWithoutExtension("file.bla")).isEqualTo("file"); assertThat(getFileNameWithoutExtension(" file ")).isEqualTo("file"); assertThat(getFileNameWithoutExtension("file name")).isEqualTo("file name"); assertThat(getFileNameWithoutExtension("file.internal.bla")).isEqualTo("file.internal"); assertThat(getFileNameWithoutExtension("file-21.03.25.txt")).isEqualTo("file-21.03.25"); assertThat(getFileNameWithoutExtension("file-21.03.25.min.js")).isEqualTo("file-21.03.25"); assertThat(getFileNameWithoutExtension("a.b.c.min.js")).isEqualTo("a.b.c"); assertThat(getFileNameWithoutExtension("file-21.03.25")).isEqualTo("file-21.03.25"); assertThat(getFileNameWithoutExtension("file-21.03.25.")).isEqualTo("file-21.03.25."); assertThat(getFileNameWithoutExtension("widget.v1.js")).isEqualTo("widget.v1"); assertThat(getFileNameWithoutExtension("widget.rc2.css")).isEqualTo("widget.rc2"); assertThat(getFileNameWithoutExtension("widget.v1.js1")).isEqualTo("widget.v1.js1"); assertThat(getFileNameWithoutExtension("widget.rc2.css3")).isEqualTo("widget.rc2.css3"); assertThat(getFileNameWithoutExtension(".env")).isEqualTo(".env"); assertThat(getFileNameWithoutExtension(".env.local")).isEqualTo(".env.local"); }