මේ වගේ ජාවා හැෂ්මැප් ආරම්භ කිරීමට යම් ක්‍රමයක් තිබේද?:

Map<String,String> test = 
    new HashMap<String, String>{"test":"test","test":"test"};

නිවැරදි වාක්‍ය ඛණ්ඩය කුමක්ද? මම මේ සම්බන්ධයෙන් කිසිවක් සොයාගෙන නැත. මෙය කළ හැකිද? කිසි විටෙකත් වෙනස් නොවන සහ සිතියම නිර්මාණය කිරීමේදී කල්තියා දන්නා සිතියමක "අවසාන / ස්ථිතික" අගයන් කිහිපයක් තැබීමට මම කෙටිම / වේගවත්ම ක්‍රමය සොයමි.

සියලුම අනුවාද

ඔබට එක් ප්‍රවේශයක් පමණක් අවශ්‍ය වූ විට: තිබේ Collections.singletonMap("key", "value").

ජාවා අනුවාදය 9 හෝ ඊට වැඩි:

ඔව්, මෙය දැන් කළ හැකිය. ජාවා 9 හි සිතියම් නිර්මාණය සරල කරන කර්මාන්තශාලා ක්‍රම කිහිපයක් එකතු කර ඇත:

// this works for up to 10 elements:
Map<String, String> test1 = Map.of(
    "a", "b",
    "c", "d"
);

// this works for any number of elements:
import static java.util.Map.entry;    
Map<String, String> test2 = Map.ofEntries(
    entry("a", "b"),
    entry("c", "d")
);

දෙකම ඉහත උදාහරණයේ testහා test2හුදෙක් සිතියම ප්රකාශ විවිධ ක්රම සමග, එම වනු ඇත. Map.ofසිතියමේ මූලද්‍රව්‍ය දහයක් දක්වා මෙම ක්‍රමය අර්ථ දක්වා ඇති අතර Map.ofEntriesක්‍රමයට එවැනි සීමාවක් නොමැත.

මෙම අවස්ථාවේ දී ලැබෙන සිතියම වෙනස් කළ නොහැකි සිතියමක් වනු ඇති බව සලකන්න. ඔබට සිතියම විකෘති වීමට අවශ්‍ය නම්, ඔබට එය නැවත පිටපත් කළ හැකිය, උදාmutableMap = new HashMap<>(Map.of("a", "b"));

( JEP 269 සහ Javadoc ද බලන්න )

ජාවා අනුවාදය 8 දක්වා:

නැත, ඔබට සියලු අංග අතින් එකතු කිරීමට සිදුවේ. සින්ටැක්ස් ටිකක් කෙටි කිරීමට ඔබට නිර්නාමික උප පංතියක ආරම්භක භාවිතා කළ හැකිය:

Map<String, String> myMap = new HashMap<String, String>() {{
        put("a", "b");
        put("c", "d");
    }};

කෙසේ වෙතත්, නිර්නාමික උප පංතිය සමහර අවස්ථාවල අනවශ්‍ය හැසිරීම් හඳුන්වා දිය හැකිය. උදාහරණයක් ලෙස මෙයට ඇතුළත් වේ:

• එය අතිරේක පන්තියක් ජනනය කරන අතර එය මතක පරිභෝජනය, තැටි අවකාශ පරිභෝජනය සහ ආරම්භක වේලාව වැඩි කරයි
• ස්ථිතික නොවන ක්‍රමයක් නම්: එය නිර්මාණය කිරීමේ ක්‍රමය කැඳවනු ලැබූ වස්තුවට යොමු දැක්වීමක් කරයි. එයින් අදහස් කරන්නේ නිර්මාණය කරන ලද සිතියම් වස්තුව තවමත් යොමු කර ඇති අතර බාහිර පන්තියේ වස්තුව කසළ එකතු කළ නොහැකි බැවින් අතිරේක මතකය අවහිර වන බවයි

ආරම්භ කිරීම සඳහා ශ්‍රිතයක් භාවිතා කිරීමෙන් ආරම්භකය තුළ සිතියමක් ජනනය කිරීමට ඔබට හැකි වේ, නමුත් නරක අතුරු ආබාධ වළක්වයි:

Map<String, String> myMap = createMap();

private static Map<String, String> createMap() {
    Map<String,String> myMap = new HashMap<String,String>();
    myMap.put("a", "b");
    myMap.put("c", "d");
    return myMap;
}

මෙය එක් ක්‍රමයකි.

HashMap<String, String> h = new HashMap<String, String>() {{
    put("a","b");
}};

කෙසේ වෙතත්, ඔබ පරෙස්සම් විය යුතු අතර ඉහත කේතය ඔබ තේරුම් ගෙන ඇති බවට වග බලා ගන්න (එය හැෂ්මැප් වෙතින් උරුම වන නව පන්තියක් නිර්මාණය කරයි). එමනිසා, ඔබ මෙහි වැඩි විස්තර කියවිය යුතුය: http://www.c2.com/cgi/wiki?DoubleBraceInitialization , හෝ හුදෙක් ගුවා භාවිතා කරන්න:

Map<String, Integer> left = ImmutableMap.of("a", 1, "b", 2, "c", 3);

ඔබ 3 වන පාර්ශ්ව libs ඉඩ නම්, ඔබ භාවිතා කළ හැකිය පේර ගේ ImmutableMap ප්රායෝගික වැනි brevity සාක්ෂාත් කර ගැනීම:

Map<String, String> test = ImmutableMap.of("k1", "v1", "k2", "v2");

මෙය යතුරු / අගය යුගල 5 ක් දක්වා ක්‍රියා කරයි , එසේ නොමැතිනම් ඔබට එහි සාදන්නා භාවිතා කළ හැකිය :

Map<String, String> test = ImmutableMap.<String, String>builder()
    .put("k1", "v1")
    .put("k2", "v2")
    ...
    .build();

• ගුවා හි වෙනස් කළ නොහැකි සිතියම් ක්‍රියාත්මක කිරීම ජාවා හි හැෂ්මැප් වලට වඩා වෙනස් බව සලකන්න ක්රියාත්මක කිරීම (වඩාත් කැපී එය පරමාණු හා අණුවල ශූන්ය යතුරු / වටිනාකම් ඉඩ නැති)
• වැඩි විස්තර සඳහා, ගුවා හි වෙනස් කළ නොහැකි එකතු වර්ග පිළිබඳ පරිශීලක මාර්ගෝපදේශ ලිපිය බලන්න

මෙය කිරීමට සෘජු ක්‍රමයක් නොමැත - ජාවාහි සිතියම් සාක්ෂරතා නොමැත (තවමත් - මම හිතන්නේ ඒවා ජාවා 8 සඳහා යෝජනා කර ඇත).

සමහර අය මේකට කැමතියි:

Map<String,String> test = new HashMap<String, String>(){{
       put("test","test"); put("test","test");}};

මෙය හැෂ්මැප් හි නිර්නාමික උප පංතියක් නිර්මාණය කරයි, නිදසුනක් ලෙස ආරම්භකයා විසින් මෙම අගයන් දක්වයි. (මාර්ගය වන විට, සිතියමකට සමාන අගයක් මෙන් දෙගුණයක් අඩංගු විය නොහැක, ඔබේ දෙවන කොටස පළමු එක නැවත ලියයි. ඊළඟ උදාහරණ සඳහා මම විවිධ අගයන් භාවිතා කරමි.)

සාමාන්‍ය ක්‍රමය මෙයයි (දේශීය විචල්‍යයක් සඳහා):

Map<String,String> test = new HashMap<String, String>();
test.put("test","test");
test.put("test1","test2");

ඔබේ testසිතියම නිදර්ශන විචල්‍යයක් නම්, ආරම්භකය ඉදිකිරීම්කරු හෝ නිදර්ශන ආරම්භකය තුළ තබන්න:

Map<String,String> test = new HashMap<String, String>();
{
    test.put("test","test");
    test.put("test1","test2");
}

ඔබේ testසිතියම පන්ති විචල්‍යයක් නම්, ආරම්භය ස්ථිතික ආරම්භකය තුළට දමන්න:

static Map<String,String> test = new HashMap<String, String>();
static {
    test.put("test","test");
    test.put("test1","test2");
}

ඔබේ සිතියම කිසි විටෙකත් වෙනස් නොවීමට ඔබට අවශ්‍ය නම්, ආරම්භ කිරීමෙන් පසු ඔබේ සිතියම එතීම කළ යුතුය Collections.unmodifiableMap(...). ඔබට මෙය ස්ථිතික ආරම්භකයකද කළ හැකිය:

static Map<String,String> test;
{
    Map<String,String> temp = new HashMap<String, String>();
    temp.put("test","test");
    temp.put("test1","test2");
    test = Collections.unmodifiableMap(temp);
}

(ඔබට දැන් testඅවසන් කළ හැකිදැයි මට විශ්වාස නැත ... එය උත්සාහ කර මෙහි වාර්තා කරන්න.)

Map<String,String> test = new HashMap<String, String>()
{
    {
        put(key1, value1);
        put(key2, value2);
    }
};

විකල්පයක්, සරල ජාවා 7 පන්ති සහ වර්රාග් භාවිතා කරමින් HashMapBuilder: මෙම ක්‍රමය සමඟ පන්තියක් සාදන්න :

public static HashMap<String, String> build(String... data){
    HashMap<String, String> result = new HashMap<String, String>();

    if(data.length % 2 != 0) 
        throw new IllegalArgumentException("Odd number of arguments");      

    String key = null;
    Integer step = -1;

    for(String value : data){
        step++;
        switch(step % 2){
        case 0: 
            if(value == null)
                throw new IllegalArgumentException("Null key value"); 
            key = value;
            continue;
        case 1:             
            result.put(key, value);
            break;
        }
    }

    return result;
}

මේ වගේ ක්‍රමය භාවිතා කරන්න:

HashMap<String,String> data = HashMapBuilder.build("key1","value1","key2","value2");

tl; dr

Map.of…ජාවා 9 සහ ඊට පසු ක්‍රම භාවිතා කරන්න .

Map< String , String > animalSounds =
    Map.of(
        "dog"  , "bark" ,   // key , value
        "cat"  , "meow" ,   // key , value
        "bird" , "chirp"    // key , value
    )
;

Map.of

Map.ofඔබට අවශ්‍ය දේ කිරීමට ජාවා 9 ස්ථිතික ක්‍රම මාලාවක් එක් කළේය : වචනාර්ථයෙන් වාක්‍ය ඛණ්ඩයක් Mapභාවිතා කරමින් වෙනස් කළ නොහැකි ක්ෂණික කරන්න .

සිතියම (ඇතුළත් කිරීම් එකතුවක්) වෙනස් කළ නොහැකි බැවින් ක්ෂණික කිරීමෙන් පසු ඔබට ඇතුළත් කිරීම් හෝ ඉවත් කළ නොහැක. එසේම, එක් එක් පිවිසුමේ යතුර සහ වටිනාකම වෙනස් කළ නොහැකි බැවින් වෙනස් කළ නොහැක. NULL වලට අවසර නැත, අනුපිටපත් යතුරු සඳහා අවසර නැත, සහ සිතියම්ගත කිරීමේ අනුපිළිවෙල අත්තනෝමතික ලෙස වෙනත් නීති සඳහා ජාවඩොක් බලන්න .

මෙම ක්‍රම දෙස බලමු, සතියේ දින සිතියමක් සඳහා නියැදි දත්ත කිහිපයක් භාවිතා කරමින් එදින වැඩ කරනු ඇතැයි අප අපේක්ෂා කරන පුද්ගලයෙකුට.

Person alice = new Person( "Alice" );
Person bob = new Person( "Bob" );
Person carol = new Person( "Carol" );

Map.of()

Map.ofහිස් නිර්මාණය කරයි Map. වෙනස් කළ නොහැකි බැවින් ඔබට ඇතුළත් කිරීම් එකතු කළ නොහැක. එවැනි සිතියමක් සඳහා උදාහරණයක් මෙහි ඇතුළත් කර නැති හිස් ය.

Map < DayOfWeek, Person > dailyWorkerEmpty = Map.of();

dailyWorkerEmpty.toString (): {}

Map.of( … )

Map.of( k , v , k , v , …)යතුරු අගය යුගල 1 සිට 10 දක්වා ගන්නා ක්‍රම කිහිපයක් වේ. ඇතුළත් කිරීම් දෙකකට උදාහරණයක් මෙන්න.

Map < DayOfWeek, Person > weekendWorker = 
        Map.of( 
            DayOfWeek.SATURDAY , alice ,     // key , value
            DayOfWeek.SUNDAY , bob           // key , value
        )
;

weekendWorker.toString (): {SUNDAY = පුද්ගලයා {name = 'Bob'}, SATURDAY = පුද්ගලයා {name = 'Alice'}}

Map.ofEntries( … )

Map.ofEntries( Map.Entry , … )Map.Entryඅතුරුමුහුණත ක්‍රියාත්මක කරන ඕනෑම වස්තු සංඛ්‍යාවක් ගනී . ජාවා විසින් එම අතුරුමුහුණත ක්‍රියාත්මක කරන පන්ති දෙකක්, එක් විකෘති, අනෙක වෙනස් කළ නොහැකි: AbstractMap.SimpleEntry, AbstractMap.SimpleImmutableEntry. නමුත් අපට කොන්ක්‍රීට් පන්තියක් නියම කිරීමට අවශ්‍ය නැත. අපට අවශ්‍ය වන්නේ Map.entry( k , v )ක්‍රමයට ඇමතීම , අපගේ යතුර සහ අපගේ වටිනාකම පසු කිරීම සහ සමහර පන්ති ක්‍රියාත්මක කිරීමේ Map.Entryඅතුරු මුහුණතක වස්තුවක් නැවත ලබා ගැනීමයි .

Map < DayOfWeek, Person > weekdayWorker = Map.ofEntries(
        Map.entry( DayOfWeek.MONDAY , alice ) ,            // Call to `Map.entry` method returns an object implementing `Map.Entry`. 
        Map.entry( DayOfWeek.TUESDAY , bob ) ,
        Map.entry( DayOfWeek.WEDNESDAY , bob ) ,
        Map.entry( DayOfWeek.THURSDAY , carol ) ,
        Map.entry( DayOfWeek.FRIDAY , carol )
);

weekdayWorker.toString (): {WEDNESDAY = පුද්ගලයා {name = 'Bob'}, TUESDAY = පුද්ගලයා {name = 'Bob'}, THURSDAY = පුද්ගලයා {name = 'Carol'}, FRIDAY = පුද්ගලයා {name = 'Carol'} , සඳුදා = පුද්ගලයා {name = 'ඇලිස්'}}

Map.copyOf

ජාවා 10 ක්රමය එකතු කළේය Map.copyOf . පවතින සිතියමක් පසුකර, එම සිතියමේ වෙනස් කළ නොහැකි පිටපතක් ආපසු ලබා ගන්න.

සටහන්

හරහා ඉදිරිපත් සිතියම් iterator පිණිස බව දැනුම් Map.ofවේ නොහැකි සහතික. ඇතුළත් කිරීම් අත්තනෝමතික අනුපිළිවෙලක් ඇත. පෙනෙන අනුපිළිවෙල මත පදනම්ව කේත ලියන්න එපා, ප්‍රලේඛනය අනතුරු අඟවන පරිදි ඇණවුම වෙනස් විය යුතුය.

මේ සියල්ල සටහන Map.of…ක්රම ආපසු Mapක ස්නායු පන්තියේ . යටින් පවතින කොන්ක්‍රීට් පන්තිය ජාවාහි එක් අනුවාදයක සිට තවත් අනුවාදයකට වෙනස් විය හැකිය. මෙම නිර්නාමික භාවය මඟින් ඔබේ විශේෂිත දත්ත වලට වඩාත් ගැලපෙන ඕනෑම දෙයක් විවිධ ක්‍රියාත්මක කිරීම් වලින් තෝරා ගැනීමට ජාවාට හැකියාව ලැබේ. උදාහරණයක් ලෙස, ඔබේ යතුරු එනූමයකින් පැමිණියේ නම් , ජාවා EnumMapආවරණ යටින් භාවිතා කරයි.

ජාවා 8

සරල ජාවා 8 හි ඔබට Streams/Collectorsඑම කාර්යය කිරීමට භාවිතා කිරීමේ හැකියාව ද ඇත .

Map<String, String> myMap = Stream.of(
         new SimpleEntry<>("key1", "value1"),
         new SimpleEntry<>("key2", "value2"),
         new SimpleEntry<>("key3", "value3"))
        .collect(toMap(SimpleEntry::getKey, SimpleEntry::getValue));

නිර්නාමික පංතියක් නිර්මාණය නොකිරීමේ වාසිය මෙයයි.

ආනයන:

import static java.util.stream.Collectors.toMap;
import java.util.AbstractMap.SimpleEntry;

ඇත්ත වශයෙන්ම, වෙනත් පිළිතුරු වල සඳහන් කර ඇති පරිදි, ජාවා 9 සිට ඔබට එය කිරීමට සරල ක්‍රම තිබේ.

ඔබට Map.ofපහසු ක්‍රම 2 කින් ඔබේම (එය ජාවා 9 සහ ඊට වැඩි) පමණක් ලබා ගත හැකිය

නියමිත පරාමිතීන් සමඟ එය සාදන්න

උදාහරණයක්

public <K,V> Map<K,V> mapOf(K k1, V v1, K k2, V v2 /* perhaps more parameters */) {
    return new HashMap<K, V>() {{
      put(k1, v1);
      put(k2,  v2);
      // etc...
    }};
}

ලැයිස්තුවක් භාවිතයෙන් එය සාදන්න

නිශ්චිත පරාමිති සමූහයක් සඳහා ක්‍රම රාශියක් සෑදීම වෙනුවට ඔබට මෙය ලැයිස්තුවක් භාවිතයෙන් කළ හැකිය.

උදාහරණයක්

public <K, V> Map<K, V> mapOf(List<K> keys, List<V> values) {
   if(keys.size() != values.size()) {
        throw new IndexOutOfBoundsException("amount of keys and values is not equal");
    }

    return new HashMap<K, V>() {{
        IntStream.range(0, keys.size()).forEach(index -> put(keys.get(index), values.get(index)));
    }};
}

සටහන ඔබ මෙය භාවිතා කරන සෑම අවස්ථාවකම නිර්නාමික පංතියක් ඇති බැවින් මෙය සෑම දෙයක් සඳහාම භාවිතා කිරීම රෙකමදාරු කරනු නොලැබේ.

ජාවා 8 හෝ ඊට අඩු

සමහර අගයන් සහිත සිතියමක් ආරම්භ කිරීමට ඔබට ස්ථිතික බ්ලොක් භාවිතා කළ හැකිය. උදාහරණයක් :

public static Map<String,String> test = new HashMap<String, String>

static {
    test.put("test","test");
    test.put("test1","test");
}

ජාවා 9 හෝ ඊට වැඩි

ප්‍රකාශ කිරීමේදී සමහර අගයන් සහිත සිතියමක් ආරම්භ කිරීමට ඔබට Map.of () ක්‍රමය භාවිතා කළ හැකිය. උදාහරණයක් :

public static Map<String,String> test = Map.of("test","test","test1","test");

අවාසනාවකට මෙන්, යතුරු සහ අගයන් එක හා සමාන නොවේ නම් වරග්ස් භාවිතා කිරීම එතරම් සාධාරණ නොවන බැවින් ඔබට භාවිතා කිරීමට සිදු වන Object...අතර සම්පූර්ණයෙන්ම ආරක්‍ෂාව නැති කර ගත යුතුය. ඔබට සැමවිටම උදා: a නිර්මාණය කිරීමට අවශ්‍ය නම් Map<String, String>, ඇත්ත වශයෙන්ම atoMap(String... args) හැකි නමුත් ඉතා ලස්සන එය යතුරු හා අගයන් කලවම් කිරීම පහසු වනු ඇත, සහ තර්ක ඔත්තේ සංඛ්යාවක් අවලංගු වනු ඇත පරිදි විය, නමුත් නැත.

වැනි දාම කළ හැකි ක්‍රමයක් ඇති හැෂ්මැප් හි උප පංතියක් ඔබට නිර්මාණය කළ හැකිය

public class ChainableMap<K, V> extends HashMap<K, V> {
  public ChainableMap<K, V> set(K k, V v) {
    put(k, v);
    return this;
  }
}

එය මෙන් භාවිතා කරන්න new ChainableMap<String, Object>().set("a", 1).set("b", "foo")

තවත් ප්‍රවේශයක් වන්නේ පොදු තනන්නාගේ රටාව භාවිතා කිරීමයි:

public class MapBuilder<K, V> {
  private Map<K, V> mMap = new HashMap<>();

  public MapBuilder<K, V> put(K k, V v) {
    mMap.put(k, v);
    return this;
  }

  public Map<K, V> build() {
    return mMap;
  }
}

එය මෙන් භාවිතා කරන්න new MapBuilder<String, Object>().put("a", 1).put("b", "foo").build();

කෙසේ වෙතත්, මම දැන් භාවිතා කර පසුව වරග්ස් සහ Pairපංතිය භාවිතා කරමි:

public class Maps {
  public static <K, V> Map<K, V> of(Pair<K, V>... pairs) {
    Map<K, V> = new HashMap<>();

    for (Pair<K, V> pair : pairs) {
      map.put(pair.first, pair.second);
    }

    return map;
  }
}

Map<String, Object> map = Maps.of(Pair.create("a", 1), Pair.create("b", "foo");

වාචික භාවය Pair.create()මට ටිකක් කරදර කරයි, නමුත් මෙය තරමක් හොඳින් ක්‍රියාත්මක වේ. ස්ථිතික ආනයනයන් ඔබට ප්‍රශ්නයක් නොවේ නම් ඔබට ඇත්ත වශයෙන්ම සහායකයකු නිර්මාණය කළ හැකිය:

public <K, V> Pair<K, V> p(K k, V v) {
  return Pair.create(k, v);
}

Map<String, Object> map = Maps.of(p("a", 1), p("b", "foo");

(ඒ වෙනුවට Pairඑක් භාවිතා සිතාගත හැකිය Map.Entry, නමුත්, එය ඉතා ක්රියාත්මක පන්තිය හා / හෝ සහකාරියක් කර්මාන්ත ක්රමය අවශ්ය වේ. එය ද මා තුලද නැහැ, මෙම කර්තව්ය සඳහා ප්රයෝජනවත් නොවන වෙනත් තර්ක අඩංගු අතුරු මුහුණතක් කිරීමේ සිට.)

ඔබට ජාවා 8 හි ප්‍රවාහ භාවිතා කළ හැකිය (මෙය කට්ටලයේ ආදර්ශයකි):

@Test
public void whenInitializeUnmodifiableSetWithDoubleBrace_containsElements() {
    Set<String> countries = Stream.of("India", "USSR", "USA")
      .collect(collectingAndThen(toSet(), Collections::unmodifiableSet));

    assertTrue(countries.contains("India"));
}

Ref: https://www.baeldung.com/java-double-brace-initialization

ඔබට එක් යතුරු අගය යුගලයක් පමණක් තැබීමට අවශ්‍ය නම්, ඔබට Collections.singletonMap (යතුර, අගය) භාවිතා කළ හැකිය;

පහත දැක්වෙන උදාහරණයේ මෙන් සිතියම ආරම්භ කිරීමට ඔබට ක්‍රමයක් නිර්මාණය කළ හැකිය.

'' '

Map<String, Integer> initializeMap()
{
  Map<String, Integer> ret = new HashMap<>();
  
  //populate ret
  ...
  
  return ret;
}

//call
Map<String, Integer> map = initializeMap();

'' '