So speichern Sie ein Array in einer Java-Eigenschaftendatei

Ich mache gerade eine .properties-Datei, die geladen und in ein Array umgewandelt werden muss.
Es besteht die Möglichkeit, dass jeder Eigenschaftsschlüssel zwischen 0 und 25 vorhanden ist.

Ich habe ein paar Implementierungen ausprobiert, aber ich bin nur dabei, dies sauber zu tun.
Hat jemand Ideen?

foo.1.filename=foo.txt
foo.1.expire=200

foo.2.filename=foo2.txt
foo.2.expire=10

etc more foo's

bar.1.filename=bar.txt
bar.1.expire=100

Wo ich die Dateinamen/Ablauf-Paare zu einem Datenobjekt zusammenbaue, als Teil eines Arrays für jedes übergeordnete Eigenschaftselement wie foo[myobject]

Die Formatierung der Eigenschaftendatei kann sich ändern, ich bin offen für Ideen.

Ich kann vorschlagen, Trennzeichen zu verwenden und die zu verwenden

String.split(delimiter)

Beispiel einer Eigenschaftendatei:

MON=0800#Etwas#Etwas1, Etwas2

prop.load(new FileInputStream("\\\\Myseccretnetwork\\Project\\props.properties"));
String[]values = prop.get("MON").toString().split("#");

Ich hoffe, das hilft

Habe deine Absicht nicht ganz verstanden. Überprüfen Sie die Apache Commons-Konfigurationsbibliothek http://commons.apache.org/configuration/

Sie können mehrere Werte für einen Schlüssel haben, wie in Schlüssel = Wert1, Wert2, und Sie können dies in ein Array einlesen als configuration.getAsStringArray("key")

Definieren Sie entweder ein Trennzeichen, das kein potenzieller Wert ist, oder lernen Sie, XML zu verwenden.

Wenn Sie immer noch darauf bestehen, Eigenschaften zu verwenden, verwenden Sie eine der Methoden, die eine Liste aller Schlüssel zurückgibt. Ihr Schlüssel scheint drei Teile zu haben, eine Gruppenkennung (foo, bar), einen Index (1, 2) und dann einen Elementnamen (Dateiname, Ablauf). Holen Sie sich alle Schlüssel, zerlegen Sie sie in ihre Bestandteile. Erstellen Sie eine Liste für jeden Bezeichnertyp. Verwenden Sie beim Verarbeiten der Liste den Bezeichner, um zu bestimmen, welcher Liste hinzugefügt werden soll. Erstellen Sie Ihre gepaarten Elemente wie gesagt und fügen Sie sie einfach zur Liste hinzu! Wenn die Indexreihenfolge wichtig ist, fügen Sie diese entweder als Feld zu Ihren gepaarten Elementen hinzu oder sortieren Sie die Schlüssel vor der Verarbeitung.

Verwenden YAML Dateien für Eigenschaften, dies unterstützt Eigenschaften als Array.

Kurzer Blick auf YAML:

Als Obermenge von JSON kann es alles tun, was JSON kann + mehr

1. Einfach zu lesen
2. Lange Eigenschaften in mehrzeilige Werte
3. Unterstützt Kommentare
4. Eigenschaften als Array
5. YAML-Validierung

Ich habe benutzerdefiniertes Laden. Eigenschaften müssen definiert werden als:

key.0=value0
key.1=value1
...

Benutzerdefiniertes Laden:

/** Return array from properties file. Array must be defined as "key.0=value0", "key.1=value1", ... */
public List<String> getSystemStringProperties(String key) {

    // result list
    List<String> result = new LinkedList<>();

    // defining variable for assignment in loop condition part
    String value;

    // next value loading defined in condition part
    for(int i = 0; (value = YOUR_PROPERTY_OBJECT.getProperty(key + "." + i)) != null; i++) {
        result.add(value);
    }

    // return
    return result;
}

Ich empfehle dringend die Verwendung von Apache Commons (http://commons.apache.org/configuration/). Es hat die Fähigkeit, eine XML-Datei als Konfigurationsdatei zu verwenden. Die Verwendung einer XML-Struktur erleichtert die Darstellung von Arrays als Wertelisten und nicht als speziell nummerierte Eigenschaften.

Hier ist eine andere Möglichkeit, den Mechanismus selbst zu implementieren. Hier betrachten wir, dass das Array mit 0 beginnen sollte und kein Loch zwischen den Indizes haben würde

    /**
     * get a string property's value
     * @param propKey property key
     * @param defaultValue default value if the property is not found
     * @return value
     */
    public static String getSystemStringProperty(String propKey,
            String defaultValue) {
        String strProp = System.getProperty(propKey);
        if (strProp == null) {
            strProp = defaultValue;
        }
        return strProp;
    }

    /**
     * internal recursive method to get string properties (array)
     * @param curResult current result
     * @param paramName property key prefix
     * @param i current indice
     * @return array of property's values
     */
    private static List<String> getSystemStringProperties(List<String> curResult, String paramName, int i) {
        String paramIValue = getSystemStringProperty(paramName + "." + String.valueOf(i), null);
        if (paramIValue == null) {
            return curResult;
        }
        curResult.add(paramIValue);
        return getSystemStringProperties(curResult, paramName, i+1);
    }

    /**
     * get the values from a property key prefix
     * @param paramName property key prefix
     * @return string array of values
     */
    public static String[] getSystemStringProperties(
            String paramName) {
        List<String> stringProperties = getSystemStringProperties(new ArrayList<String>(), paramName, 0);
        return stringProperties.toArray(new String[stringProperties.size()]);
    }

Hier ist eine Möglichkeit zum Testen:

    @Test
    public void should_be_able_to_get_array_of_properties() {
        System.setProperty("my.parameter.0", "ooO");
        System.setProperty("my.parameter.1", "oO");
        System.setProperty("my.parameter.2", "boo");
        // WHEN 
        String[] pluginParams = PropertiesHelper.getSystemStringProperties("my.parameter");

        // THEN
        assertThat(pluginParams).isNotNull();
        assertThat(pluginParams).containsExactly("ooO","oO","boo");
        System.out.println(pluginParams[0].toString());
    }

hoffe das hilft

und alle Anmerkungen sind willkommen..