Java.util.Properties'i HashMap <String, String> 'e dönüştürme

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

java.util.Propertiesbir uygulamasıdır java.util.Map, Ve java.util.HashMapbireyin yapıcı bir alan Maptürü param. Öyleyse, neden açıkça dönüştürülmeli?

Bunun nedeni PropertiesgenişlemesidirHashtable<Object, Object> (sırayla uygular Map<Object, Object>). Bunu bir Map<String, String>. Bu nedenle uyumsuzdur.

Dize özelliklerini tek tek haritanıza beslemeniz gerekiyor ...

Örneğin:

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

Bunu yapmanın etkili yolu, aşağıdaki gibi genel bir Haritaya atılmaktır:

Properties props = new Properties();

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

Bu, a'yı Map<Object, Object>derleyici için "tamam" olan bir ham Haritaya dönüştürür (yalnızca uyarı). Biz çiğ sahip olduktan Mapo kadar kullanacaklar Map<String, String>o da (başka uyarı) "Tamam" olacak. Ek açıklama ile onları görmezden gelebilirsiniz@SuppressWarnings({ "unchecked", "rawtypes" })

Bu işe yarayacaktır çünkü JVM'de nesnenin gerçekten genel bir türü yoktur. Soysal türler, işleri derleme zamanında doğrulayan bir numaradır.

Bazı anahtar veya değer bir Dize değilse, bir ClassCastExceptionhata oluşturur. Geçerli ile Propertiesuygulanması bu sürece süperden değişken çağrı yöntemlerini kullanmayın olarak, gerçekleşmesi pek olası değildir Hashtable<Object,Object>ait Properties.

Öyleyse, Properties örneğinizle kötü şeyler yapmazsanız, gidilecek yol budur.

Google Guava'yı kullanabilirsiniz:

com.google.common.collect.Maps.fromProperties (Özellikler)

Buna ne dersin?

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

Bir uyarıya neden olur, ancak yineleme olmadan çalışır.

Java 8 yolu:

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

Propertiesuygular Map<Object, Object>- değil Map<String, String>.

Bu kurucuyu aramaya çalışıyorsunuz:

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

... ile Kve Vher ikisi ile String.

Ama Map<Object, Object>bir Map<? extends String, ? extends String>... dize olmayan anahtarlar ve değerler içerebilir.

Bu işe yarar:

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

... ama senin için o kadar yararlı olmayacak.

Temelde, Propertiesasla bir alt sınıf yapılmamalıydı HashTable... sorun bu. V1'den beri, amaca aykırı olmasına rağmen, String olmayan anahtarları ve değerleri her zaman depolayabiliyor. Bunun yerine kompozisyon kullanılmış olsaydı, API yalnızca dize anahtarları / değerleriyle çalışabilirdi ve her şey yolunda olurdu.

Bunun gibi bir şey isteyebilirsiniz:

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

Şu Guava API'sini kullanırdım: com.google.common.collect.Maps # fromProperties

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

Eğer varsa bilmek sizin o Propertiesnesne yalnızca içeren <String, String>girdileri, bir ham türüne çare olabilir:

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

Sorun, Propertiesuygulayan Map<Object, Object>, ancak HashMapkurucu bir Map<? extends String, ? extends String>.

Bu cevap , bu (oldukça sezgisel) kararı açıklar. Kısaca: Java 5'ten önce Propertiesuygulandı Map(o zamanlar jenerik olmadığından). Bu, herhangi Object bir Propertiesnesneyi bir nesneye koyabileceğiniz anlamına geliyordu . Bu hala dokümantasyonda:

'Dan Propertiesmiras aldığından Hashtable, putve putAllyöntemleri bir Propertiesnesneye uygulanabilir . Arayanın anahtarları veya değerleri Strings olmayan girişler eklemesine izin verdikleri için bunların kullanımı kesinlikle önerilmez . Bunun setPropertyyerine yöntem kullanılmalıdır.

Bununla uyumluluğu sürdürmek için, tasarımcıların onu Map<Object, Object>Java 5'te miras almaktan başka seçeneği yoktu . Bu, yeni kodu gereksiz yere karıştıran tam bir geriye dönük uyumluluk çabasının talihsiz bir sonucudur.

Yalnızca hiç dize özelliklerini kullanırsanız Propertiesnesne, sen gerektiğini Yapıcınızda denetlenmeyen bir döküm ile kurtulmak mümkün:

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

veya kopyasız:

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

bunun nedeni yalnızca HashMap yapıcısının Map generic türünde bir argüman gerektirmesi ve Properties'in Map uygulamasını kullanmasıdır.

Bu bir uyarı olsa da işe yarayacak

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

Bunu kullanabilirsiniz:

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

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

İlk şey,

Özellikler sınıfı Hashmap'e değil Hashtable'a dayanır. Özellikler sınıfı temelde Hashtable'ı genişletir

HashMap sınıfında bir properties nesnesini alıp size bir hashmap nesnesi döndüren böyle bir kurucu yoktur. Yani yaptığınız şey doğru DEĞİL. Özellikler nesnesini hashtable referansına çevirebilmelisiniz.

Bunu kullanıyorum:

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