अतिरिक्त या नए मूल्यों

Question

बहुत कैसे एक ImmutableList जैसे बढ़ाया जा सकता है की तरह के साथ एक ImmutableMap विस्तार: (

ImmutableList<Long> originalList = ImmutableList.of(1, 2, 3); 
ImmutableList<Long> extendedList = Iterables.concat(originalList, ImmutableList.of(4, 5)); 

अगर मैं एक मौजूदा नक्शे है, मैं इसे कैसे का विस्तार कर सकता है या बदल दिया मूल्यों के साथ एक नई प्रतिलिपि बनाकर)?

ImmutableMap<String, Long> oldPrices = ImmutableMap.of("banana", 4, "apple", 7); 
ImmutableMap<String, Long> newPrices = … // Increase apple prices, leave others. 
             // => { "banana": 4, "apple": 9 } 

(। के जाहिरा तौर पर that doesn't exist by design के रूप में, एक कुशल समाधान की तलाश नहीं करते हैं यह सवाल नहीं बल्कि सबसे मुहावरेदार समाधान चाहता है।)

Answer 1

आप स्पष्ट रूप से एक बिल्डर बना सकते हैं:

ImmutableMap<String, Long> oldPrices = ImmutableMap.of("banana", 4, "apple", 7); 
ImmutableMap<String, Long> newPrices = 
    new ImmutableMap.Builder() 
    .putAll(oldPrices) 
    .put("orange", 9) 
    .build(); 

संपादित करें:
टिप्पणियों में उल्लेख के अनुसार, यह मौजूदा मानों को ओवरराइड करने की अनुमति नहीं देगा। यह एक अलग Map (उदाहरण के लिए, HashMap) के प्रारंभिक ब्लॉक से जाकर किया जा सकता है। यह लेकिन सुरुचिपूर्ण कुछ भी है, लेकिन यह काम करना चाहिए:

ImmutableMap<String, Long> oldPrices = ImmutableMap.of("banana", 4, "apple", 7); 
ImmutableMap<String, Long> newPrices = 
    new ImmutableMap.Builder() 
    .putAll(new HashMap<>() {{ 
     putAll(oldPrices); 
     put("orange", 9); // new value 
     put("apple", 12); // override an old value 
    }}) 
    .build(); 

Answer 2

बस एक नया HashMap में ImmutableMap कॉपी, आइटम जोड़ने के लिए, और करने के लिए कनवर्ट एक नया ImmutableMap

ImmutableMap<String, Long> oldPrices = ImmutableMap.of("banana", 4, "apple", 7); 
Map<String, Long> copy = new HashMap<>(oldPrices); 
copy.put("orange", 9); // add a new entry 
copy.put("apple", 12); // replace the value of an existing entry 

ImmutableMap<String, Long> newPrices = ImmutableMap.copyOf(copy); 

Answer 3

खैर मैं के साथ इस किया है धाराएं लेकिन यह सही नहीं है:

public static <K,V> Map<K,V> update(final Map<K,V> map, final Map.Entry<K,V> replace) 
{ 
    return Stream.concat(
     Stream.of(replace), 
     map.entrySet().stream() 
      .filter(kv -> ! replace.getKey().equals(kv.getKey())) 
    .collect(Collectors.toMap(SimpleImmutableEntry::getKey, SimpleImmutableEntry::getValue)); 
} 

और यह केवल एक प्रविष्टि दर्ज करता है या अपडेट करता है। ध्यान दें कि ImmutableMap & जुड़े कलेक्टर में छोड़ा जा सकता है (जो मैं वास्तव में क्या प्रयोग किया जाता है)

Answer 4

नहीं एक बहुत performant कोड, लेकिन नीचे काम करेगा

private <K, V> ImmutableMap.Builder<K, V> update(final ImmutableMap.Builder<K, V> builder, final List<ImmutablePair<K, V>> replace) { 
    Set<K> keys = replace.stream().map(entry -> entry.getKey()).collect(toSet()); 
    Map<K, V> map = new HashMap<>(); 
    builder.build().forEach((key, val) -> { 
     if (!keys.contains(key)) { 
      map.put(key, val); 
     } 
    }); 
    ImmutableMap.Builder<K, V> newBuilder = ImmutableMap.builder(); 
    newBuilder.putAll(map); 
    replace.stream().forEach(kvEntry -> newBuilder.put(kvEntry.getKey(), kvEntry.getValue())); 
    return newBuilder; 
}