关于Java文件路径问题

1.如何获得当前文件路径

常用：

字符串类型：System.getProperty("user.dir");

综合：

1. package com.zcjl.test.base;
2. import java.io.File;
3. public class Test {
4.     public static void main(String[] args) throws Exception {
5.         System.out.println(
6.             Thread.currentThread().getContextClassLoader().getResource(""));
7.         System.out.println(Test.class.getClassLoader().getResource(""));
8.         System.out.println(ClassLoader.getSystemResource(""));
9.         System.out.println(Test.class.getResource(""));
10.         System.out.println(Test.class.getResource("/"));
11.         System.out.println(new File("").getAbsolutePath());
12.         System.out.println(System.getProperty("user.dir"));
13.     }
14. }

 

2.Web服务中

(1).Weblogic

WebApplication的系统文件根目录是你的weblogic安装所在根目录。
例如：如果你的weblogic安装在c:/bea/weblogic700.....
那么，你的文件根路径就是c:/.
所以，有两种方式能够让你访问你的服务器端的文件：
a.使用绝对路径：
比如将你的参数文件放在c:/yourconfig/yourconf.properties，
直接使用 new FileInputStream("yourconfig/yourconf.properties");
b.使用相对路径：
相对路径的根目录就是你的webapplication的根路径，即WEB-INF的上一级目录，将你的参数文件放在yourwebapp/yourconfig/yourconf.properties，
这样使用：
new FileInputStream("./yourconfig/yourconf.properties");
这两种方式均可，自己选择。

(2).Tomcat

在类中输出System.getProperty("user.dir");显示的是%Tomcat_Home%/bin

(3).Resin

不是你的JSP放的相对路径,是JSP引擎执行这个JSP编译成SERVLET
的路径为根.比如用新建文件法测试File f = new File("a.htm");
这个a.htm在resin的安装目录下

(4).如何读相对路径哪？

在Java文件中getResource或getResourceAsStream均可

例：getClass().getResourceAsStream(filePath);//filePath可以是"/filename",这里的/代表web发布根路径下WEB-INF/classes

(5).获得文件真实路径

string  file_real_path=request.getRealPath("mypath/filename"); 

通常使用request.getRealPath("/"); 

3.文件操作的类

1. import java.io.*;
2. import java.net.*;
3. import java.util.*;
5. //import javax.swing.filechooser.*;
6. //import org.jr.swing.filter.*;
8. /**
9.  * 此类中封装一些常用的文件操作。 所有方法都是静态方法，不需要生成此类的实例， 为避免生成此类的实例，构造方法被申明为private类型的。
10.  * 
11.  * @since 0.1
12.  */
14. public class FileUtil {
15.     /**
16.      * 私有构造方法，防止类的实例化，因为工具类不需要实例化。
17.      */
18.     private FileUtil() {
20.     }
22.     /**
23.      * 修改文件的最后访问时间。 如果文件不存在则创建该文件。 <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考
24.      * 
25.      * 虑中。</b>
26.      * 
27.      * @param file
28.      *            需要修改最后访问时间的文件。
29.      * @since 0.1
30.      */
31.     public static void touch(File file) {
32.         long currentTime = System.currentTimeMillis();
33.         if (!file.exists()) {
34.             System.err.println("file not found:" + file.getName());
35.             System.err.println("Create a new file:" + file.getName());
36.             try {
37.                 if (file.createNewFile()) {
38.                     // System.out.println("Succeeded!");
39.                 } else {
40.                     // System.err.println("Create file failed!");
41.                 }
42.             } catch (IOException e) {
43.                 // System.err.println("Create file failed!");
44.                 e.printStackTrace();
45.             }
46.         }
47.         boolean result = file.setLastModified(currentTime);
48.         if (!result) {
49.             // System.err.println("touch failed: " + file.getName());
50.         }
51.     }
53.     /**
54.      * 修改文件的最后访问时间。 如果文件不存在则创建该文件。 <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考
55.      * 
56.      * 虑中。</b>
57.      * 
58.      * @param fileName
59.      *            需要修改最后访问时间的文件的文件名。
60.      * @since 0.1
61.      */
62.     public static void touch(String fileName) {
63.         File file = new File(fileName);
64.         touch(file);
65.     }
67.     /**
68.      * 修改文件的最后访问时间。 如果文件不存在则创建该文件。 <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考
69.      * 
70.      * 虑中。</b>
71.      * 
72.      * @param files
73.      *            需要修改最后访问时间的文件数组。
74.      * @since 0.1
75.      */
76.     public static void touch(File[] files) {
77.         for (int i = 0; i < files.length; i++) {
78.             touch(files);
79.         }
80.     }
82.     /**
83.      * 修改文件的最后访问时间。 如果文件不存在则创建该文件。 <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考
84.      * 
85.      * 虑中。</b>
86.      * 
87.      * @param fileNames
88.      *            需要修改最后访问时间的文件名数组。
89.      * @since 0.1
90.      */
91.     public static void touch(String[] fileNames) {
92.         File[] files = new File[fileNames.length];
93.         for (int i = 0; i < fileNames.length; i++) {
94.             files[i] = new File(fileNames[i]);
95.         }
96.         touch(files);
97.     }
99.     /**
100.      * 判断指定的文件是否存在。
101.      * 
102.      * @param fileName
103.      *            要判断的文件的文件名
104.      * @return 存在时返回true，否则返回false。
105.      * @since 0.1
106.      */
107.     public static boolean isFileExist(String fileName) {
108.         return new File(fileName).isFile();
109.     }
111.     /**
112.      * 创建指定的目录。 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。 <b>注意：可能会在返回false的时候创建部分父目录。</b>
113.      * 
114.      * @param file
115.      *            要创建的目录
116.      * @return 完全创建成功时返回true，否则返回false。
117.      * @since 0.1
118.      */
119.     public static boolean makeDirectory(File file) {
120.         File parent = file.getParentFile();
121.         if (parent != null) {
122.             return parent.mkdirs();
123.         }
124.         return false;
125.     }
127.     /**
128.      * 创建指定的目录。 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。 <b>注意：可能会在返回false的时候创建部分父目录。</b>
129.      * 
130.      * @param fileName
131.      *            要创建的目录的目录名
132.      * @return 完全创建成功时返回true，否则返回false。
133.      * @since 0.1
134.      */
135.     public static boolean makeDirectory(String fileName) {
136.         File file = new File(fileName);
137.         return makeDirectory(file);
138.     }
140.     /**
141.      * 清空指定目录中的文件。 这个方法将尽可能删除所有的文件，但是只要有一个文件没有被删除都会返回false。
142.      * 另外这个方法不会迭代删除，即不会删除子目录及其内容。
143.      * 
144.      * @param directory
145.      *            要清空的目录
146.      * @return 目录下的所有文件都被成功删除时返回true，否则返回false.
147.      * @since 0.1
148.      */
149.     public static boolean emptyDirectory(File directory) {
150.         boolean result = false;
151.         File[] entries = directory.listFiles();
152.         for (int i = 0; i < entries.length; i++) {
153.             if (!entries[i].delete()) {
154.                 result = false;
155.             }
156.         }
157.         return true;
158.     }
160.     /**
161.      * 清空指定目录中的文件。 这个方法将尽可能删除所有的文件，但是只要有一个文件没有被删除都会返回false。
162.      * 另外这个方法不会迭代删除，即不会删除子目录及其内容。
163.      * 
164.      * @param directoryName
165.      *            要清空的目录的目录名
166.      * @return 目录下的所有文件都被成功删除时返回true，否则返回false。
167.      * @since 0.1
168.      */
169.     public static boolean emptyDirectory(String directoryName) {
170.         File dir = new File(directoryName);
171.         return emptyDirectory(dir);
172.     }
174.     /**
175.      * 删除指定目录及其中的所有内容。
176.      * 
177.      * @param dirName
178.      *            要删除的目录的目录名
179.      * @return 删除成功时返回true，否则返回false。
180.      * @since 0.1
181.      */
182.     public static boolean deleteDirectory(String dirName) {
183.         return deleteDirectory(new File(dirName));
184.     }
186.     /**
187.      * 删除指定目录及其中的所有内容。
188.      * 
189.      * @param dir
190.      *            要删除的目录
191.      * @return 删除成功时返回true，否则返回false。
192.      * @since 0.1
193.      */
194.     public static boolean deleteDirectory(File dir) {
195.         if ((dir == null) || !dir.isDirectory()) {
196.             throw new IllegalArgumentException("Argument " + dir
197.                     + " is not a directory. ");
198.         }
200.         File[] entries = dir.listFiles();
201.         int sz = entries.length;
203.         for (int i = 0; i < sz; i++) {
204.             if (entries[i].isDirectory()) {
205.                 if (!deleteDirectory(entries[i])) {
206.                     return false;
207.                 }
208.             } else {
209.                 if (!entries[i].delete()) {
210.                     return false;
211.                 }
212.             }
213.         }
215.         if (!dir.delete()) {
216.             return false;
217.         }
218.         return true;
219.     }
221.     /**
222.      * 返回文件的URL地址。
223.      * 
224.      * @param file
225.      *            文件
226.      * @return 文件对应的的URL地址
227.      * @throws MalformedURLException
228.      * @since 0.4
229.      * @deprecated 在实现的时候没有注意到File类本身带一个toURL方法将文件路径转换为URL。 请使用File.toURL方法。
230.      */
231.     public static URL getURL(File file) throws MalformedURLException {
232.         String fileURL = "file:/" + file.getAbsolutePath();
233.         URL url = new URL(fileURL);
234.         return url;
235.     }
237.     /**
238.      * 从文件路径得到文件名。
239.      * 
240.      * @param filePath
241.      *            文件的路径，可以是相对路径也可以是绝对路径
242.      * @return 对应的文件名
243.      * @since 0.4
244.      */
245.     public static String getFileName(String filePath) {
246.         File file = new File(filePath);
247.         return file.getName();
248.     }
250.     /**
251.      * 从文件名得到文件绝对路径。
252.      * 
253.      * @param fileName
254.      *            文件名
255.      * @return 对应的文件路径
256.      * @since 0.4
257.      */
258.     public static String getFilePath(String fileName) {
259.         File file = new File(fileName);
260.         return file.getAbsolutePath();
261.     }
263.     /**
264.      * 将DOS/Windows格式的路径转换为UNIX/Linux格式的路径。
265.      * 其实就是将路径中的"/"全部换为"/"，因为在某些情况下我们转换为这种方式比较方便，
266.      * 某中程度上说"/"比"/"更适合作为路径分隔符，而且DOS/Windows也将它当作路径分隔符。
267.      * 
268.      * @param filePath
269.      *            转换前的路径
270.      * @return 转换后的路径
271.      * @since 0.4
272.      */
273.     public static String toUNIXpath(String filePath) {
274.         return filePath.replace('//', '/');
275.     }
277.     /**
278.      * 从文件名得到UNIX风格的文件绝对路径。
279.      * 
280.      * @param fileName
281.      *            文件名
282.      * @return 对应的UNIX风格的文件路径
283.      * @since 0.4
284.      * @see #toUNIXpath(String filePath) toUNIXpath
285.      */
286.     public static String getUNIXfilePath(String fileName) {
287.         File file = new File(fileName);
288.         return toUNIXpath(file.getAbsolutePath());
289.     }
291.     /**
292.      * 得到文件的类型。 实际上就是得到文件名中最后一个“.”后面的部分。
293.      * 
294.      * @param fileName
295.      *            文件名
296.      * @return 文件名中的类型部分
297.      * @since 0.5
298.      */
299.     public static String getTypePart(String fileName) {
300.         int point = fileName.lastIndexOf('.');
301.         int length = fileName.length();
302.         if (point == -1 || point == length - 1) {
303.             return "";
304.         } else {
305.             return fileName.substring(point + 1, length);
306.         }
307.     }
309.     /**
310.      * 得到文件的类型。 实际上就是得到文件名中最后一个“.”后面的部分。
311.      * 
312.      * @param file
313.      *            文件
314.      * @return 文件名中的类型部分
315.      * @since 0.5
316.      */
317.     public static String getFileType(File file) {
318.         return getTypePart(file.getName());
319.     }
321.     /**
322.      * 得到文件的名字部分。 实际上就是路径中的最后一个路径分隔符后的部分。
323.      * 
324.      * @param fileName
325.      *            文件名
326.      * @return 文件名中的名字部分
327.      * @since 0.5
328.      */
329.     public static String getNamePart(String fileName) {
330.         int point = getPathLsatIndex(fileName);
331.         int length = fileName.length();
332.         if (point == -1) {
333.             return fileName;
334.         } else if (point == length - 1) {
335.             int secondPoint = getPathLsatIndex(fileName, point - 1);
336.             if (secondPoint == -1) {
337.                 if (length == 1) {
338.                     return fileName;
339.                 } else {
340.                     return fileName.substring(0, point);
341.                 }
342.             } else {
343.                 return fileName.substring(secondPoint + 1, point);
344.             }
345.         } else {
346.             return fileName.substring(point + 1);
347.         }
348.     }
350.     /**
351.      * 得到文件名中的父路径部分。 对两种路径分隔符都有效。 不存在时返回""。
352.      * 如果文件名是以路径分隔符结尾的则不考虑该分隔符，例如"/path/"返回""。
353.      * 
354.      * @param fileName
355.      *            文件名
356.      * @return 父路径，不存在或者已经是父目录时返回""
357.      * @since 0.5
358.      */
359.     public static String getPathPart(String fileName) {
360.         int point = getPathLsatIndex(fileName);
361.         int length = fileName.length();
362.         if (point == -1) {
363.             return "";
364.         } else if (point == length - 1) {
365.             int secondPoint = getPathLsatIndex(fileName, point - 1);
366.             if (secondPoint == -1) {
367.                 return "";
368.             } else {
369.                 return fileName.substring(0, secondPoint);
370.             }
371.         } else {
372.             return fileName.substring(0, point);
373.         }
374.     }
376.     /**
377.      * 得到路径分隔符在文件路径中首次出现的位置。 对于DOS或者UNIX风格的分隔符都可以。
378.      * 
379.      * @param fileName
380.      *            文件路径
381.      * @return 路径分隔符在路径中首次出现的位置，没有出现时返回-1。
382.      * @since 0.5
383.      */
384.     public static int getPathIndex(String fileName) {
385.         int point = fileName.indexOf('/');
386.         if (point == -1) {
387.             point = fileName.indexOf('//');
388.         }
389.         return point;
390.     }
392.     /**
393.      * 得到路径分隔符在文件路径中指定位置后首次出现的位置。 对于DOS或者UNIX风格的分隔符都可以。
394.      * 
395.      * @param fileName
396.      *            文件路径
397.      * @param fromIndex
398.      *            开始查找的位置
399.      * @return 路径分隔符在路径中指定位置后首次出现的位置，没有出现时返回-1。
400.      * @since 0.5
401.      */
402.     public static int getPathIndex(String fileName, int fromIndex) {
403.         int point = fileName.indexOf('/', fromIndex);
404.         if (point == -1) {
405.             point = fileName.indexOf('//', fromIndex);
406.         }
407.         return point;
408.     }
410.     /**
411.      * 得到路径分隔符在文件路径中最后出现的位置。 对于DOS或者UNIX风格的分隔符都可以。
412.      * 
413.      * @param fileName
414.      *            文件路径
415.      * @return 路径分隔符在路径中最后出现的位置，没有出现时返回-1。
416.      * @since 0.5
417.      */
418.     public static int getPathLsatIndex(String fileName) {
419.         int point = fileName.lastIndexOf('/');
420.         if (point == -1) {
421.             point = fileName.lastIndexOf('//');
422.         }
423.         return point;
424.     }
426.     /**
427.      * 得到路径分隔符在文件路径中指定位置前最后出现的位置。 对于DOS或者UNIX风格的分隔符都可以。
428.      * 
429.      * @param fileName
430.      *            文件路径
431.      * @param fromIndex
432.      *            开始查找的位置
433.      * @return 路径分隔符在路径中指定位置前最后出现的位置，没有出现时返回-1。
434.      * @since 0.5
435.      */
436.     public static int getPathLsatIndex(String fileName, int fromIndex) {
437.         int point = fileName.lastIndexOf('/', fromIndex);
438.         if (point == -1) {
439.             point = fileName.lastIndexOf('//', fromIndex);
440.         }
441.         return point;
442.     }
444.     /**
445.      * 将文件名中的类型部分去掉。
446.      * 
447.      * @param filename
448.      *            文件名
449.      * @return 去掉类型部分的结果
450.      * @since 0.5
451.      */
452.     public static String trimType(String filename) {
453.         int index = filename.lastIndexOf(".");
454.         if (index != -1) {
455.             return filename.substring(0, index);
456.         } else {
457.             return filename;
458.         }
459.     }
461.     /**
462.      * 得到相对路径。 文件名不是目录名的子节点时返回文件名。
463.      * 
464.      * @param pathName
465.      *            目录名
466.      * @param fileName
467.      *            文件名
468.      * @return 得到文件名相对于目录名的相对路径，目录下不存在该文件时返回文件名
469.      * @since 0.5
470.      */
471.     public static String getSubpath(String pathName, String fileName) {
472.         int index = fileName.indexOf(pathName);
473.         if (index != -1) {
474.             return fileName.substring(index + pathName.length() + 1);
475.         } else {
476.             return fileName;
477.         }
478.     }
480. }

 

4.遗留问题

目前new FileInputStream()只会使用绝对路径，相对没用过，因为要相对于web服务器地址，比较麻烦

还不如写个配置文件来的快哪

5.按Java文件类型分类读取配置文件

配 置文件是应用系统中不可缺少的，可以增加程序的灵活性。java.util.Properties是从jdk1.2就有的类，一直到现在都支持load ()方法，jdk1.4以后save(output,string) ->store(output,string)。如果只是单纯的读，根本不存在烦恼的问题。web层可以通过 Thread.currentThread().getContextClassLoader().
getResourceAsStream("xx.properties") 获取；Application可以通过new FileInputStream("xx.properties");直接在classes一级获取。关键是有时我们需要通过web修改配置文件，我们不 能将路径写死了。经过测试觉得有以下心得：

1.servlet中读写。如果运用Struts 或者Servlet可以直接在初始化参数中配置，调用时根据servlet的getRealPath("/")获取真实路径，再根据String file = this.servlet.getInitParameter("abc");获取相对的WEB-INF的相对路径。
例：
InputStream input = Thread.currentThread().getContextClassLoader().
getResourceAsStream("abc.properties");
Properties prop = new Properties();
prop.load(input);
input.close();
OutputStream out = new FileOutputStream(path);
prop.setProperty("abc", “test");
prop.store(out, “–test–");
out.close();

2.直接在jsp中操作，通过jsp内置对象获取可操作的绝对地址。
例：
// jsp页面
String path = pageContext.getServletContext().getRealPath("/");
String realPath = path+"/WEB-INF/classes/abc.properties";

//java 程序
InputStream in = getClass().getClassLoader().getResourceAsStream("abc.properties"); // abc.properties放在webroot/WEB-INF/classes/目录下
prop.load(in);
in.close();

OutputStream out = new FileOutputStream(path); // path为通过页面传入的路径
prop.setProperty("abc", “abcccccc");
prop.store(out, “–test–");
out.close();

3.只通过Java程序操作资源文件
InputStream in = new FileInputStream("abc.properties"); // 放在classes同级

OutputStream out = new FileOutputStream("abc.properties");

 

原文引自：http://java998.javaeye.com/blog/66474