Obtenir le nom du fichier de l'URL
En Java, étant donné un Java.net.URL ou un String sous la forme de http://www.example.com/some/path/to/a/file.xml, quel est le moyen le plus simple d’obtenir le nom du fichier, sans l’extension? Donc, dans cet exemple, je cherche quelque chose qui retourne "file".
Je peux penser à plusieurs façons de faire cela, mais je cherche quelque chose qui soit facile à lire et court.
Au lieu de réinventer la roue, pourquoi ne pas utiliser Apache commons-io :
import org.Apache.commons.io.FilenameUtils;
public class FilenameUtilTest {
public static void main(String[] args) throws Exception {
URL url = new URL("http://www.example.com/some/path/to/a/file.xml?foo=bar#test");
System.out.println(FilenameUtils.getBaseName(url.getPath())); // -> file
System.out.println(FilenameUtils.getExtension(url.getPath())); // -> xml
System.out.println(FilenameUtils.getName(url.getPath())); // -> file.xml
}
}
String fileName = url.substring( url.lastIndexOf('/')+1, url.length() );
String fileNameWithoutExtn = fileName.substring(0, fileName.lastIndexOf('.'));
Cela devrait à propos de le couper (je vous laisserai le traitement de l'erreur):
int slashIndex = url.lastIndexOf('/');
int dotIndex = url.lastIndexOf('.', slashIndex);
String filenameWithoutExtension;
if (dotIndex == -1) {
filenameWithoutExtension = url.substring(slashIndex + 1);
} else {
filenameWithoutExtension = url.substring(slashIndex + 1, dotIndex);
}
Si vous n'avez pas besoin de vous débarrasser de l'extension de fichier, voici une façon de le faire sans recourir à une manipulation de chaînes sujette aux erreurs et sans utiliser de bibliothèques externes. Fonctionne avec Java 1.7+:
import Java.net.URI
import Java.nio.file.Paths
String url = "http://example.org/file?p=foo&q=bar"
String filename = Paths.get(new URI(url).getPath()).getFileName().toString()
public static String getFileName(URL extUrl) {
//URL: "http://photosaaaaa.net/photos-ak-snc1/v315/224/13/659629384/s659629384_752969_4472.jpg"
String filename = "";
//PATH: /photos-ak-snc1/v315/224/13/659629384/s659629384_752969_4472.jpg
String path = extUrl.getPath();
//Checks for both forward and/or backslash
//NOTE:**While backslashes are not supported in URL's
//most browsers will autoreplace them with forward slashes
//So technically if you're parsing an html page you could run into
//a backslash , so i'm accounting for them here;
String[] pathContents = path.split("[\\\\/]");
if(pathContents != null){
int pathContentsLength = pathContents.length;
System.out.println("Path Contents Length: " + pathContentsLength);
for (int i = 0; i < pathContents.length; i++) {
System.out.println("Path " + i + ": " + pathContents[i]);
}
//lastPart: s659629384_752969_4472.jpg
String lastPart = pathContents[pathContentsLength-1];
String[] lastPartContents = lastPart.split("\\.");
if(lastPartContents != null && lastPartContents.length > 1){
int lastPartContentLength = lastPartContents.length;
System.out.println("Last Part Length: " + lastPartContentLength);
//filenames can contain . , so we assume everything before
//the last . is the name, everything after the last . is the
//extension
String name = "";
for (int i = 0; i < lastPartContentLength; i++) {
System.out.println("Last Part " + i + ": "+ lastPartContents[i]);
if(i < (lastPartContents.length -1)){
name += lastPartContents[i] ;
if(i < (lastPartContentLength -2)){
name += ".";
}
}
}
String extension = lastPartContents[lastPartContentLength -1];
filename = name + "." +extension;
System.out.println("Name: " + name);
System.out.println("Extension: " + extension);
System.out.println("Filename: " + filename);
}
}
return filename;
}
Get Fichier Nom avec extension, sans extension, extension uniquement avec seulement 3 lignes:
String urlStr = "http://www.example.com/yourpath/foler/test.png";
String fileName = urlStr.substring(urlStr.lastIndexOf('/')+1, urlStr.length());
String fileNameWithoutExtension = fileName.substring(0, fileName.lastIndexOf('.'));
String fileExtension = urlStr.substring(urlStr.lastIndexOf("."));
Log.i("File Name", fileName);
Log.i("File Name Without Extension", fileNameWithoutExtension);
Log.i("File Extension", fileExtension);
Résultat du journal:
File Name(13656): test.png
File Name Without Extension(13656): test
File Extension(13656): .png
J'espère que cela vous aidera.
Je suis venu avec ceci:
String url = "http://www.example.com/some/path/to/a/file.xml";
String file = url.substring(url.lastIndexOf('/')+1, url.lastIndexOf('.'));
Rester simple :
/**
* This function will take an URL as input and return the file name.
* <p>Examples :</p>
* <ul>
* <li>http://example.com/a/b/c/test.txt -> test.txt</li>
* <li>http://example.com/ -> an empty string </li>
* <li>http://example.com/test.txt?param=value -> test.txt</li>
* <li>http://example.com/test.txt#anchor -> test.txt</li>
* </ul>
*
* @param url The input URL
* @return The URL file name
*/
public static String getFileNameFromUrl(URL url) {
String urlString = url.getFile();
return urlString.substring(urlString.lastIndexOf('/') + 1).split("\\?")[0].split("#")[0];
}
String fileName = url.substring(url.lastIndexOf('/') + 1);
Bon mot:
new File(uri.getPath).getName
Code complet:
import Java.io.File
import Java.net.URI
val uri = new URI("http://example.org/file.txt?whatever")
new File(uri.getPath).getName
res18: String = file.txt
Note: URI#gePath est déjà suffisamment intelligent pour supprimer les paramètres de requête et le schéma du protocole. Exemples:
new URI("http://example.org/hey/file.txt?whatever").getPath
res20: String = /hey/file.txt
new URI("hdfs:///hey/file.txt").getPath
res21: String = /hey/file.txt
new URI("file:///hey/file.txt").getPath
res22: String = /hey/file.txt
Voici le moyen le plus simple de le faire sous Android. Je sais que cela ne fonctionnera pas dans Java mais cela peut aider Android développeur de l'application.
import Android.webkit.URLUtil;
public String getFileNameFromURL(String url) {
String fileNameWithExtension = null;
String fileNameWithoutExtension = null;
if (URLUtil.isValidUrl(url)) {
fileNameWithExtension = URLUtil.guessFileName(url, null, null);
if (fileNameWithExtension != null && !fileNameWithExtension.isEmpty()) {
String[] f = fileNameWithExtension.split(".");
if (f != null & f.length > 1) {
fileNameWithoutExtension = f[0];
}
}
}
return fileNameWithoutExtension;
}
Il y a quelques façons:
E/S de fichier Java 7:
String fileName = Paths.get(strUrl).getFileName().toString();
Apache Commons:
String fileName = FilenameUtils.getName(strUrl);
en utilisant Jersey:
UriBuilder buildURI = UriBuilder.fromUri(strUrl);
URI uri = buildURI.build();
String fileName = Paths.get(uri.getPath()).getFileName();
Substring:
String fileName = strUrl.substring(strUrl.lastIndexOf('/') + 1);
Créez un objet URL à partir de la chaîne. Lorsque vous avez un objet URL pour la première fois, il existe des méthodes pour extraire facilement n’importe quel extrait d’information dont vous avez besoin.
Je peux fortement recommander le site Web Javaalmanac qui contient de nombreux exemples, mais qui a changé depuis. Vous pourriez trouver http://exampledepot.8waytrips.com/egs/Java.io/File2Uri.html intéressant:
// Create a file object
File file = new File("filename");
// Convert the file object to a URL
URL url = null;
try {
// The file need not exist. It is made into an absolute path
// by prefixing the current working directory
url = file.toURL(); // file:/d:/almanac1.4/Java.io/filename
} catch (MalformedURLException e) {
}
// Convert the URL to a file object
file = new File(url.getFile()); // d:/almanac1.4/Java.io/filename
// Read the file contents using the URL
try {
// Open an input stream
InputStream is = url.openStream();
// Read from is
is.close();
} catch (IOException e) {
// Could not open the file
}
Si vous souhaitez obtenir uniquement le nom de fichier depuis un fichier Java.net.URL (sans paramètres de requête), vous pouvez utiliser la fonction suivante:
public static String getFilenameFromURL(URL url) {
return new File(url.getPath().toString()).getName();
}
Par exemple, cette URL d'entrée:
"http://example.com/image.png?version=2&modificationDate=1449846324000"
Serait traduit en cette chaîne de sortie:
image.png
J'ai trouvé que certaines URL étaient passées directement à FilenameUtils.getName renvoie des résultats non désirés, qui doivent être résumés pour éviter les exploits.
Par exemple,
System.out.println(FilenameUtils.getName("http://www.google.com/.."));
résultats
..
je doute que quiconque veuille accepter.
La fonction suivante semble fonctionner correctement et montre certains de ces cas de test. Elle renvoie null lorsque le nom du fichier ne peut pas être déterminé.
public static String getFilenameFromUrl(String url)
{
if (url == null)
return null;
try
{
// Add a protocol if none found
if (! url.contains("//"))
url = "http://" + url;
URL uri = new URL(url);
String result = FilenameUtils.getName(uri.getPath());
if (result == null || result.isEmpty())
return null;
if (result.contains(".."))
return null;
return result;
}
catch (MalformedURLException e)
{
return null;
}
}
Ceci est résumé avec quelques cas de tests simples dans l'exemple suivant:
import Java.util.Objects;
import Java.net.URL;
import org.Apache.commons.io.FilenameUtils;
class Main {
public static void main(String[] args) {
validateFilename(null, null);
validateFilename("", null);
validateFilename("www.google.com/../me/you?trex=5#sdf", "you");
validateFilename("www.google.com/../me/you?trex=5 is the num#sdf", "you");
validateFilename("http://www.google.com/test.png?test", "test.png");
validateFilename("http://www.google.com", null);
validateFilename("http://www.google.com#test", null);
validateFilename("http://www.google.com////", null);
validateFilename("www.google.com/..", null);
validateFilename("http://www.google.com/..", null);
validateFilename("http://www.google.com/test", "test");
validateFilename("https://www.google.com/../../test.png", "test.png");
validateFilename("file://www.google.com/test.png", "test.png");
validateFilename("file://www.google.com/../me/you?trex=5", "you");
validateFilename("file://www.google.com/../me/you?trex", "you");
}
private static void validateFilename(String url, String expectedFilename){
String actualFilename = getFilenameFromUrl(url);
System.out.println("");
System.out.println("url:" + url);
System.out.println("filename:" + expectedFilename);
if (! Objects.equals(actualFilename, expectedFilename))
throw new RuntimeException("Problem, actual=" + actualFilename + " and expected=" + expectedFilename + " are not equal");
}
public static String getFilenameFromUrl(String url)
{
if (url == null)
return null;
try
{
// Add a protocol if none found
if (! url.contains("//"))
url = "http://" + url;
URL uri = new URL(url);
String result = FilenameUtils.getName(uri.getPath());
if (result == null || result.isEmpty())
return null;
if (result.contains(".."))
return null;
return result;
}
catch (MalformedURLException e)
{
return null;
}
}
}
Les urls peuvent avoir des paramètres à la fin, ceci
/**
* Getting file name from url without extension
* @param url string
* @return file name
*/
public static String getFileName(String url) {
String fileName;
int slashIndex = url.lastIndexOf("/");
int qIndex = url.lastIndexOf("?");
if (qIndex > slashIndex) {//if has parameters
fileName = url.substring(slashIndex + 1, qIndex);
} else {
fileName = url.substring(slashIndex + 1);
}
if (fileName.contains(".")) {
fileName = fileName.substring(0, fileName.lastIndexOf("."));
}
return fileName;
}
L'objet Url dans rllib vous permet d'accéder au nom de fichier non échappé du chemin. Voici quelques exemples:
String raw = "http://www.example.com/some/path/to/a/file.xml";
assertEquals("file.xml", Url.parse(raw).path().filename());
raw = "http://www.example.com/files/r%C3%A9sum%C3%A9.pdf";
assertEquals("résumé.pdf", Url.parse(raw).path().filename());
Pour renvoyer le nom de fichier sans extension et sans paramètre, utilisez ce qui suit:
String filenameWithParams = FilenameUtils.getBaseName(urlStr); // may hold params if http://example.com/a?param=yes
return filenameWithParams.split("\\?")[0]; // removing parameters from url if they exist
Afin de retourner nom du fichier avec extension sans params utilisez ceci:
/** Parses a URL and extracts the filename from it or returns an empty string (if filename is non existent in the url) <br/>
* This method will work in win/unix formats, will work with mixed case of slashes (forward and backward) <br/>
* This method will remove parameters after the extension
*
* @param urlStr original url string from which we will extract the filename
* @return filename from the url if it exists, or an empty string in all other cases */
private String getFileNameFromUrl(String urlStr) {
String baseName = FilenameUtils.getBaseName(urlStr);
String extension = FilenameUtils.getExtension(urlStr);
try {
extension = extension.split("\\?")[0]; // removing parameters from url if they exist
return baseName.isEmpty() ? "" : baseName + "." + extension;
} catch (NullPointerException npe) {
return "";
}
}
public String getFileNameWithoutExtension(URL url) {
String path = url.getPath();
if (StringUtils.isBlank(path)) {
return null;
}
if (StringUtils.endsWith(path, "/")) {
//is a directory ..
return null;
}
File file = new File(url.getPath());
String fileNameWithExt = file.getName();
int sepPosition = fileNameWithExt.lastIndexOf(".");
String fileNameWithOutExt = null;
if (sepPosition >= 0) {
fileNameWithOutExt = fileNameWithExt.substring(0,sepPosition);
}else{
fileNameWithOutExt = fileNameWithExt;
}
return fileNameWithOutExt;
}
J'ai le même problème, avec le tien. Je l'ai résolu par ceci:
var URL = window.location.pathname; // Gets page name
var page = URL.substring(URL.lastIndexOf('/') + 1);
console.info(page)
Au-delà des méthodes toutes avancées, mon astuce simple est StringTokenizer:
import Java.util.ArrayList;
import Java.util.StringTokenizer;
public class URLName {
public static void main(String args[]){
String url = "http://www.example.com/some/path/to/a/file.xml";
StringTokenizer tokens = new StringTokenizer(url, "/");
ArrayList<String> parts = new ArrayList<>();
while(tokens.hasMoreTokens()){
parts.add(tokens.nextToken());
}
String file = parts.get(parts.size() -1);
int dot = file.indexOf(".");
String fileName = file.substring(0, dot);
System.out.println(fileName);
}
}
la réponse d'Andy a été refaite avec split ():
Url u= ...;
String[] pathparts= u.getPath().split("\\/");
String filename= pathparts[pathparts.length-1].split("\\.", 1)[0];
Que dis-tu de ça:
String filenameWithoutExtension = null;
String fullname = new File(
new URI("http://www.xyz.com/some/deep/path/to/abc.png").getPath()).getName();
int lastIndexOfDot = fullname.lastIndexOf('.');
filenameWithoutExtension = fullname.substring(0,
lastIndexOfDot == -1 ? fullname.length() : lastIndexOfDot);