Convertendo java.util.Properties em HashMap <String, String>

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

java.util.Propertiesé uma implementação de java.util.Map, java.util.HashMapo construtor de And recebe um Mapparâmetro de tipo. Então, por que ele deve ser convertido explicitamente?

Isso ocorre porque PropertiesestendeHashtable<Object, Object> (que, por sua vez, implementa Map<Object, Object>). Você tenta alimentar isso em um Map<String, String>. Portanto, é incompatível.

Você precisa alimentar as propriedades da string, uma por uma, em seu mapa ...

Por exemplo:

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

A maneira eficiente de fazer isso é lançar para um mapa genérico da seguinte maneira:

Properties props = new Properties();

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

Isso converterá um Map<Object, Object>em um mapa bruto, que é "ok" para o compilador (apenas aviso). Assim que tivermos um raw, Mapele será lançado para o Map<String, String>qual também estará "ok" (outro aviso). Você pode ignorá-los com anotações@SuppressWarnings({ "unchecked", "rawtypes" })

Isso funcionará porque na JVM o objeto não tem realmente um tipo genérico. Tipos genéricos são apenas um truque que verifica as coisas em tempo de compilação.

Se alguma chave ou valor não for uma String, ocorrerá um ClassCastExceptionerro. Com a Propertiesimplementação atual, é muito improvável que isso aconteça, contanto que você não use os métodos de chamada mutáveis ​​do super Hashtable<Object,Object>de Properties.

Portanto, se não fizer coisas desagradáveis ​​com sua instância de Propriedades, este é o caminho a seguir.

Você pode usar o Google Guava's:

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

Que tal agora?

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

Irá causar um aviso, mas funciona sem iterações.

O método Java 8:

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

Propertiesimplementos Map<Object, Object>- não Map<String, String>.

Você está tentando chamar este construtor:

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

... com Ke Vambos como String.

Mas Map<Object, Object>não é Map<? extends String, ? extends String>... pode conter chaves e valores que não sejam de string.

Isso funcionaria:

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

... mas não seria tão útil para você.

Fundamentalmente, Propertiesnunca deveria ter sido feita uma subclasse de HashTable... esse é o problema. Desde v1, ele sempre foi capaz de armazenar chaves e valores não String, apesar de ser contra a intenção. Se a composição tivesse sido usada em vez disso, a API poderia ter funcionado apenas com chaves / valores de string e tudo estaria bem.

Você pode querer algo assim:

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

Eu usaria a seguinte API Guava: com.google.common.collect.Maps # fromProperties

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

Se você sabe que seu Propertiesobjeto contém apenas <String, String>entradas, pode recorrer a um tipo bruto:

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

O problema é que Propertiesimplementa Map<Object, Object>, enquanto o HashMapconstrutor espera um Map<? extends String, ? extends String>.

Essa resposta explica essa decisão (bastante contra-intuitiva). Resumindo: antes do Java 5, Propertiesimplementado Map(já que não havia genéricos naquela época). Isso significa que você pode colocar qualquer Object um em um Propertiesobjeto. Isso ainda está na documentação:

Como Propertiesherda de Hashtable, os métodos pute putAllpodem ser aplicados a um Propertiesobjeto. Seu uso é fortemente desencorajado, pois permitem que o chamador insira entradas cujas chaves ou valores não sejam Strings. O setPropertymétodo deve ser usado em seu lugar.

Para manter a compatibilidade com isso, os designers não tiveram outra escolha a não ser fazer com que ele herdasse Map<Object, Object>em Java 5. É um resultado infeliz do esforço para obter compatibilidade total com versões anteriores, o que torna o novo código desnecessariamente complicado.

Se você sempre usa propriedades de string em seu Propertiesobjeto, deverá conseguir fazer uma conversão não verificada em seu construtor:

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

ou sem quaisquer cópias:

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

isso ocorre apenas porque o construtor de HashMap requer um argumento do tipo genérico Map e Properties implementa Map.

Isso funcionará, embora com um aviso

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

Você pode usar isto:

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

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

Primeira coisa,

A classe Properties é baseada em Hashtable e não em Hashmap. A classe Properties basicamente estende Hashtable

Não existe tal construtor na classe HashMap que pega um objeto de propriedades e retorna um objeto hashmap. Portanto, o que você está fazendo NÃO é correto. Você deve ser capaz de converter o objeto de propriedades para referência de hashtable.

Eu uso isso:

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