1. import java.util.*;
   
2. import java.io.*;
   
3. class RunCount
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 Properties prop = new Properties();
   
8.                 File file = new File("count.ini");
   
9.                 if(!file.exists())
   
10.                 {
    
11.                         
    
12.                         try
    
13.                         {
    
14.                                 file.createNewFile();
    
15.                                 System.out.println("haha");
    
16.                         }
    
17.                         catch (IOException e)
    
18.                         {
    
19.                                 throw new RuntimeException(e.toString()+"yichang");
    
20.                         }
    
21.                         
    
22.                 }
    
23.                 FileInputStream fis = null;
    
24.                 FileOutputStream fos = null;
    
25.                 try
    
26.                 {
    
27.                         fis = new FileInputStream(file);
    
28.                         fos = new FileOutputStream(file);  //为什么我在这里new 一个FileOutput类. 就无法使文件持久化..
    
29.                 //        fos.write("temp=0".getBytes());
    
30.                         //fos.newLine();
    
31.                 //        fos.flush();
    
32.                         //System.out.println(fis.toString());
    
33.                         System.out.println(file.length());
    
34.                         prop.load(fis);
    
35.                         int count = 0;
    
36.                         System.out.println(prop);
    
37.                         String value = prop.getProperty("temp");
    
38.                         /*if(value == null)
    
39.                         {
    
40.                                 System.out.println(value);
    
41.                                 fos.write("temp=0".getBytes());
    
42.                         }
    
43.                         else*/
    
44.                         if(value != null)
    
45.                                 count = Integer.valueOf(value);
    
46.                         count++;
    
47.                 //        System.out.println(prop);
    
48.                         prop.setProperty("temp",count+"");
    
49.                 //        fos = new FileOutputStream(file);   // 但我如果在这里new的话.文件能一直保持...
    
50.                         prop.store(fos,"");
    
51.                         prop.list(System.out);
    
52.                 }
    
53.                 catch (IOException e)
    
54.                 {
    
55.                         throw new RuntimeException(e.toString()+"文件不存在");
    
56.                 }
    
57.                 finally
    
58.                 {
    
59.                         if(fis != null)
    
60.                         {
    
61.                                 try
    
62.                                 {
    
63.                                         fis.close();
    
64.                                 }
    
65.                                 catch (IOException e)
    
66.                                 {
    
67.                                         throw new RuntimeException(e.toString()+"haha");
    
68.                                 }
    
69.                         }
    
70.                         if(fos != null)
    
71.                         {
    
72.                                 try
    
73.                                 {
    
74.                                         fos.close();
    
75.                                 }
    
76.                                 catch (IOException e)
    
77.                                 {
    
78.                                         throw new RuntimeException(e.toString()+"Hhasdas");
    
79.                                 }
    
80.                         }
    
81.                 }
    
82.                
    
83.         }
    
84. }
    

复制代码

想问的问题是,这两个地方所new的FileOutputStream 对Properties有什么影响,?
文字表达不好..麻烦各位有时间看看.

个人理解 你在第一个位置加载file进入输出流的时候 ，文件的属性还没有改变 ，自然将文件存入内存 在下次打开的时候 由于属性还是与你上次一样，所以属性值是不变的。而在第二个位置，每次执行 属性都会先进行变化，所以可以存储进内存中。个人理解，没有尝试，如有错误，可以一起讨论