创建文件时出现Android fileNotFoundException

由于某些原因，Android在文件名前面加了“/”，这是一个问题，因为这样，我就无法访问该文件，因为出现以下错误：

该文件位于/data/data/tk.yteditors.london2013/files/

如何解决此问题并防止File类在文件前面添加“/”

如果你需要更多的细节，尽管问

01-23 16:59:15.174: W/System.err(26732): java.io.FileNotFoundException: /1043005842.html: open failed: ENOENT (No such file or directory)
01-23 16:59:15.204: W/System.err(26732):    at libcore.io.IoBridge.open(IoBridge.java:416)
01-23 16:59:15.204: W/System.err(26732):    at java.io.FileInputStream.<init>(FileInputStream.java:78)
01-23 16:59:15.214: W/System.err(26732):    at java.io.FileInputStream.<init>(FileInputStream.java:105)
01-23 16:59:15.214: W/System.err(26732):    at tk.yteditors.london2013.lib.ftp.SimpleFTP.stor(SimpleFTP.java:151)
01-23 16:59:15.214: W/System.err(26732):    at tk.yteditors.london2013.ConfirmActivity.sendFtp(ConfirmActivity.java:109)
01-23 16:59:15.214: W/System.err(26732):    at tk.yteditors.london2013.ConfirmActivity$1.run(ConfirmActivity.java:92)
01-23 16:59:15.214: W/System.err(26732):    at java.lang.Thread.run(Thread.java:856)
01-23 16:59:15.224: W/System.err(26732): Caused by: libcore.io.ErrnoException: open failed: ENOENT (No such file or directory)
01-23 16:59:15.224: W/System.err(26732):    at libcore.io.Posix.open(Native Method)
01-23 16:59:15.224: W/System.err(26732):    at libcore.io.BlockGuardOs.open(BlockGuardOs.java:110)
01-23 16:59:15.224: W/System.err(26732):    at libcore.io.IoBridge.open(IoBridge.java:400)
01-23 16:59:15.224: W/System.err(26732):    ... 6 more

01-23 16:59:15.174:W/System.err（26732）：java.io.FileNotFoundException:/1043005842.html:open failed:enoint（没有这样的文件或目录）
01-23 16:59:15.204:W/System.err（26732）：位于libcore.io.IoBridge.open（IoBridge.java:416）
01-23 16:59:15.204:W/System.err（26732）：位于java.io.FileInputStream。（FileInputStream.java:78）
01-23 16:59:15.214:W/System.err（26732）：位于java.io.FileInputStream。（FileInputStream.java:105）
01-23 16:59:15.214:W/System.err（26732）：位于tk.yteditors.london2013.lib.ftp.SimpleFTP.stor（SimpleFTP.java:151）
01-23 16:59:15.214:W/System.err（26732）：在tk.yteditors.london2013.confiractive.sendFtp（confiractive.java:109）
01-23 16:59:15.214:W/System.err（26732）：在伦敦2013年的tk.yteditors.confirActivity$1.run（confirActivity.java:92）
01-23 16:59:15.214:W/System.err（26732）：位于java.lang.Thread.run（Thread.java:856）
01-23 16:59:15.224:W/System.err（26732）：原因：libcore.io.ErrnoException:open失败：enoint（没有这样的文件或目录）
01-23 16:59:15.224:W/System.err（26732）：位于libcore.io.Posix.open（本机方法）
01-23 16:59:15.224:W/System.err（26732）：位于libcore.io.BlockGuardOs.open（BlockGuardOs.java:110）
01-23 16:59:15.224:W/System.err（26732）：位于libcore.io.IoBridge.open（IoBridge.java:400）
01-23 16:59:15.224:W/系统错误（26732）：。。。还有6个

激活器代码：

public void sendFtp() throws Exception{
    SimpleFTP ftp = new SimpleFTP();
    ftp.connect("<SECRET_IP>", 21, "<SECRET_UN>", "<SECRET_PASS>");
    ftp.bin();
    ftp.stor(new File(getIntent().getExtras().getString("fileName")));
    ftp.disconnect();
}

public void sendFtp（）引发异常{
SimpleFTP ftp=新的SimpleFTP（）；
连接（“，21，”，“）；
ftp.bin（）；
stor（新文件（getIntent（）.getExtras（）.getString（“文件名”））；
ftp.disconnect（）；
}

其他代码：

package tk.yteditors.london2013.lib.ftp;

import java.io.*;
import java.net.*;
import java.util.*;


/**
 * SimpleFTP is a simple package that implements a Java FTP client.
 * With SimpleFTP, you can connect to an FTP server and upload multiple files.
 *  <p>
 * Copyright Paul Mutton,
 *           <a href="http://www.jibble.org/">http://www.jibble.org/</a>
 * 
 */
public class SimpleFTP {


/**
 * Create an instance of SimpleFTP.
 */
public SimpleFTP() {

}


/**
 * Connects to the default port of an FTP server and logs in as
 * anonymous/anonymous.
 */
public synchronized void connect(String host) throws IOException {
    connect(host, 21);
}


/**
 * Connects to an FTP server and logs in as anonymous/anonymous.
 */
public synchronized void connect(String host, int port) throws IOException {
    connect(host, port, "anonymous", "anonymous");
}


/**
 * Connects to an FTP server and logs in with the supplied username
 * and password.
 */
public synchronized void connect(String host, int port, String user, String pass) throws IOException {
    if (socket != null) {
        throw new IOException("SimpleFTP is already connected. Disconnect first.");
    }
    socket = new Socket(host, port);
    reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

    String response = readLine();
    if (response.startsWith("220")) {

    } else{
        throw new IOException("SimpleFTP received an unknown response when connecting to the FTP server: " + response);
    }

    sendLine("USER " + user);

    response = readLine();
    if (!response.startsWith("331") && !response.startsWith("220")) {
        throw new IOException("SimpleFTP received an unknown response after sending the user: " + response);
    }

    sendLine("PASS " + pass);

    response = readLine();
    if (!response.startsWith("230") && !response.startsWith("220")) {
        throw new IOException("SimpleFTP was unable to log in with the supplied password: " + response);
    }

    // Now logged in.
}


/**
 * Disconnects from the FTP server.
 */
public synchronized void disconnect() throws IOException {
    try {
        sendLine("QUIT");
    }
    finally {
        socket = null;
    }
}


/**
 * Returns the working directory of the FTP server it is connected to.
 */
public synchronized String pwd() throws IOException {
    sendLine("PWD");
    String dir = null;
    String response = readLine();
    if (response.startsWith("257")) {
        int firstQuote = response.indexOf('\"');
        int secondQuote = response.indexOf('\"', firstQuote + 1);
        if (secondQuote > 0) {
            dir = response.substring(firstQuote + 1, secondQuote);
        }
    }
    return dir;
}


/**
 * Changes the working directory (like cd). Returns true if successful.
 */   
public synchronized boolean cwd(String dir) throws IOException {
    sendLine("CWD " + dir);
    String response = readLine();
    return (response.startsWith("250"));
}


/**
 * Sends a file to be stored on the FTP server.
 * Returns true if the file transfer was successful.
 * The file is sent in passive mode to avoid NAT or firewall problems
 * at the client end.
 */
public synchronized boolean stor(File file) throws IOException {
    if (file.isDirectory()) {
        throw new IOException("SimpleFTP cannot upload a directory.");
    }

    String filename = file.getName();

    return stor(new FileInputStream(file.getName()), filename);
}

/**
 * Sends a file to be stored on the FTP server.
 * Returns true if the file transfer was successful.
 * The file is sent in passive mode to avoid NAT or firewall problems
 * at the client end.
 */
public synchronized boolean stor(InputStream inputStream, String filename) throws IOException {

    BufferedInputStream input = new BufferedInputStream(inputStream);

    sendLine("PASV");
    String response = readLine();
    if (!response.startsWith("227")) {
        throw new IOException("SimpleFTP could not request passive mode: " + response);
    }

    String ip = null;
    int port = -1;
    int opening = response.indexOf('(');
    int closing = response.indexOf(')', opening + 1);
    if (closing > 0) {
        String dataLink = response.substring(opening + 1, closing);
        StringTokenizer tokenizer = new StringTokenizer(dataLink, ",");
        try {
            ip = tokenizer.nextToken() + "." + tokenizer.nextToken() + "." + tokenizer.nextToken() + "." + tokenizer.nextToken();
            port = Integer.parseInt(tokenizer.nextToken()) * 256 + Integer.parseInt(tokenizer.nextToken());
        }
        catch (Exception e) {
            throw new IOException("SimpleFTP received bad data link information: " + response);
        }
    }

    sendLine("STOR " + filename);

    Socket dataSocket = new Socket(ip, port);

    response = readLine();
    if (!response.startsWith("150")) {
        throw new IOException("SimpleFTP was not allowed to send the file: " + response);
    }

    BufferedOutputStream output = new BufferedOutputStream(dataSocket.getOutputStream());
    byte[] buffer = new byte[4096];
    int bytesRead = 0;
    while ((bytesRead = input.read(buffer)) != -1) {
        output.write(buffer, 0, bytesRead);
    }
    output.flush();
    output.close();
    input.close();

    response = readLine();
    return response.startsWith("226");
}


/**
 * Enter binary mode for sending binary files.
 */
public synchronized boolean bin() throws IOException {
    sendLine("TYPE I");
    String response = readLine();
    return (response.startsWith("200"));
}


/**
 * Enter ASCII mode for sending text files. This is usually the default
 * mode. Make sure you use binary mode if you are sending images or
 * other binary data, as ASCII mode is likely to corrupt them.
 */
public synchronized boolean ascii() throws IOException {
    sendLine("TYPE A");
    String response = readLine();
    return (response.startsWith("200"));
}


/**
 * Sends a raw command to the FTP server.
 */
private void sendLine(String line) throws IOException {
    if (socket == null) {
        throw new IOException("SimpleFTP is not connected.");
    }
    try {
        writer.write(line + "\r\n");
        writer.flush();
        if (DEBUG) {
            System.out.println("> " + line);
        }
    }
    catch (IOException e) {
        socket = null;
        throw e;
    }
}

private String readLine() throws IOException {
    String line = reader.readLine();
    if (DEBUG) {
        System.out.println("< " + line);
    }
    return line;
}

private Socket socket = null;
private BufferedReader reader = null;
private BufferedWriter writer = null;

private static boolean DEBUG = false;


}

包tk.yteditors.london2013.lib.ftp；
导入java.io.*；
导入java.net。*；
导入java.util.*；
/**
*SimpleFTP是一个实现Java FTP客户端的简单包。
*使用SimpleFTP，您可以连接到FTP服务器并上载多个文件。
*
*版权所有Paul Mutton，
*           
* 
*/
公共类SimpleFTP{
/**
*创建SimpleFTP的实例。
*/
公共SimpleFTP（）{
}
/**
*连接到FTP服务器的默认端口，并以
*匿名/匿名。
*/
公共同步的void connect（字符串主机）引发IOException{
连接（主机，21）；
}
/**
*连接到FTP服务器并以匿名/匿名身份登录。
*/
公共同步的void connect（字符串主机、int端口）引发IOException{
连接（主机、端口、“匿名”、“匿名”）；
}
/**
*连接到FTP服务器并使用提供的用户名登录
*和密码。
*/
公共同步的void connect（字符串主机、int端口、字符串用户、字符串传递）引发IOException{
if（套接字！=null）{
抛出新IOException（“SimpleFTP已连接。请先断开连接”）；
}
套接字=新套接字（主机、端口）；
reader=new BufferedReader（new InputStreamReader（socket.getInputStream（））；
writer=newbufferedwriter（newoutputstreamwriter（socket.getOutputStream（））；
字符串响应=readLine（）；
if（响应。启动时使用（“220”））{
}否则{
抛出新IOException（“SimpleFTP在连接到FTP服务器时收到未知响应：“+response”）；
}
发送线（“用户”+用户）；
response=readLine（）；
如果（！response.startsWith（“331”）和&！response.startsWith（“220”））{
抛出新IOException（“SimpleFTP在发送用户：“+response”后收到未知响应）；
}
发送线（“通过”+通过）；
response=readLine（）；
如果（！response.startsWith（“230”）和&！response.startsWith（“220”））{
抛出新IOException（“SimpleFTP无法使用提供的密码登录：“+响应”）；
}
//现在登录。
}
/**
*断开与FTP服务器的连接。
*/
公共同步的void disconnect（）引发IOException{
试一试{
发送线（“退出”）；
}
最后{
socket=null；
}
}
/**
*返回连接到的FTP服务器的工作目录。
*/
公共同步字符串pwd（）引发IOException{
发送线（“PWD”）；
字符串dir=null；
字符串响应=readLine（）；
if（response.startsWith（“257”））{
int firstQuote=response.indexOf（“\”）；
int secondQuote=response.indexOf（“\”，firstQuote+1）；
如果（第二个报价>0）{
dir=response.substring（第一个引号+1，第二个引号）；
}
}
返回目录；
}
/**
*更改工作目录（如cd）。如果成功，则返回true。
*/   
公共同步布尔cwd（字符串目录）引发IOException{
发送线（“CWD”+dir）；
字符串响应=readLine（）；
返回（response.startsWith（“250”））；
}
/**
*发送要存储在FTP服务器上的文件。
*如果文件传输成功，则返回true。
*文件以被动模式发送，以避免NAT或防火墙问题
*在客户端。
*/
公共同步布尔存储（文件）引发IOException{
if（file.isDirectory（））{
抛出新IOException（“SimpleFTP无法上载目录”）；
}
字符串文件名=file.getName（）；
返回stor（新文件输入流（file.getName（）），文件名）；
}
/**
*发送要存储在FTP服务器上的文件。
*如果文件传输成功，则返回true。
*文件以被动模式发送，以避免NAT或防火墙问题
*在客户端。
*/
公共同步布尔存储（InputStream InputStream，字符串文件名）引发IOException{
BufferedInputStream输入=新的BufferedInputStream（inputStream）；
发送线（“PASV”）；
字符串响应=readLine（）；
如果（！response.startsWith（“227”））{
抛出新IOException（“SimpleFTP无法请求被动模式：”