Conversión de java.util.Properties a HashMap <String, String>

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

java.util.Propertieses una implementación del constructor de java.util.Map, And recibe un tipo param. Entonces, ¿por qué debe convertirse explícitamente?java.util.HashMapMap

Esto se debe a que PropertiesextiendeHashtable<Object, Object> (que, a su vez, implementa Map<Object, Object>). Intenta alimentar eso en un Map<String, String>. Por tanto, es incompatible.

Necesita introducir las propiedades de la cadena una por una en su mapa ...

Por ejemplo:

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

La forma eficiente de hacerlo es simplemente convertir a un mapa genérico de la siguiente manera:

Properties props = new Properties();

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

Esto convertirá un Map<Object, Object>mapa en un mapa sin formato, que está "bien" para el compilador (solo advertencia). Una vez que tengamos un raw Mapse lanzará al Map<String, String>que también estará "ok" (otra advertencia). Puedes ignorarlos con una anotación.@SuppressWarnings({ "unchecked", "rawtypes" })

Esto funcionará porque en la JVM el objeto realmente no tiene un tipo genérico. Los tipos genéricos son solo un truco que verifica las cosas en tiempo de compilación.

Si alguna clave o valor no es una cadena, producirá un ClassCastExceptionerror. Con la Propertiesimplementación actual , es muy poco probable que esto suceda, siempre y cuando no use los métodos de llamada mutables del super Hashtable<Object,Object>de Properties.

Entonces, si no hace cosas desagradables con su instancia de Propiedades, este es el camino a seguir.

Podrías usar Google Guava's:

com.google.common.collect.Maps.fromProperties (Propiedades)

¿Qué tal esto?

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

Causará una advertencia, pero funciona sin iteraciones.

La forma Java 8:

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

Propertiesimplementos Map<Object, Object>- no Map<String, String>.

Estás intentando llamar a este constructor:

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

... con Ky Vambos como String.

Pero Map<Object, Object>no es un Map<? extends String, ? extends String>... puede contener claves y valores que no sean cadenas.

Esto funcionaría:

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

... pero no te sería tan útil.

Fundamentalmente, Propertiesnunca debería haber sido una subclase de HashTable... ese es el problema. Desde v1, siempre ha sido posible almacenar claves y valores que no son de cadena, a pesar de que eso va en contra de la intención. Si se hubiera utilizado la composición en su lugar, la API solo podría haber funcionado con claves / valores de cadena, y todo habría ido bien.

Es posible que desee algo como esto:

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

Usaría la siguiente API de Guava: com.google.common.collect.Maps # fromProperties

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

Si sabe que su Propertiesobjeto solo contiene <String, String>entradas, puede recurrir a un tipo sin formato:

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

El problema es que Propertiesimplementa Map<Object, Object>, mientras que el HashMapconstructor espera un Map<? extends String, ? extends String>.

Esta respuesta explica esta decisión (bastante contraria a la intuición). En resumen: antes de Java 5, Propertiesimplementado Map(ya que no había genéricos en ese entonces). Esto significaba que podía poner cualquiera Object en un Propertiesobjeto. Esto todavía está en la documentación:

Dado que Propertieshereda de Hashtable, los métodos puty putAllse pueden aplicar a un Propertiesobjeto. Se desaconseja encarecidamente su uso, ya que permiten a la persona que llama insertar entradas cuyas claves o valores no son Strings. En su lugar setProperty, debería utilizarse el método.

Para mantener la compatibilidad con esto, los diseñadores no tuvieron otra opción que heredarlo Map<Object, Object>en Java 5. Es un resultado desafortunado del esfuerzo por lograr una compatibilidad total con versiones anteriores que hace que el nuevo código sea innecesariamente complicado.

Si solo usa propiedades de cadena en su Propertiesobjeto, debería poder salirse con una conversión sin marcar en su constructor:

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

o sin copias:

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

esto es solo porque el constructor de HashMap requiere un argumento de tipo Map genérico y Propiedades implementa Map.

Esto funcionará, aunque con una advertencia

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

Puedes usar esto:

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

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

Lo primero,

La clase de propiedades se basa en Hashtable y no en Hashmap. La clase de propiedades básicamente extiende Hashtable

No existe tal constructor en la clase HashMap que toma un objeto de propiedades y le devuelve un objeto hashmap. Entonces, lo que estás haciendo NO es correcto. Debería poder convertir el objeto de propiedades en una referencia de tabla hash.

yo uso esto:

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