Obter nome de arquivo da URL
Pergunta
Em Java, dado um java.net.URL
ou um String
na forma de http://www.example.com/some/path/to/a/file.xml
, qual é a maneira mais fácil de obter o nome do arquivo, menos a extensão? Assim, neste exemplo, eu estou procurando algo que os retornos "file"
.
Não consigo pensar em várias maneiras de fazer isso, mas eu estou procurando algo que é fácil de ler e curto.
Solução
Em vez de reinventar a roda, como sobre o uso do 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
}
}
Outras dicas
String fileName = url.substring( url.lastIndexOf('/')+1, url.length() );
String fileNameWithoutExtn = fileName.substring(0, fileName.lastIndexOf('.'));
Isso deve cerca de cortá-lo (eu vou deixar o tratamento de erros para você):
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);
}
Se você não precisa se livrar da extensão de arquivo, aqui está uma maneira de fazê-lo sem recorrer à manipulação de Cordas propenso a erros e sem o uso de bibliotecas externas. Funciona com 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 Arquivo nome com extensão , sem extensão , apenas a extensão com apenas 3 linha:
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);
registro de resultado:
File Name(13656): test.png
File Name Without Extension(13656): test
File Extension(13656): .png
Hope vai ajudá-lo.
Eu vim acima com este:
String url = "http://www.example.com/some/path/to/a/file.xml";
String file = url.substring(url.lastIndexOf('/')+1, url.lastIndexOf('.'));
Mantenha-o simples:
/**
* 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);
Um liner:
new File(uri.getPath).getName
código completo:
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
Nota ??strong>: URI#gePath
já é suficiente inteligente para retirar parâmetros de consulta e esquema do protocolo. Exemplos:
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
Aqui é a maneira mais simples de fazê-lo em Android. Eu sei que não vai trabalhar em Java, mas pode ajudar a desenvolvedor de aplicativos Android.
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;
}
Criar um objeto URL da cadeia. Quando pela primeira vez que você tem um objeto URL existem métodos para facilmente retirar praticamente qualquer trecho de informação que você precisa.
Posso altamente recomendável o site Javaalmanac que tem toneladas de exemplos, mas que, desde então, mudou-se. Você pode achar http://exampledepot.8waytrips.com/egs/java.io /File2Uri.html interessante:
// 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
}
Existem algumas maneiras:
Java 7 File I / O:
String fileName = Paths.get(strUrl).getFileName().toString();
Apache Commons:
String fileName = FilenameUtils.getName(strUrl);
Usando 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);
Se você quiser obter apenas o nome do arquivo a partir de um java.net.URL (não incluindo quaisquer parâmetros de consulta), você poderia usar a seguinte função:
public static String getFilenameFromURL(URL url) {
return new File(url.getPath().toString()).getName();
}
Por exemplo, este URL de entrada:
"http://example.com/image.png?version=2&modificationDate=1449846324000"
seria traduzido a esta cadeia de saída:
image.png
Descobri que algumas urls quando passaram diretamente para FilenameUtils.getName
retorno resultados indesejados e isso precisa ser embrulhado para exploits Evitar.
Por exemplo,
System.out.println(FilenameUtils.getName("http://www.google.com/.."));
volta ??p>
..
que eu duvido que alguém quer permitir.
A função a seguir parece funcionar bem, e mostra alguns desses casos de teste, e ele retorna null
quando o nome do arquivo não pode ser determinado.
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;
}
}
Este é embrulhado com alguns simples casos testes no exemplo a seguir:
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;
}
}
}
URLs podem ter parâmetros no final, este
/**
* 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;
}
O objeto Url
em urllib permite que você acesse filename unescaped do caminho. Aqui estão alguns exemplos:
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());
resposta refeito de Andy usando split ():
Url u= ...;
String[] pathparts= u.getPath().split("\\/");
String filename= pathparts[pathparts.length-1].split("\\.", 1)[0];
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;
}
Como sobre isto:
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);
Para filename retorno sem extensão e sem parâmetros use o seguinte:
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
A fim de retorno nome de arquivo com extensão sem parâmetros usar este:
/** 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 "";
}
}
Para além do todos os métodos avançados, meu truque simples é 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);
}
}
Eu tenho o mesmo problema, com o seu. Eu resolvi por isso:
var URL = window.location.pathname; // Gets page name
var page = URL.substring(URL.lastIndexOf('/') + 1);
console.info(page)
create a new file with string image path
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 "";
}
}
importação java.io *;.
import java.net.*;
public class ConvertURLToFileName{
public static void main(String[] args)throws IOException{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Please enter the URL : ");
String str = in.readLine();
try{
URL url = new URL(str);
System.out.println("File : "+ url.getFile());
System.out.println("Converting process Successfully");
}
catch (MalformedURLException me){
System.out.println("Converting process error");
}
Espero que isso irá ajudá-lo.