Cómo almacenar una matriz en un archivo de propiedades de Java

Actualmente estoy creando un archivo .properties que debe cargarse y transformarse en una matriz.
Existe la posibilidad de que existan entre 0 y 25 de cada una de las claves de propiedad.

Probé algunas implementaciones, pero estoy atascado en hacer esto limpiamente.
¿Alguien tiene alguna idea?

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

Donde ensamblaré los emparejamientos de nombre de archivo/caducidad en un objeto de datos, como parte de una matriz para cada elemento de propiedad principal como foo[myobject]

El formato del archivo de propiedades puede cambiar, estoy abierto a ideas.

Puedo sugerir usar delimitadores y usar el

String.split(delimiter)

Archivo de propiedades de ejemplo:

MON=0800#Algo#Algo1, Algo2

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

Espero que ayude

No capté exactamente tu intención. Verifique la biblioteca de configuración de Apache Commons http://commons.apache.org/configuration/

Puede tener múltiples valores contra una clave como en key=value1,value2 y puede leer esto en una matriz como configuration.getAsStringArray("key")

Defina un delimitador que no sea un valor potencial o aprenda a usar XML.

Si aún insiste en usar propiedades, use uno de los métodos que devolverá una lista de todas las claves. Su clave parece tener tres partes: un identificador de grupo (foo, bar), un índice (1, 2) y luego un nombre de elemento (nombre de archivo, caducar). Consigue todas las llaves, divídelas en sus partes componentes. Cree una Lista para cada tipo de identificador, cuando procese la lista use el identificador para determinar a qué Lista agregar. ¡Cree sus elementos emparejados como dijo y simplemente agréguelos a la lista! Si el orden del índice es importante, agréguelo como un campo a sus elementos emparejados u ordene las claves antes de procesar.

Usar YAML archivos para propiedades, esto admite propiedades como una matriz.

Vistazo rápido sobre YAML:

Un superconjunto de JSON, puede hacer todo lo que JSON puede hacer y más

1. Fácil de leer
2. Propiedades largas en valores multilínea
3. Soporta comentarios
4. Propiedades como matriz
5. Validación YAML

Tengo carga personalizada. Las propiedades deben definirse como:

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

Carga personalizada:

/** 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;
}

Recomiendo usar Apache Commons (http://commons.apache.org/configuration/). Tiene la capacidad de utilizar un archivo XML como archivo de configuración. El uso de una estructura XML facilita la representación de matrices como listas de valores en lugar de propiedades numeradas especialmente.

aquí hay otra forma de hacerlo implementando usted mismo el mecanismo. aquí consideramos que la matriz debería comenzar con 0 y no tendría ningún hueco entre el índice

    /**
     * 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()]);
    }

Aquí hay una manera de probar:

    @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());
    }

espero que esto ayude

y todos los comentarios son bienvenidos..