直接使用java.util.Properties提供的类，读取properties文件的时候，读出来的是乱序的。

但是，我想要的，或者开发需求是要求，怎么读进来，怎么写出去。按顺序读，还得按顺序写。

下面就示范怎么按顺序读properties文件，以及还得按原来的顺序写properties文件。

package com.lxk.propertyFileTest;

import java.util.*;

/**

* Created by lxk on 2017/5/2

*/

public class OrderedProperties extends Properties {

private static final long serialVersionUID = -4627607243846121965L;

/**

* 因为LinkedHashSet有序，所以，key在调用put()的时候，存放到这里也就有序。

*/

private final LinkedHashSet keys = new LinkedHashSet<>();

@Override

public Enumeration keys() {

return Collections.enumeration(keys);

}

/**

* 在put的时候，只是把key有序的存到{@link OrderedProperties#keys}

* 取值的时候，根据有序的keys，可以有序的取出所有value

* 依然调用父类的put方法,也就是key value 键值对还是存在hashTable里.

* 只是现在多了个存key的属性{@link OrderedProperties#keys}

*/

@Override

public Object put(Object key, Object value) {

keys.add(key);

return super.put(key, value);

}

/**

* 因为复写了这个方法，在(方式一)的时候,才输出有序。

* {@link MainOrder#printProp}

*/

@Override

public Set stringPropertyNames() {

Set set = new LinkedHashSet<>();

for (Object key : this.keys) {

set.add((String) key);

}

return set;

}

/**

* 因为复写了这个方法，在(方式二)的时候,才输出有序。

* {@link MainOrder#printProp}

*/

@Override

public Set keySet() {

return keys;

}

//这个就不设置有序了，因为涉及到HashTable内部类：EntrySet，不好复写。

//public LinkedHashSet> entrySet() {

// LinkedHashSet> entrySet = new LinkedHashSet<>();

// for (Object key : keys) {

//

// }

// return entrySet;

//}

/**

* 因为复写了这个方法，在(方式四)的时候,才输出有序。

* {@link MainOrder#printProp}

*/

@Override

public Enumeration> propertyNames() {

return Collections.enumeration(keys);

}

}

上面是继承Java自带的类，我们做的主要是实现有序，其他的还是原来的样子就行。

下面是main方法的类。

package com.lxk.propertyFileTest;

import java.io.*;

import java.util.Enumeration;

import java.util.Map;

import java.util.Properties;

import java.util.Set;

/**

* 读写properties文件测试(带顺序的读和写)

*

* Created by lxk on 2017/5/2

*/

public class MainOrder {

public static void main(String[] args) {

Properties prop = readOrderedPropertiesFile();

printProp(prop);

writeOrderedPropertiesFile(prop);

}

/**

* 输出properties的key和value

*/

public static void printProp(Properties properties) {

System.out.println("---------(方式一)------------");

for (String key : properties.stringPropertyNames()) {

System.out.println(key + "=" + properties.getProperty(key));

}

System.out.println("---------(方式二)------------");

Set keys = properties.keySet();//返回属性key的集合

for (Object key : keys) {

System.out.println(key.toString() + "=" + properties.get(key));

}

System.out.println("---------(方式三)------------");

Set> entrySet = properties.entrySet();//返回的属性键值对实体

for (Map.Entry entry : entrySet) {

System.out.println(entry.getKey() + "=" + entry.getValue());

}

System.out.println("---------(方式四)------------");

Enumeration> e = properties.propertyNames();

while (e.hasMoreElements()) {

String key = (String) e.nextElement();

String value = properties.getProperty(key);

System.out.println(key + "=" + value);

}

}

/**

* 读Properties文件(有序)

*/

private static Properties readOrderedPropertiesFile() {

Properties properties = new OrderedProperties();

InputStreamReader inputStreamReader = null;

try {

InputStream inputStream = new BufferedInputStream(new FileInputStream("D:testOrder.properties"));

//prop.load(in);//直接这么写，如果properties文件中有汉子，则汉字会乱码。因为未设置编码格式。

inputStreamReader = new InputStreamReader(inputStream, "utf-8");

properties.load(inputStreamReader);

} catch (Exception e) {

System.out.println(e.getMessage());

} finally {

if (inputStreamReader != null) {

try {

inputStreamReader.close();

} catch (IOException e) {

System.out.println(e.getMessage());

}

}

}

return properties;

}

/**

* 写Properties文件(有序)

*/

private static void writeOrderedPropertiesFile(Properties properties) {

properties.setProperty("phone", "10086");

OutputStreamWriter outputStreamWriter = null;

try {

//保存属性到b.properties文件

FileOutputStream fileOutputStream = new FileOutputStream("order.properties", false);//true表示追加打开,false每次都是清空再重写

//prop.store(oFile, "此参数是保存生成properties文件中第一行的注释说明文字");//这个会两个地方乱码

//prop.store(new OutputStreamWriter(oFile, "utf-8"), "汉字乱码");//这个就是生成的properties文件中第一行的注释文字乱码

outputStreamWriter = new OutputStreamWriter(fileOutputStream, "utf-8");

properties.store(outputStreamWriter, "lll");

} catch (Exception e) {

System.out.println(e.getMessage());

} finally {

if (outputStreamWriter != null) {

try {

outputStreamWriter.close();

} catch (IOException e) {

System.out.println(e.getMessage());

}

}

}

}

}

其实读和写，都和使用系统提供的类的差别不大，只是现在读到了我们自己写的子类里面去了。

起他的代码都是一样样的。

下面是读的文件的内容截图：

再然后是，实际代码运行的结果截图：

---------(方式一)------------

1=11

2=22

3=33

4=44

5=55

6=66

7=77

8=88

9=99

10=18

11汉字=测试汉字以防乱码产生

---------(方式二)------------

1=11

2=22

3=33

4=44

5=55

6=66

7=77

8=88

9=99

10=18

11汉字=测试汉字以防乱码产生

---------(方式三)------------

11汉字=测试汉字以防乱码产生

9=99

8=88

7=77

6=66

5=55

4=44

3=33

2=22

10=18

1=11

---------(方式四)------------

1=11

2=22

3=33

4=44

5=55

6=66

7=77

8=88

9=99

10=18

11汉字=测试汉字以防乱码产生

额，太长了，就不截图了吧，就给把打印结果给展示一下得了。

可以看到，只有第三次是无序的，具体原因，我也在代码里面解释过了。

还有，就是生成的文件的截图：

觉得此文有用的，不嫌麻烦的，就点个赞吧，要是嫌弃麻烦呢，也麻烦点个赞嘛，要是实在不想点赞呢，也不是不可以。

但是，你要是想踩一脚呢，那还是赶紧，马上，快快的闪人。

小心我手里三十米长的大刀。哼哼。想想都怕 ！！！