Conversione di java.util.Properties in HashMap <String, String>

Properties properties = new Properties();
Map<String, String> map = new HashMap<String, String>(properties);// why wrong?

java.util.Propertiesè un'implementazione di java.util.Map, java.util.HashMapil costruttore di And riceve un Mapparametro di tipo. Allora, perché deve essere convertito esplicitamente?

Questo perché si PropertiesestendeHashtable<Object, Object> (che, a sua volta, implementa Map<Object, Object>). Tenti di inserirlo in un file Map<String, String>. È quindi incompatibile.

Devi inserire le proprietà della stringa una per una nella tua mappa ...

Per esempio:

for (final String name: properties.stringPropertyNames())
    map.put(name, properties.getProperty(name));

Il modo efficiente per farlo è semplicemente eseguire il cast su una mappa generica come segue:

Properties props = new Properties();

Map<String, String> map = (Map)props;

Questo convertirà un Map<Object, Object>in una mappa grezza, che è "ok" per il compilatore (solo avvertimento). Una volta che avremo un raw Map, verrà Map<String, String>eseguito il cast al quale sarà anche "ok" (un altro avvertimento). Puoi ignorarli con l'annotazione@SuppressWarnings({ "unchecked", "rawtypes" })

Questo funzionerà perché nella JVM l'oggetto non ha realmente un tipo generico. I tipi generici sono solo un trucco che verifica le cose in fase di compilazione.

Se una chiave o un valore non è una stringa, verrà ClassCastExceptiongenerato un errore. Con l' Propertiesimplementazione corrente è molto improbabile che ciò accada, a condizione che non si utilizzino i metodi di chiamata mutabili del super Hashtable<Object,Object>di Properties.

Quindi, se non fai cose brutte con la tua istanza Properties, questa è la strada da percorrere.

Puoi usare Google Guava:

com.google.common.collect.Maps.fromProperties (Proprietà)

Cosa ne pensi di questo?

   Map properties = new Properties();
   Map<String, String> map = new HashMap<String, String>(properties);

Provocherà un avviso, ma funziona senza iterazioni.

Il modo in cui Java 8:

properties.entrySet().stream().collect(
    Collectors.toMap(
         e -> e.getKey().toString(),
         e -> e.getValue().toString()
    )
);

Propertiesattrezzi Map<Object, Object>- non Map<String, String>.

Stai provando a chiamare questo costruttore:

public HashMap(Map<? extends K,? extends V> m)

... con Ked Ventrambi come String.

Ma Map<Object, Object>non è un Map<? extends String, ? extends String>... può contenere chiavi e valori non stringa.

Questo funzionerebbe:

Map<Object, Object> map = new HashMap<Object, Object>();

... ma non ti sarebbe così utile.

Fondamentalmente, Propertiesnon avrebbe mai dovuto essere una sottoclasse di HashTable... questo è il problema. Dalla v1, è sempre stato in grado di memorizzare chiavi e valori non String, nonostante ciò fosse contro l'intenzione. Se invece fosse stata utilizzata la composizione, l'API avrebbe potuto funzionare solo con chiavi / valori stringa e tutto sarebbe andato bene.

Potresti volere qualcosa del genere:

Map<String, String> map = new HashMap<String, String>();
for (String key : properties.stringPropertyNames()) {
    map.put(key, properties.getProperty(key));
}

Vorrei utilizzare la seguente API Guava: com.google.common.collect.Maps # fromProperties

Properties properties = new Properties();
Map<String, String> map = Maps.fromProperties(properties);

Se sai che il tuo Propertiesoggetto contiene solo <String, String>voci, puoi ricorrere a un tipo grezzo:

Properties properties = new Properties();
Map<String, String> map = new HashMap<String, String>((Map) properties);

Il problema è che Propertiesimplementa Map<Object, Object>, mentre il HashMapcostruttore si aspetta un file Map<? extends String, ? extends String>.

Questa risposta spiega questa decisione (abbastanza contro-intuitiva). In breve: prima di Java 5, Propertiesimplementato Map(poiché non c'erano generici allora). Ciò significava che potevi mettere qualsiasi cosa Object in un Propertiesoggetto. Questo è ancora nella documenazione:

Poiché Propertieseredita da Hashtable, i metodi pute putAllpossono essere applicati a un Propertiesoggetto. Il loro uso è fortemente sconsigliato in quanto consentono al chiamante di inserire voci le cui chiavi o valori non sono Strings. IlsetProperty metodo dovrebbe essere utilizzato invece.

Per mantenere la compatibilità con questo, i progettisti non hanno avuto altra scelta che farlo ereditare Map<Object, Object> in Java 5. È uno sfortunato risultato della ricerca della piena compatibilità all'indietro che rende il nuovo codice inutilmente contorto.

Se usi solo le proprietà della stringa nel tuo Propertiesoggetto, dovresti essere in grado di farla franca con un cast non controllato nel tuo costruttore:

Map<String, String> map = new HashMap<String, String>( (Map<String, String>) properties);

o senza alcuna copia:

Map<String, String> map = (Map<String, String>) properties;

questo è solo perché il costruttore di HashMap richiede un argomento di tipo generico Map e Properties implementa Map.

Funzionerà, anche se con un avvertimento

    Properties properties = new Properties();
    Map<String, String> map = new HashMap(properties);

Puoi usare questo:

Map<String, String> map = new HashMap<>();

props.forEach((key, value) -> map.put(key.toString(), value.toString()));

Prima cosa,

La classe delle proprietà è basata su Hashtable e non su Hashmap. La classe Properties fondamentalmente estende Hashtable

Non esiste un tale costruttore nella classe HashMap che prenda un oggetto proprietà e ti restituisca un oggetto hashmap. Quindi quello che stai facendo NON è corretto. Dovresti essere in grado di eseguire il cast dell'oggetto delle proprietà in riferimento alla tabella hash.

io uso questo:

for (Map.Entry<Object, Object> entry:properties.entrySet()) {
    map.put((String) entry.getKey(), (String) entry.getValue());
}