Мне нужно прочитать файл свойств и создать класс свойств в Java. Я делаю это, используя:
Properties props = new Properties();
props.load(new FileInputStream(args[0]));
for (Enumeration e = props.propertyNames(); e.hasMoreElements();) {
}
Однако свойства, возвращаемые props.propertyName, не находятся в порядке исходного файла свойств. Я понимаю, что "Свойства" - это просто старомодные, негенерированные Hashtables. Я ищу работу. Есть идеи? Спасибо!
Возможно, вы захотите реализовать свой собственный класс свойств с аналогичными функциями.
Вы не сможете получить заказ, поскольку, как вы уже указали, он использует Hashtable.
Пример из www.java2s.com должен решить вашу проблему.
import java.util.Enumeration;
import java.util.Properties;
import java.util.Vector;
/**
* <a href="OrderedProperties.java.html"><b><i>View Source</i></b></a>
*
* @author Brian Wing Shun Chan
*
*/
public class OrderedProperties extends Properties {
public OrderedProperties() {
super ();
_names = new Vector();
}
public Enumeration propertyNames() {
return _names.elements();
}
public Object put(Object key, Object value) {
if (_names.contains(key)) {
_names.remove(key);
}
_names.add(key);
return super .put(key, value);
}
public Object remove(Object key) {
_names.remove(key);
return super .remove(key);
}
private Vector _names;
}
И ваш код изменится на:
Properties props = new OrderedProperties();
props.load(new FileInputStream(args[0]));
for (Enumeration e = props.propertyNames(); e.hasMoreElements();) {
}
Вы можете расширить свойства и делегировать все методы карты LinkedHashMap, чтобы сохранить заказ. Вот пример (вам может потребоваться переопределить некоторые другие методы):
public class LinkedProperties extends Properties{
private static final long serialVersionUID = 1L;
private Map<Object, Object> linkMap = new LinkedHashMap<Object,Object>();
@Override
public synchronized Object put(Object key, Object value){
return linkMap.put(key, value);
}
@Override
public synchronized boolean contains(Object value){
return linkMap.containsValue(value);
}
@Override
public boolean containsValue(Object value){
return linkMap.containsValue(value);
}
@Override
public synchronized Enumeration<Object> elements(){
throw new UnsupportedOperationException(
"Enumerations are so old-school, don't use them, "
+ "use keySet() or entrySet() instead");
}
@Override
public Set<Entry<Object, Object>> entrySet(){
return linkMap.entrySet();
}
@Override
public synchronized void clear(){
linkMap.clear();
}
@Override
public synchronized boolean containsKey(Object key){
return linkMap.containsKey(key);
}
}
Подобно одному из вышеперечисленных, но без накладных расходов на сохранение нашего собственного списка значений. Все, что нам нужно сделать, это сохранить отдельный упорядоченный список ключей и предоставить новый метод "keys()".
public class SequencedProperties extends Properties {
private static final long serialVersionUID = -7032434592318855760L;
private List keyList = new ArrayList();
@Override
public synchronized Enumeration keys() {
return Collections.enumeration(keyList);
}
@Override
public synchronized Object put(Object key, Object value) {
if (! containsKey(key)) {
keyList.add(key);
}
return super.put(key, value);
}
@Override
public synchronized Object remove(Object key) {
keyList.remove(key);
return super.remove(key);
}
@Override
public synchronized void putAll(Map values) {
for (Object key : values.keySet()) {
if (! containsKey(key)) {
keyList.add(key);
}
}
super.putAll(values);
}
}
Тот факт, что они представлены в виде Hashtable под капотом, означает, что их порядок не сохраняется никоим образом.
Я бы посоветовал вам "свернуть свой собственный" читатель свойств, если вы абсолютно отчаянно нуждаетесь в этой функции.
полная реализация на основе LinkedHashMap
import java.util.*;
import java.io.*;
/**
* Ordered properties implementation
*/
public class LinkedProperties extends Properties{
private static final long serialVersionUID = 1L;
private Map<Object, Object> linkMap = new LinkedHashMap<Object,Object>();
public void clear(){
linkMap.clear();
}
public boolean contains(Object value){
return linkMap.containsValue(value);
}
public boolean containsKey(Object key){
return linkMap.containsKey(key);
}
public boolean containsValue(Object value){
return linkMap.containsValue(value);
}
public Enumeration elements(){
throw new RuntimeException("Method elements is not supported in LinkedProperties class");
}
public Set entrySet(){
return linkMap.entrySet();
}
public boolean equals(Object o){
return linkMap.equals(o);
}
public Object get(Object key){
return linkMap.get(key);
}
public String getProperty(String key) {
Object oval = get(key); //here the class Properties uses super.get()
if(oval==null)return null;
return (oval instanceof String) ? (String)oval : null; //behavior of standard properties
}
public boolean isEmpty(){
return linkMap.isEmpty();
}
public Enumeration keys(){
Set keys=linkMap.keySet();
return Collections.enumeration(keys);
}
public Set keySet(){
return linkMap.keySet();
}
public void list(PrintStream out) {
this.list(new PrintWriter(out,true));
}
public void list(PrintWriter out) {
out.println("-- listing properties --");
for (Map.Entry e : (Set<Map.Entry>)this.entrySet()){
String key = (String)e.getKey();
String val = (String)e.getValue();
if (val.length() > 40) {
val = val.substring(0, 37) + "...";
}
out.println(key + "=" + val);
}
}
public Object put(Object key, Object value){
return linkMap.put(key, value);
}
public int size(){
return linkMap.size();
}
public Collection values(){
return linkMap.values();
}
//for test purpose only
public static void main(String[] arg)throws Exception{
Properties p0=new Properties();
Properties p1=new LinkedProperties();
p0.put("aaa","111");
p0.put("bbb","222");
p0.put("ccc","333");
p0.put("ddd","444");
p1.put("aaa","111");
p1.put("bbb","222");
p1.put("ccc","333");
p1.put("ddd","444");
System.out.println("\n--"+p0.getClass());
p0.list(System.out);
p0.store(System.out,"comments");
p0.storeToXML(System.out,"comments");
System.out.println(p0.toString());
System.out.println("\n--"+p1.getClass());
p1.list(System.out);
p1.store(System.out,"comments");
p1.storeToXML(System.out,"comments");
System.out.println(p1.toString());
}
}
Результат:
--class java.util.Properties
-- listing properties --
bbb=222
aaa=111
ddd=444
ccc=333
#comments
#Wed Apr 10 08:55:42 EEST 2013
bbb=222
aaa=111
ddd=444
ccc=333
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>comments</comment>
<entry key="bbb">222</entry>
<entry key="aaa">111</entry>
<entry key="ddd">444</entry>
<entry key="ccc">333</entry>
</properties>
{bbb=222, aaa=111, ddd=444, ccc=333}
--class groovy.abi.LinkedProperties
-- listing properties --
aaa=111
bbb=222
ccc=333
ddd=444
#comments
#Wed Apr 10 08:55:42 EEST 2013
aaa=111
bbb=222
ccc=333
ddd=444
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>comments</comment>
<entry key="aaa">111</entry>
<entry key="bbb">222</entry>
<entry key="ccc">333</entry>
<entry key="ddd">444</entry>
</properties>
{aaa=111, bbb=222, ccc=333, ddd=444}
Правильная реализация keySet:
public class OrderedProperties extends Properties {
private Set<Object> keySet = new LinkedHashSet<Object>(100);
@Override
public Enumeration<Object> keys() {
return Collections.enumeration(keySet);
}
@Override
public Set<Object> keySet() {
return keySet;
}
@Override
public synchronized Object put(Object key, Object value) {
if (! keySet.contains(key)) {
keySet.add(key);
}
return super.put(key, value);
}
@Override
public synchronized Object remove(Object key) {
keySet.remove(key);
return super.remove(key);
}
@Override
public synchronized void putAll(Map values) {
for (Object key : values.keySet()) {
if (! containsKey(key)) {
keySet.add(key);
}
}
super.putAll(values);
}
}
Свойства подкласса, чтобы запомнить порядок чтения и создать перечисление, в котором используется список упорядоченных ключей?
Чтобы решить проблему: "выполнять классы на основе порядка в файле свойств". Я обычно использовал одну из двух возможностей:
1 - используйте одно свойство в виде списка с разделителями-запятыми с именами классов или с ключами к определению класса
loadClasses = class-definition-A, class-definition-B, class-definition-C
или (полезно, если "определение" состоит из более чем одного свойства)
loadClasses = keyA, keyB, keyC
keyA = class-definition-A
keyB = определение класса-B
keyC = class-definition-C
2 - используйте ключ, за которым следует индекс (счетчик). Прочитайте ключи в цикле, пока не будет найдено значение.
class1 = class-definition-A
class2 = class-definition-B
class3 = class-definition-C