public static String getPhotoFileExtension(int empKey){
    try{
        String[] types = {".jpg",".JPG",".png", ".PNG"};
        for(String t : types)
        {
            String path = "/"+Common.PHOTO_PATH + empKey + t;
            File f = new File(Sessions.getCurrent().getWebApp()
                    .getRealPath(path));
            if(f.isFile())
                return t;
        }
    }catch (Exception e) {
        e.printStackTrace();
    }
    return "";
}

// on Linux
File f1 = new File("/testFolder/test.png");
File f2 = new File("/testFolder/test.PNG");
File f3 = new File("/testFolder/test.PnG");
f1.exists(); // false
f2.exists(); // false
f3.exists(); // true

// on Windows
File f1 = new File("c:\testFolder\test.png");
File f2 = new File("c:\testFolder\test.PNG");
File f3 = new File("c:\testFolder\test.PnG");
f1.exists(); // true
f2.exists(); // true
f3.exists(); // true

File dir = new File("c://testFolder//");
for(String fileName : dir.list())
    System.out.println(fileName);
// OUTPUT: test.PnG

File dir = new File("c://testFolder//");
for(File file : dir.listFiles())
    System.out.println(file.getName());
// OUTPUT: test.PnG

public boolean exists(File dir, String filename){
    String[] files = dir.list();
    for(String file : files)
        if(file.equals(filename))
            return true;
    return false;
}

File dir = new File("c:\testFolder\");
exists(dir, "test.png");   // false
exists(dir, "test.PNG");   // false
exists(dir, "test.PnG");   // true

File f = new File("c://testFolder//test.png");
System.out.println(f.getCanonicalPath());
// OUTPUT: C:testFoldertest.PnG

public boolean checkExtensionCaseSensitive(File _file, String _extension) throws IOException{
    String canonicalPath = _file.getCanonicalPath();
    String extension = "";
    int i = canonicalPath.lastIndexOf('.');
    if (i > 0) {
        extension = canonicalPath.substring(i+1);
        if(extension.equals(_extension))
            return true;
    }
    return false;
}

File f = new File("c://testFolder//test.png");
checkExtensionCaseSensitive(f, "png"); // false
checkExtensionCaseSensitive(f, "PNG"); // false
checkExtensionCaseSensitive(f, "PnG"); // true

public static boolean fileExistsCaseSensitive(String path) {
    try {
        File file = new File(path);
        return file.exists() && file.getCanonicalFile().getName().equals(file.getName());
    } catch (IOException e) {
        return false;
    }
}

import java.io.File;
import java.util.Collection;
import java.util.Optional;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.filefilter.IOFileFilter;

public class CaseInsensitiveFileFinder {

    /**
     * Attempts to find a file with the given <code>fileName</code> (irrespective of case) in the given
     * <code>absoluteDirPath</code>. Note that while this method is able to find <code>fileName</code> ignoring case, it
     * may not be able to do so if <code>absoluteDirPath</code> is in an incorrect case - that behavior is OS dependent.
     *
     * @param absoluteDirPath the absolute path of the parent directory of <code>fileName</code> (e.g. "/Users/me/foo")
     * @param fileName the name of the file including extension that may or may not be the correct case
     * (e.g. myfile.txt)
     * @return an optional reference to the file if found, {@link Optional#empty()} will be returned if the file is not
     * found
     */
    public Optional<File> findFileIgnoreCase(String absoluteDirPath, final String fileName) {

        File directory = new File(absoluteDirPath);
        if (!directory.isDirectory()) {
            throw new IllegalArgumentException("Directory '" + absoluteDirPath + "' isn't a directory.");
        }
        IOFileFilter caseInsensitiveFileNameFilter = new IOFileFilter() {
            @Override
            public boolean accept(File dir, String name) {
                boolean isSameFile = fileName.equalsIgnoreCase(name);
                return isSameFile;
            }

            @Override
            public boolean accept(File file) {
                String name = file.getName();
                boolean isSameFile = fileName.equalsIgnoreCase(name);
                return isSameFile;
            }
        };
        Collection<File> foundFiles = FileUtils.listFiles(directory, caseInsensitiveFileNameFilter, null);
        if (foundFiles == null || foundFiles.isEmpty()) {
            return Optional.empty();
        }
        if (foundFiles.size() > 1) {
            throw new IllegalStateException(
                    "More requirements needed to determine what to do with more than one file. Pick the closest match maybe?");
        }
        // else exactly one file
        File foundFile = foundFiles.iterator().next();
        return Optional.of(foundFile);
    }
}

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import java.io.File;
import java.io.IOException;
import java.util.Optional;

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import com.google.common.io.Files;

/**
 * Non-quite-unit tests for {@link CaseInsensitiveFileFinder} class.
 */
public class CaseInsensitiveFileFinderTest {

    private static String APPENDABLE_NEW_TMP_DIR_PATH;

    /**
     * Create the files with different cases.
     * @throws IOException
     */
    @BeforeClass
    public static void setup() throws IOException {
        File newTmpDir = Files.createTempDir();
        String newTmpDirPath = newTmpDir.getCanonicalPath();
        final String appendableNewTmpDirPath;
        String fileSeparator = System.getProperty("file.separator");
        if (!newTmpDirPath.endsWith(fileSeparator)) {
            appendableNewTmpDirPath = newTmpDirPath + fileSeparator;
        }
        else {
            appendableNewTmpDirPath = newTmpDirPath;
        }
        CaseInsensitiveFileFinderTest.APPENDABLE_NEW_TMP_DIR_PATH = appendableNewTmpDirPath;

        File foofileDotPng = new File(appendableNewTmpDirPath + "FOOFILE.PNG");
        Files.touch(foofileDotPng);
        assertTrue(foofileDotPng.isFile());
        File barfileDotJpg = new File(appendableNewTmpDirPath + "BARFILE.JPG");
        Files.touch(barfileDotJpg);
        assertTrue(barfileDotJpg.isFile());
    }

    @AfterClass
    public static void teardown() throws IOException {
        File newTmpDir = new File(CaseInsensitiveFileFinderTest.APPENDABLE_NEW_TMP_DIR_PATH);
        assertTrue(newTmpDir.isDirectory());
        // delete even though directory isn't empty
        FileUtils.deleteDirectory(newTmpDir);
    }

    @Test
    public void findFooFilePngUsingLowercase() throws IOException {
        CaseInsensitiveFileFinder fileFinder = new CaseInsensitiveFileFinder();
        Optional<File> optFoundFile = fileFinder.findFileIgnoreCase(APPENDABLE_NEW_TMP_DIR_PATH, "foofile.png");
        assertTrue(optFoundFile.isPresent());
        File foundFile = optFoundFile.get();
        assertTrue(foundFile.isFile());
        assertEquals(APPENDABLE_NEW_TMP_DIR_PATH + "FOOFILE.PNG", foundFile.getCanonicalPath());
    }

    @Test
    public void findBarFileJpgUsingLowercase() throws IOException {
        CaseInsensitiveFileFinder fileFinder = new CaseInsensitiveFileFinder();
        Optional<File> optFoundFile = fileFinder.findFileIgnoreCase(APPENDABLE_NEW_TMP_DIR_PATH, "barfile.jpg");
        assertTrue(optFoundFile.isPresent());
        File foundFile = optFoundFile.get();
        assertTrue(foundFile.isFile());
        assertEquals(APPENDABLE_NEW_TMP_DIR_PATH + "BARFILE.JPG", foundFile.getCanonicalPath());
    }

    @Test
    public void findFileThatDoesNotExist() {
        CaseInsensitiveFileFinder fileFinder = new CaseInsensitiveFileFinder();
        Optional<File> optFoundFile = fileFinder.findFileIgnoreCase(APPENDABLE_NEW_TMP_DIR_PATH, "dne.txt");
        assertFalse(optFoundFile.isPresent());
    }

    @Test
    public void findFooFileUsingDirWithNoTrailingFileSeparator() throws IOException {
        CaseInsensitiveFileFinder fileFinder = new CaseInsensitiveFileFinder();
        String newDirPathWithNoTrailingFileSep = StringUtils.chop(APPENDABLE_NEW_TMP_DIR_PATH);
        Optional<File> optFoundFile = fileFinder.findFileIgnoreCase(newDirPathWithNoTrailingFileSep, "FOOFILE.PNG");
        assertTrue(optFoundFile.isPresent());
        File foundFile = optFoundFile.get();
        assertTrue(foundFile.isFile());
        assertEquals(APPENDABLE_NEW_TMP_DIR_PATH + "FOOFILE.PNG", foundFile.getCanonicalPath());
    }
}

public static File getPhotoFileExtension(int empKey){
    try{
        String[] types = {".jpg",".JPG",".png", ".PNG"};
        for(String t : types)
        {
            String path = "/"+Common.PHOTO_PATH + empKey + t;
            File f = new File(Sessions.getCurrent().getWebApp()
                    .getRealPath(path));
            if(f.isFile())
                return f;
        }
    }catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

public static boolean fileExistsCaseSensitive(String path) {
    try {
        File file = new File(path);
        return file.exists() || !file.getCanonicalFile().getName().equals(file.getName());
    } catch (IOException e) {
        return false;
    }
}