# Properties sortieren



## *java* (3. Nov 2007)

hallo,

neue anfänger frage, neues glück   

also, ich habe eine property datei dort befinden sich mehrere daten drin. 
wenn ich die jetzt auslese bekomme ich das ganze unsortiert. wie kann ich es machen, dass die daten so ausgelesen werden wie sich in der datei stehen? warum stehen die eigentlich unsortiert dadrin. ich habe sie doch mit put nacheinader reingelegt?



```
Properties conf = new Properties ();
//werden gefüllt mit daten aus einer datei

Iterator it = conf.keySet().iterator();
	   while (it.hasNext()) {
		  String key = (String)it.next();
		  System.out.println(key + " = " + conf.get(key));
	   }
```

vielen dank gruß


----------



## Leroy42 (3. Nov 2007)

java.util.properties ist eine Klasse, die Hashtable erweitert.

Alle _Hash_s sind von Haus aus unsortiert!


----------



## *java* (3. Nov 2007)

hallo,

ok! um welche funktionen denn? aber wie kann ich sie sortieren?

grüße


----------



## Gast (4. Nov 2007)

@Leroy42 nicht böse sein, aber warum sind Hashs unsortiert?
Ist es nicht der Sinn das man bei einer Hashtable über den Hash sucht, bzw. einsortiert. Dadurch sollten die Inhalte doch nach dem Hash sortiert sein?


----------



## Murray (5. Nov 2007)

Gast hat gesagt.:
			
		

> Ist es nicht der Sinn das man bei einer Hashtable über den Hash sucht, bzw. einsortiert.


Sucht (bzw. findet): ja
einsortiert: nein



			
				Gast hat gesagt.:
			
		

> Dadurch sollten die Inhalte doch nach dem Hash sortiert sein?


Nö, die Reihenfolge ist ein Implementierungsdetail und als solches nicht explizit definiert - es ist durchaus möglich, dass sich die Reihenfolge von einem Programmdurchlauf zum nächsten unterscheidet, obwohl sich die zugrundeliegende Property-Datei zwischenzeitlich nicht geändert hat.


----------



## d.meinig (9. Nov 2007)

Einfach mal eine eigene Klasse implementieren:




```
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.Date;
import java.util.InvalidPropertiesFormatException;
import java.util.Iterator;
import java.util.Properties;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;

/**
 * @author Dierk Meinig
 * Sortiert die Properties in natuerlicher Folge bei der Speicherung
 */
public class SortedProperties extends Properties
{

	/**
	 * 
	 */
	private static final long serialVersionUID = 8394964014128693064L;
	
	private static SortedMap<Object, Object> map =new TreeMap<Object, Object>();
	
	/*
	 *  (non-Javadoc)
	 * @see java.util.Hashtable#keySet()
	 * Fuer die Sortierung der XML-Ausgabe
	 * ueberschrieben
	 */
	public Set<Object> keySet()
	{
		map.putAll(this);
		return map.keySet();
	}
	
	/*
	 *  (non-Javadoc)
	 * @see java.util.Properties#load(java.io.InputStream)
	 * laedt alle Properties auch in die sortierte map
	 */
	public synchronized void load(InputStream inStream) throws IOException
	{
		super.load(inStream);
		map.putAll(this);
	}
	
	/*
	 *  (non-Javadoc)
	 * @see java.util.Properties#loadFromXML(java.io.InputStream)
	 * laedt alle Properties auch in die sortierte map
	 */
    public synchronized void loadFromXML(InputStream in)throws IOException, InvalidPropertiesFormatException 
    {
    	super.loadFromXML(in);
		map.putAll(this);
    }
    
    /*
     *  (non-Javadoc)
     * @see java.util.Properties#setProperty(java.lang.String, java.lang.String)
     * schreibt Property auch in die sortierte map
     */
	public synchronized Object setProperty(String key, String value) 
	{
		map.putAll(this);
		Object o = super.setProperty(key, value);
		map.put(key, value);
        return o;
    }

	/*
	 *  (non-Javadoc)
	 * @see java.util.Dictionary#remove(java.lang.Object)
	 * entfernt eine Property auch aus der sortierten map
	 */
	public synchronized Object remove(Object key)
	{
		map.putAll(this);
		Object o = super.remove(key);
		map.remove(key);
		return o;
	}
	
	/*
	 *  (non-Javadoc)
	 * @see java.util.Properties#store(java.io.OutputStream, java.lang.String)
	 * ueberschrieben, um mit den Keys der sortierten Map zu arbeiten
	 */
    public synchronized void store(OutputStream out, String comments)
    throws IOException
    {
        BufferedWriter awriter;
        awriter = new BufferedWriter(new OutputStreamWriter(out, "8859_1"));
        if (comments != null)
            writeln(awriter, "#" + comments);
        	writeln(awriter, "#" + new Date().toString());

        	// Hier wird mit den Keys der sortierten Map gearbeitet
        	// die Werte und Keys für die Ausgabe werden aus der
        	// Super geholt
        Iterator it = keySet().iterator();
//        for (Enumeration e = keys(); e.hasMoreElements();) 
        while(it.hasNext())
        {
            String key = (String) it.next();//(String)e.nextElement();
            String val = (String)get(key);
            key = saveConvert(key, true);

	    /* No need to escape embedded and trailing spaces for value, hence
	     * pass false to flag.
	     */
            val = saveConvert(val, false);
            writeln(awriter, key + "=" + val);
        }
        awriter.flush();
    }
    
    /*
     * keine Aenderungen zu super, war not visible
     */
    private static void writeln(BufferedWriter bw, String s) throws IOException {
        bw.write(s);
        bw.newLine();
    }
    
    /*
     * keine Aenderungen zu super, war not visible
     */
    private String saveConvert(String theString, boolean escapeSpace) {
        int len = theString.length();
        int bufLen = len * 2;
        if (bufLen < 0) {
            bufLen = Integer.MAX_VALUE;
        }
        StringBuffer outBuffer = new StringBuffer(bufLen);

        for(int x=0; x<len; x++) {
            char aChar = theString.charAt(x);
            // Handle common case first, selecting largest block that
            // avoids the specials below
            if ((aChar > 61) && (aChar < 127)) {
                if (aChar == '\\') {
                    outBuffer.append('\\'); outBuffer.append('\\');
                    continue;
                }
                outBuffer.append(aChar);
                continue;
            }
            switch(aChar) {
		case ' ':
		    if (x == 0 || escapeSpace) 
			outBuffer.append('\\');
		    outBuffer.append(' ');
		    break;
                case '\t':outBuffer.append('\\'); outBuffer.append('t');
                          break;
                case '\n':outBuffer.append('\\'); outBuffer.append('n');
                          break;
                case '\r':outBuffer.append('\\'); outBuffer.append('r');
                          break;
                case '\f':outBuffer.append('\\'); outBuffer.append('f');
                          break;
                case '=': // Fall through
                case ':': // Fall through
                case '#': // Fall through
                case '!':
                    outBuffer.append('\\'); outBuffer.append(aChar);
                    break;
                default:
                    if ((aChar < 0x0020) || (aChar > 0x007e)) {
                        outBuffer.append('\\');
                        outBuffer.append('u');
                        outBuffer.append(toHex((aChar >> 12) & 0xF));
                        outBuffer.append(toHex((aChar >>  8) & 0xF));
                        outBuffer.append(toHex((aChar >>  4) & 0xF));
                        outBuffer.append(toHex( aChar        & 0xF));
                    } else {
                        outBuffer.append(aChar);
                    }
            }
        }
        return outBuffer.toString();
    }
    
    /*
     * keine Aenderungen zu super, war not visible
     */
    private static char toHex(int nibble) {
    	return hexDigit[(nibble & 0xF)];
        }

    /*
     * keine Aenderungen zu super, war not visible
     */
        /** A table of hex digits */
        private static final char[] hexDigit = {
    	'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
        };

}
```


----------



## d.meinig (9. Nov 2007)

```
import java.util.Collections;
import java.util.Enumeration;
import java.util.Properties;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.Vector;

/**
 * @author Dierk Meinig
 * Sortiert die Properties in natuerlicher Folge bei der Speicherung
 */
public class SortedProperties extends Properties
{

	/**
	 * 
	 */
	private static final long serialVersionUID = 8394964014128693064L;
	
	/*
	 * (non-Javadoc)
	 * @see java.util.Hashtable#keys()
	 */
	public synchronized Enumeration keys() {
		Enumeration keysEnum = super.keys();
		Vector keyList = new Vector();
		while(keysEnum.hasMoreElements()){
		keyList.add(keysEnum.nextElement());
		}
		Collections.sort(keyList);
		return keyList.elements();
		}
	
	/* (non-Javadoc)
	 * @see java.util.Hashtable#keySet()
	 * used in storeToXml
	 */
	public Set<Object> keySet()
	{
		SortedSet set = new TreeSet( super.keySet());
		return set;
	}
}
```


----------

