ඔබ Mapජාවාහි ස්ථිතිකයක් ආරම්භ කරන්නේ කෙසේද ?

පළමු ක්‍රමය: ස්ථිතික ආරම්භක
ක්‍රමය දෙක: නිදර්ශන ආරම්භක (නිර්නාමික උප පංතිය) හෝ වෙනත් ක්‍රමයක්?

එක් එක් අයගේ වාසි සහ අවාසි මොනවාද?

ක්‍රම දෙක නිදර්ශනය කරන උදාහරණයක් මෙන්න:

import java.util.HashMap;
import java.util.Map;

public class Test {
    private static final Map<Integer, String> myMap = new HashMap<>();
    static {
        myMap.put(1, "one");
        myMap.put(2, "two");
    }

    private static final Map<Integer, String> myMap2 = new HashMap<>(){
        {
            put(1, "one");
            put(2, "two");
        }
    };
}

නිදර්ශන ආරම්භකය මේ අවස්ථාවේ දී සින්ටැක්ටික් සීනි පමණක් නේද? ආරම්භ කිරීම සඳහා ඔබට අමතර නිර්නාමික පන්තියක් අවශ්‍ය වන්නේ මන්දැයි මම නොදනිමි. නිර්මාණය කරන පන්තිය අවසාන නම් එය ක්‍රියා නොකරනු ඇත.

ස්ථිතික ආරම්භකය භාවිතා කර ඔබට වෙනස් කළ නොහැකි සිතියමක් නිර්මාණය කළ හැකිය:

public class Test {
    private static final Map<Integer, String> myMap;
    static {
        Map<Integer, String> aMap = ....;
        aMap.put(1, "one");
        aMap.put(2, "two");
        myMap = Collections.unmodifiableMap(aMap);
    }
}

ස්ථිතික, වෙනස් කළ නොහැකි සිතියමක් ආරම්භ කිරීමේ ගුවා ක්‍රමයට මම කැමතියි :

static final Map<Integer, String> MY_MAP = ImmutableMap.of(
    1, "one",
    2, "two"
);

ඔබට පෙනෙන පරිදි, එය ඉතා සංක්ෂිප්ත ය (පහසු කර්මාන්තශාලා ක්‍රම නිසා ImmutableMap).

සිතියමට ඇතුළත් කිරීම් 5 කට වඩා තිබිය යුතු නම්, ඔබට තවදුරටත් භාවිතා කළ නොහැක ImmutableMap.of(). ඒ වෙනුවට, ImmutableMap.builder()මෙම රේඛා ඔස්සේ උත්සාහ කරන්න :

static final Map<Integer, String> MY_MAP = ImmutableMap.<Integer, String>builder()
    .put(1, "one")
    .put(2, "two")
    // ... 
    .put(15, "fifteen")
    .build();

ගුවා හි වෙනස් කළ නොහැකි එකතු කිරීමේ උපයෝගිතා වල ප්‍රතිලාභ ගැන වැඩි විස්තර දැනගැනීම සඳහා, ගුවා පරිශීලක මාර්ගෝපදේශයේ විස්තර කර ඇති වෙනස් කළ නොහැකි එකතුව බලන්න .

(උප කාණ්ඩයක්) ගුවා ගූගල් එකතු කිරීම් ලෙස හැඳින්වේ . ඔබගේ ජාවා ව්‍යාපෘතියේ ඔබ තවමත් මෙම පුස්තකාලය භාවිතා නොකරන්නේ නම්, එය අත්හදා බැලීමට මම තරයේ නිර්දේශ කරමි ! සෙසු SO භාවිතා කරන්නන් එකඟ වන පරිදි ගුවා ඉතා ඉක්මණින් ජාවා සඳහා වඩාත් ජනප්‍රිය හා ප්‍රයෝජනවත් නොමිලේ තෙවන පාර්ශවීය ලිබ් එකක් බවට පත්ව ඇත . (ඔබ එයට අලුත් නම්, එම සබැඳිය පිටුපස විශිෂ්ට ඉගෙනුම් සම්පත් කිහිපයක් තිබේ.)

යාවත්කාලීන කිරීම (2015) : ජාවා 8 සම්බන්ධයෙන් ගත් කල , මම තවමත් ගුවා ප්‍රවේශය භාවිතා කරන්නේ එය අන් සියල්ලටම වඩා පිරිසිදු බැවිනි. ඔබට ගුවා පරායත්තතාවය අවශ්‍ය නැතිනම්, පැරණි පැරණි ක්‍රමයක් සලකා බලන්න . ද්විමාන අරාව සහ ස්ට්‍රීම් ඒපීඅයි සමඟ ඇති හැක් ඔබ මගෙන් ඇසුවොත් එය ඉතා කැත වන අතර යතුරු සහ අගයන් එකම වර්ගයේ නොවන ( Map<Integer, String>ප්‍රශ්නයේදී මෙන් ) සිතියමක් නිර්මාණය කිරීමට ඔබට අවශ්‍ය නම් එය අවලස්සන වේ.

ජාවා 8 සම්බන්ධයෙන් පොදුවේ ගුවා හි අනාගතය සම්බන්ධයෙන්, ලුවී වස්මන් 2014 දී මෙය නැවත පැවසූ අතර, 2016 දී [ යාවත්කාලීන කිරීම ] ගුවා 21 සඳහා ජාවා 8 අවශ්‍ය වන අතර නිසි ලෙස සහාය දෙන බව නිවේදනය කරන ලදී .

යාවත්කාලීන කිරීම (2016) : තාගීර් වලීව් පෙන්වා දෙන පරිදි , එකතු කිරීම සඳහා පහසු කර්මාන්තශාලා ක්‍රම එකතු කිරීමෙන් ජාවා 9 පිරිසිදු ජේඩීකේ හැර වෙනත් කිසිවක් භාවිතා නොකිරීමට මෙය පිරිසිදු කරයි :

static final Map<Integer, String> MY_MAP = Map.of(
    1, "one", 
    2, "two"
);

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

public class Test {
    private static final Map<Integer, String> MY_MAP = createMap();

    private static Map<Integer, String> createMap() {
        Map<Integer, String> result = new HashMap<>();
        result.put(1, "one");
        result.put(2, "two");
        return Collections.unmodifiableMap(result);
    }
}

1. එය නිර්නාමික පංතියක් මග හැරේ, එය මා පෞද්ගලිකව නරක ශෛලියක් ලෙස සලකන අතර එයින් වළකින්න
2. එමඟින් සිතියම නිර්මාණය කිරීම වඩාත් පැහැදිලි කරයි
3. එය සිතියම වෙනස් කළ නොහැකි කරයි
4. MY_MAP නියත බැවින් මම එය නියත ලෙස නම් කරමි

ජාවා 5 මෙම වඩාත් සංයුක්ත වාක්‍ය ඛණ්ඩය සපයයි:

static final Map<String , String> FLAVORS = new HashMap<String , String>() {{
    put("Up",    "Down");
    put("Charm", "Strange");
    put("Top",   "Bottom");
}};

දෙවන ක්‍රමයට ඇති එක් වාසියක් නම්, Collections.unmodifiableMap()පසුව කිසිවක් එකතු කිරීම යාවත්කාලීන නොවන බවට සහතික වීම සඳහා ඔබට එය ඔතා තැබිය හැකිය :

private static final Map<Integer, String> CONSTANT_MAP = 
    Collections.unmodifiableMap(new HashMap<Integer, String>() {{ 
        put(1, "one");
        put(2, "two");
    }});

 // later on...

 CONSTANT_MAP.put(3, "three"); // going to throw an exception!

මෙන්න ජාවා 8 එක්-පේළියේ ස්ථිතික සිතියම් ආරම්භකය:

private static final Map<String, String> EXTENSION_TO_MIMETYPE =
    Arrays.stream(new String[][] {
        { "txt", "text/plain" }, 
        { "html", "text/html" }, 
        { "js", "application/javascript" },
        { "css", "text/css" },
        { "xml", "application/xml" },
        { "png", "image/png" }, 
        { "gif", "image/gif" }, 
        { "jpg", "image/jpeg" },
        { "jpeg", "image/jpeg" }, 
        { "svg", "image/svg+xml" },
    }).collect(Collectors.toMap(kv -> kv[0], kv -> kv[1]));

සංස්කරණය කරන්න: Map<Integer, String>ප්‍රශ්නයේ දී මෙන් ආරම්භ කිරීමට, ඔබට මේ වගේ දෙයක් අවශ්‍ය වනු ඇත:

static final Map<Integer, String> MY_MAP = Arrays.stream(new Object[][]{
        {1, "one"},
        {2, "two"},
}).collect(Collectors.toMap(kv -> (Integer) kv[0], kv -> (String) kv[1]));

සංස්කරණය කරන්න (2): new SimpleEntry<>(k, v)ඇමතුම් ප්‍රවාහයක් භාවිතා කරන i_am_zero විසින් වඩා හොඳ, මිශ්‍ර ආකාරයේ හැකියාවක් ඇති අනුවාදයක් ඇත . එම පිළිතුර බලන්න: https://stackoverflow.com/a/37384773/3950982

Map.of ජාවා 9+ හි

private static final Map<Integer, String> MY_MAP = Map.of(1, "one", 2, "two");

වැඩි විස්තර සඳහා JEP 269 බලන්න. JDK 9 2017 සැප්තැම්බර් මාසයේදී සාමාන්‍ය ලබා ගත හැකි විය.

ජාවා 9

එක් එක් ප්‍රවේශය නිර්මාණය කිරීම සඳහා අපට Map.ofEntriesඇමතුම් භාවිතා කළ හැකිය Map.entry( k , v ).

import static java.util.Map.entry;
private static final Map<Integer,String> map = Map.ofEntries(
        entry(1, "one"),
        entry(2, "two"),
        entry(3, "three"),
        entry(4, "four"),
        entry(5, "five"),
        entry(6, "six"),
        entry(7, "seven"),
        entry(8, "eight"),
        entry(9, "nine"),
        entry(10, "ten"));

ඒ වගේම අපි භාවිතා කළ හැකි Map.ofඔහුගේ පිළිතුරු Tagir යෝජනා කරන පරිදි මෙහි නමුත් අපි භාවිතා කිරීම් 10 කට වඩා තිබිය නොහැක Map.of.

ජාවා 8 (පිළිවෙලට විසඳුම)

අපට සිතියම් ඇතුළත් කිරීම් ප්‍රවාහයක් නිර්මාණය කළ හැකිය. අපි මේ වන විටත් ක්රියාත්මක කිරිමේදි දෙකක් Entryතුළ java.util.AbstractMapවන SimpleEntry හා SimpleImmutableEntry . මෙම උදාහරණය සඳහා අපට කලින් භාවිතා කළ හැකිය:

import java.util.AbstractMap.*;
private static final Map<Integer, String> myMap = Stream.of(
            new SimpleEntry<>(1, "one"),
            new SimpleEntry<>(2, "two"),
            new SimpleEntry<>(3, "three"),
            new SimpleEntry<>(4, "four"),
            new SimpleEntry<>(5, "five"),
            new SimpleEntry<>(6, "six"),
            new SimpleEntry<>(7, "seven"),
            new SimpleEntry<>(8, "eight"),
            new SimpleEntry<>(9, "nine"),
            new SimpleEntry<>(10, "ten"))
            .collect(Collectors.toMap(SimpleEntry::getKey, SimpleEntry::getValue));

සූර්යග්‍රහණ එකතුව සමඟ , පහත සඳහන් සියල්ල ක්‍රියාත්මක වනු ඇත:

import java.util.Map;

import org.eclipse.collections.api.map.ImmutableMap;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.impl.factory.Maps;

public class StaticMapsTest
{
    private static final Map<Integer, String> MAP =
        Maps.mutable.with(1, "one", 2, "two");

    private static final MutableMap<Integer, String> MUTABLE_MAP =
       Maps.mutable.with(1, "one", 2, "two");


    private static final MutableMap<Integer, String> UNMODIFIABLE_MAP =
        Maps.mutable.with(1, "one", 2, "two").asUnmodifiable();


    private static final MutableMap<Integer, String> SYNCHRONIZED_MAP =
        Maps.mutable.with(1, "one", 2, "two").asSynchronized();


    private static final ImmutableMap<Integer, String> IMMUTABLE_MAP =
        Maps.mutable.with(1, "one", 2, "two").toImmutable();


    private static final ImmutableMap<Integer, String> IMMUTABLE_MAP2 =
        Maps.immutable.with(1, "one", 2, "two");
}

ඔබට සූර්යග්‍රහණ එකතුව සමඟ ප්‍රාථමික සිතියම් ස්ථිතිකව ආරම්භ කළ හැකිය.

import org.eclipse.collections.api.map.primitive.ImmutableIntObjectMap;
import org.eclipse.collections.api.map.primitive.MutableIntObjectMap;
import org.eclipse.collections.impl.factory.primitive.IntObjectMaps;

public class StaticPrimitiveMapsTest
{
    private static final MutableIntObjectMap<String> MUTABLE_INT_OBJ_MAP =
            IntObjectMaps.mutable.<String>empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two");

    private static final MutableIntObjectMap<String> UNMODIFIABLE_INT_OBJ_MAP =
            IntObjectMaps.mutable.<String>empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")
                    .asUnmodifiable();

    private static final MutableIntObjectMap<String> SYNCHRONIZED_INT_OBJ_MAP =
            IntObjectMaps.mutable.<String>empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")
                    .asSynchronized();

    private static final ImmutableIntObjectMap<String> IMMUTABLE_INT_OBJ_MAP =
            IntObjectMaps.mutable.<String>empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")
                    .toImmutable();

    private static final ImmutableIntObjectMap<String> IMMUTABLE_INT_OBJ_MAP2 =
            IntObjectMaps.immutable.<String>empty()
                    .newWithKeyValue(1, "one")
                    .newWithKeyValue(2, "two");
} 

සටහන: මම සූර්යග්‍රහණ එකතුව සඳහා කැපවන්නෙක් වෙමි

මෙම තත්වය තුළ මම කිසි විටෙක නිර්නාමික උප පංතියක් නිර්මාණය නොකරමි. උදාහරණයක් ලෙස සිතියම නවීකරණය කළ නොහැකි කිරීමට ස්ථිතික ආරම්භකයින් සමානව ක්‍රියා කරයි:

private static final Map<Integer, String> MY_MAP;
static
{
    Map<Integer, String>tempMap = new HashMap<Integer, String>();
    tempMap.put(1, "one");
    tempMap.put(2, "two");
    MY_MAP = Collections.unmodifiableMap(tempMap);
}

සමහර විට ගූගල් එකතුව පරීක්ෂා කිරීම සිත්ගන්නාසුළුය , උදා: ඔවුන්ගේ පිටුවේ ඇති වීඩියෝ. ඒවා සිතියම් සහ කට්ටල ආරම්භ කිරීමට විවිධ ක්‍රම සපයන අතර වෙනස් කළ නොහැකි එකතු කිරීම් ද සපයයි.

යාවත්කාලීන කිරීම: මෙම පුස්තකාලය දැන් ගුවා ලෙස නම් කර ඇත.

මම නිර්නාමික පන්තියට කැමතියි, මන්ද එය සමඟ කටයුතු කිරීම පහසුය:

public static final Map<?, ?> numbers = Collections.unmodifiableMap(new HashMap<Integer, String>() {
    {
        put(1, "some value");
                    //rest of code here
    }
});

public class Test {
    private static final Map<Integer, String> myMap;
    static {
        Map<Integer, String> aMap = ....;
        aMap.put(1, "one");
        aMap.put(2, "two");
        myMap = Collections.unmodifiableMap(aMap);
    }
}

අපි නියත එකකට වඩා ප්‍රකාශ කළහොත් එම කේතය ස්ථිතික කොටසකින් ලියා ඇති අතර එය අනාගතයේදී නඩත්තු කිරීම දුෂ්කර ය. එබැවින් නිර්නාමික පංතියක් භාවිතා කිරීම වඩා හොඳය.

public class Test {

    public static final Map numbers = Collections.unmodifiableMap(new HashMap(2, 1.0f){
        {
            put(1, "one");
            put(2, "two");
        }
    });
}

නියත ලෙස සැලකිය නොහැකි වෙනත් wise ානවන්තයන් සඳහා වෙනස් කළ නොහැකි සිතියමක් භාවිතා කිරීමට යෝජනා කෙරේ.

ස්ථිතික බ්ලොක් ශෛලියට වඩා "ද්විත්ව වරහන් ආරම්භක" විලාසය මට තරයේ යෝජනා කළ හැකිය.

නිර්නාමික පංතිය, පොදු කාර්ය, කාර්ය සාධනය යනාදිය තමන් කැමති නැති බව යමෙක් අදහස් දැක්විය හැකිය.

නමුත් මම වඩාත් සලකා බලන්නේ කේත කියවීමේ හැකියාව සහ නඩත්තු කිරීමේ හැකියාවයි. මෙම දෘෂ්ටි කෝණයෙන් බලන විට, ද්විත්ව වරහන වඩා හොඳ කේත ශෛලියක් නොව ස්ථිතික ක්‍රමයකි.

1. මූලද්රව්ය කූඩු සහ පේළිගත කර ඇත.
2. එය වැඩිපුර OO මිස ක්‍රියා පටිපාටිය නොවේ.
3. කාර්ය සාධන බලපෑම සැබවින්ම කුඩා වන අතර එය නොසලකා හැරිය හැකිය.
4. වඩා හොඳ IDE ලුහු line ු සටහන් සහාය (ඒ වෙනුවට බොහෝ නිර්නාමික ස්ථිතික}} වාරණය)
5. ඔවුන් අතර සම්බන්ධතාවය ගෙන ඒම සඳහා ඔබ අදහස් දැක්වීම් කිහිපයක් ඉතිරි කර ඇත.
6. ව්‍යතිරේකයෙන් සහ බයිට්කෝඩ් ප්‍රශස්තකරණයෙන් ආරම්භ නොකළ වස්තුවක මූලද්‍රව්‍ය කාන්දු වීම / නිදර්ශන ඊයම් වළක්වන්න.
7. ස්ථිතික කොටස ක්‍රියාත්මක කිරීමේ අනුපිළිවෙල ගැන කරදර නොවන්න.

ඊට අමතරව, එය ඔබ නිර්නාමික පංතියේ GC ගැන දැන සිටි අතර, ඔබට එය භාවිතා කිරීමෙන් සෑම විටම එය සාමාන්‍ය හැෂ්මැප් බවට පරිවර්තනය කළ හැකිය new HashMap(Map map).

ඔබ වෙනත් ගැටලුවකට මුහුණ දෙන තුරු ඔබට මෙය කළ හැකිය. ඔබ එසේ කරන්නේ නම්, ඔබ ඒ සඳහා තවත් කේතීකරණ ශෛලියක් භාවිතා කළ යුතුය (උදා: ස්ථිතික, කර්මාන්තශාලා පන්තියක් නැත).

සුපුරුදු පරිදි අපාචේ - කොමන්ස් සඳහා නිසි ක්‍රමයක් ඇත MapUtils.putAll (සිතියම, වස්තුව []) :

උදාහරණයක් ලෙස, වර්ණ සිතියමක් නිර්මාණය කිරීමට:

Map<String, String> colorMap = MapUtils.putAll(new HashMap<String, String>(), new String[][] {
     {"RED", "#FF0000"},
     {"GREEN", "#00FF00"},
     {"BLUE", "#0000FF"}
 });

මට ගුවා භාවිතා කිරීමට අවශ්‍ය නැති විට (හෝ නොහැකි) ImmutableMap.of()හෝ මට විකෘති අවශ්‍ය නම් මෙන්න මගේ ප්‍රියතම දේ Map:

public static <A> Map<String, A> asMap(Object... keysAndValues) {
    return new LinkedHashMap<String, A>() {{
        for (int i = 0; i < keysAndValues.length - 1; i++) {
            put(keysAndValues[i].toString(), (A) keysAndValues[++i]);
        }
    }};
}

එය ඉතා සංයුක්ත වන අතර එය අයාලේ යන අගයන් නොසලකා හරියි (එනම් අගයක් නොමැති අවසාන යතුරක්).

භාවිතය:

Map<String, String> one = asMap("1stKey", "1stVal", "2ndKey", "2ndVal");
Map<String, Object> two = asMap("1stKey", Boolean.TRUE, "2ndKey", new Integer(2));

ඔබ unmodifiable සිතියම අවශ්ය නම්, අවසානයේ ජාවා 9 සිසිල් කර්මාන්ත ක්රමය එකතු ofකිරීමට Mapඅතුරු මුහුණත. Set, List සඳහා ද සමාන ක්‍රමයක් එකතු කරනු ලැබේ.

Map<String, String> unmodifiableMap = Map.of("key1", "value1", "key2", "value2");

නිර්නාමික පංති උත්පාදනය කිරීමෙන් වළක්වා ගැනීම සඳහා ස්ථිතික ආරම්භක යන්ත්‍රයක් භාවිතා කිරීමට මම කැමැත්තෙමි (එයට තවත් අරමුණක් නැත), එබැවින් මම ස්ථිතික ආරම්භකය සමඟ ආරම්භක ඉඟි ලැයිස්තුගත කරමි. සියලුම ලැයිස්තුගත විසඳුම් / ඉඟි ටයිප්-ආරක්ෂිතයි.

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

පළමු ඉඟිය

1 වන ඉඟිය නම් ඔබට සිතියම සඳහා දේශීය සඳහනක් කළ හැකි අතර ඔබ එයට කෙටි නමක් ලබා දේ:

private static final Map<Integer, String> myMap = new HashMap<>();
static {
    final Map<Integer, String> m = myMap; // Use short name!
    m.put(1, "one"); // Here referencing the local variable which is also faster!
    m.put(2, "two");
    m.put(3, "three");
}

දෙවන ඉඟිය

දෙවන ඉඟිය නම්, ඇතුළත් කිරීම් එකතු කිරීම සඳහා ඔබට උපකාරක ක්‍රමයක් නිර්මාණය කළ හැකිය; ඔබට අවශ්‍ය නම් මෙම සහායක ක්‍රමය ප්‍රසිද්ධ කළ හැකිය:

private static final Map<Integer, String> myMap2 = new HashMap<>();
static {
    p(1, "one"); // Calling the helper method.
    p(2, "two");
    p(3, "three");
}

private static void p(Integer k, String v) {
    myMap2.put(k, v);
}

මෙහි ඇති උපකාරක ක්‍රමය නැවත භාවිතා කළ නොහැකි වුවද එයට මූලද්‍රව්‍ය එකතු කළ හැකි බැවිනි myMap2. එය නැවත භාවිතයට ගත හැකි වන පරිදි, අපට සිතියම උපකාරක ක්‍රමයේ පරාමිතියක් බවට පත් කළ හැකි නමුත් ආරම්භක කේතය කෙටි නොවේ.

තෙවන ඉඟිය

3 වන ඉඟිය නම්, ජනගහන ක්‍රියාකාරිත්වය සමඟ නැවත භාවිතා කළ හැකි තනන්නෙකු වැනි උපකාරක පන්තියක් ඔබට නිර්මාණය කළ හැකිය. මෙය සැබවින්ම සරල, පේළි 10 ක උපකාරක පන්තියකි.

public class Test {
    private static final Map<Integer, String> myMap3 = new HashMap<>();
    static {
        new B<>(myMap3)   // Instantiating the helper class with our map
            .p(1, "one")
            .p(2, "two")
            .p(3, "three");
    }
}

class B<K, V> {
    private final Map<K, V> m;

    public B(Map<K, V> m) {
        this.m = m;
    }

    public B<K, V> p(K k, V v) {
        m.put(k, v);
        return this; // Return this for chaining
    }
}

ඔබ නිර්මාණය කරන නිර්නාමික පන්තිය හොඳින් ක්‍රියාත්මක වේ. කෙසේ වෙතත් මෙය අභ්‍යන්තර පංතියක් බව ඔබ දැන සිටිය යුතු අතර ඒ නිසා අවට පන්තියේ උදාහරණයකට එය යොමු වනු ඇත. එබැවින් ඔබට එය සමඟ යම් යම් දේ කළ නොහැකි බව ඔබට පෙනී යනු ඇත ( එකක් සඳහා XStream භාවිතා කිරීම). ඔබට ඉතා අමුතු දෝෂ කිහිපයක් ලැබෙනු ඇත.

එසේ පැවසීමෙන් පසු, ඔබ දන්නා තාක් කල් මෙම ප්‍රවේශය හොඳයි. සියලු වර්ගවල එකතු කිරීම් සංක්ෂිප්ත ආකාරයකින් ආරම්භ කිරීම සඳහා මම බොහෝ විට එය භාවිතා කරමි.

සංස්කරණය කරන්න: මෙය ස්ථිතික පංතියක් බව අදහස් දැක්වීමේදී නිවැරදිව පෙන්වා දී ඇත. නිසැකවම මම මෙය සමීපව කියවා නැත. කෙසේ වෙතත් මගේ අදහස් කරන්නේ තවමත් නිර්නාමික අභ්යන්තර පන්ති සඳහා අදාළ වේ.

ඔබට දැඩි හා සාපේක්ෂව ආරක්ෂිත යමක් අවශ්‍ය නම්, ඔබට සම්පාදක-කාල වර්ගයේ පරීක්ෂාව ධාවන කාලයට මාරු කළ හැකිය:

static final Map<String, Integer> map = MapUtils.unmodifiableMap(
    String.class, Integer.class,
    "cat",  4,
    "dog",  2,
    "frog", 17
);

මෙම ක්‍රියාත්මක කිරීම මඟින් කිසියම් දෝෂයක් ඇතිවිය යුතුය:

import java.util.HashMap;

public abstract class MapUtils
{
    private MapUtils() { }

    public static <K, V> HashMap<K, V> unmodifiableMap(
            Class<? extends K> keyClazz,
            Class<? extends V> valClazz,
            Object...keyValues)
    {
        return Collections.<K, V>unmodifiableMap(makeMap(
            keyClazz,
            valClazz,
            keyValues));
    }

    public static <K, V> HashMap<K, V> makeMap(
            Class<? extends K> keyClazz,
            Class<? extends V> valClazz,
            Object...keyValues)
    {
        if (keyValues.length % 2 != 0)
        {
            throw new IllegalArgumentException(
                    "'keyValues' was formatted incorrectly!  "
                  + "(Expected an even length, but found '" + keyValues.length + "')");
        }

        HashMap<K, V> result = new HashMap<K, V>(keyValues.length / 2);

        for (int i = 0; i < keyValues.length;)
        {
            K key = cast(keyClazz, keyValues[i], i);
            ++i;
            V val = cast(valClazz, keyValues[i], i);
            ++i;
            result.put(key, val);
        }

        return result;
    }

    private static <T> T cast(Class<? extends T> clazz, Object object, int i)
    {
        try
        {
            return clazz.cast(object);
        }
        catch (ClassCastException e)
        {
            String objectName = (i % 2 == 0) ? "Key" : "Value";
            String format = "%s at index %d ('%s') wasn't assignable to type '%s'";
            throw new IllegalArgumentException(String.format(format, objectName, i, object.toString(), clazz.getSimpleName()), e);
        }
    }
}

ජාවා 8 සමඟ මම පහත රටාව භාවිතා කිරීමට පැමිණියෙමි:

private static final Map<String, Integer> MAP = Stream.of(
    new AbstractMap.SimpleImmutableEntry<>("key1", 1),
    new AbstractMap.SimpleImmutableEntry<>("key2", 2)
).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

එය වඩාත්ම වෙහෙසකර හා ටිකක් වටරවුම නොවේ, නමුත්

• එයට පිටතින් කිසිවක් අවශ්‍ය නොවේ java.util
• එය යතුරු පුවරුව ආරක්ෂිත වන අතර යතුර සහ වටිනාකම සඳහා විවිධ වර්ගයන්ට පහසුවෙන් ඉඩ සලසයි.

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

Map<K, V> map = Collections.singletonMap(key, value)

ඔබට මෙම භාවිත කළ හැක StickyMapසහ MapEntryසිට Cactoos :

private static final Map<String, String> MAP = new StickyMap<>(
  new MapEntry<>("name", "Jeffrey"),
  new MapEntry<>("age", "35")
);

ඔබගේ දෙවන ප්‍රවේශය (ද්විත්ව වරහන ආරම්භ කිරීම) ප්‍රති-රටාවක් ලෙස සැලකේ , එබැවින් මම පළමු ප්‍රවේශය සඳහා යන්නෙමි.

ස්ථිතික සිතියමක් ආරම්භ කිරීමට තවත් පහසු ක්‍රමයක් නම් මෙම උපයෝගීතා ශ්‍රිතය භාවිතා කිරීමයි:

public static <K, V> Map<K, V> mapOf(Object... keyValues) {
    Map<K, V> map = new HashMap<>(keyValues.length / 2);

    for (int index = 0; index < keyValues.length / 2; index++) {
        map.put((K)keyValues[index * 2], (V)keyValues[index * 2 + 1]);
    }

    return map;
}

Map<Integer, String> map1 = mapOf(1, "value1", 2, "value2");
Map<String, String> map2 = mapOf("key1", "value1", "key2", "value2");

සටහන: Java 9ඔබට Map.of භාවිතා කළ හැකිය

මම ස්ථිතික ආරම්භක සින්ටැක්ස් වලට කැමති නැති අතර නිර්නාමික උප පංති වලට මට ඒත්තු ගැන්වී නැත. සාමාන්‍යයෙන්, ස්ථිතික ආරම්භක භාවිතා කිරීමේ සියලු අවාසි සහ පූර්ව පිළිතුරු වල සඳහන් කර ඇති නිර්නාමික උප පංති භාවිතා කිරීමේ සියලු අවාසි සමඟ මම එකඟ වෙමි. අනෙක් අතට - මෙම තනතුරු වල ඉදිරිපත් කර ඇති වාසි මට ප්‍රමාණවත් නොවේ. ස්ථිතික ආරම්භක ක්‍රමය භාවිතා කිරීමට මම කැමැත්තෙමි:

public class MyClass {
    private static final Map<Integer, String> myMap = prepareMap();

    private static Map<Integer, String> prepareMap() {
        Map<Integer, String> hashMap = new HashMap<>();
        hashMap.put(1, "one");
        hashMap.put(2, "two");

        return hashMap;
    }
}

මම භාවිතා කරන ප්‍රවේශය (සහ කැමති වීමට වැඩී ඇති) කිසිදු පිළිතුරක පළ කර ඇති බවක් මා දැක නැත, එබැවින් මෙන්න එයයි:

ස්ථිතික ආරම්භක භාවිතා කිරීමට මා කැමති නැත, මන්ද ඒවා අවුල් සහගත බැවින් මම නිර්නාමික පංති වලට කැමති නැත, මන්ද එය එක් එක් අවස්ථාව සඳහා නව පන්තියක් නිර්මාණය කරන බැවිනි.

ඒ වෙනුවට, මම කැමතියි මේ වගේ පෙනුමක් ඇති ආරම්භයට:

map(
    entry("keyA", "val1"),
    entry("keyB", "val2"),
    entry("keyC", "val3")
);

අවාසනාවකට මෙන්, මෙම ක්‍රම සම්මත ජාවා පුස්තකාලයේ කොටසක් නොවේ, එබැවින් ඔබට පහත සඳහන් ක්‍රම නිර්වචනය කරන උපයෝගිතා පුස්තකාලයක් නිර්මාණය කිරීමට (හෝ භාවිතා කිරීමට) අවශ්‍ය වනු ඇත:

 public static <K,V> Map<K,V> map(Map.Entry<K, ? extends V>... entries)
 public static <K,V> Map.Entry<K,V> entry(K key, V val)

(ක්‍රමයේ නම උපසර්ග කිරීම අවශ්‍ය නොවීමට ඔබට 'ආනයන ස්ථිතික' භාවිතා කළ හැකිය)

අනෙක් එකතු කිරීම් සඳහා සමාන ස්ථිතික ක්‍රම සැපයීම ප්‍රයෝජනවත් බව මට පෙනී ගියේය (ලැයිස්තුව, කට්ටලය, වර්ග කිරීම, වර්ග කිරීම සිතියම් ආදිය)

එය json වස්තු ආරම්භය තරම් හොඳ නැත, නමුත් කියවීමේ හැකියාව සම්බන්ධයෙන් ගත් කල එය එම දිශාවේ පියවරකි.

ජාවා සිතියම් සාහිත්‍යකරුවන්ට සහය නොදක්වන හෙයින්, සිතියම් අවස්ථා සැමවිටම පැහැදිලිවම ක්ෂණිකව හා ජනගහනයෙන් යුක්ත විය යුතුය.

වාසනාවකට මෙන්, කර්මාන්තශාලා ක්‍රම භාවිතා කරමින් ජාවා හි සිතියම් සාහිත්‍යකරුවන්ගේ හැසිරීම දළ වශයෙන් දැක්විය හැකිය .

උදාහරණයක් වශයෙන්:

public class LiteralMapFactory {

    // Creates a map from a list of entries
    @SafeVarargs
    public static <K, V> Map<K, V> mapOf(Map.Entry<K, V>... entries) {
        LinkedHashMap<K, V> map = new LinkedHashMap<>();
        for (Map.Entry<K, V> entry : entries) {
            map.put(entry.getKey(), entry.getValue());
        }
        return map;
    }
    // Creates a map entry
    public static <K, V> Map.Entry<K, V> entry(K key, V value) {
        return new AbstractMap.SimpleEntry<>(key, value);
    }

    public static void main(String[] args) {
        System.out.println(mapOf(entry("a", 1), entry("b", 2), entry("c", 3)));
    }
}

ප්‍රතිදානය:

{a = 1, b = 2, c = 3}

වරකට සිතියමක් මූලද්‍රව්‍යයක් නිර්මාණය කිරීම හා ජනගහනය කිරීම වඩා පහසුය.

එකතු කිරීමේ API සඳහා JEP 269 පහසු කර්මාන්තශාලා ක්‍රම කිහිපයක් සපයයි. මෙම කර්මාන්තශාලා ක්‍රම වර්තමාන ජාවා අනුවාදයේ 8 වන අතර එය ජාවා 9 නිකුතුව සඳහා සැලසුම් කර ඇත.

සඳහා Mapකර්මාන්ත ක්රම දෙකක් තිබේ: ofහා ofEntries. භාවිතා කරමින් of, ඔබට ප්‍රත්‍යාවර්ත යතුරු / අගය යුගල ලබා දිය හැකිය. උදාහරණයක් ලෙස, ඒ හා Mapසමාන දෙයක් නිර්මාණය කිරීම සඳහා {age: 27, major: cs}:

Map<String, Object> info = Map.of("age", 27, "major", "cs");

දැනට අධික ලෙස පටවා ඇති අනුවාද දහයක් ඇත of, එබැවින් ඔබට යතුරු / අගය යුගල දහයක් අඩංගු සිතියමක් සෑදිය හැකිය. ඔබ මෙම සීමාව හෝ විකල්ප යතුර / අගයන් අකමැති නම්, ඔබට මෙය භාවිතා කළ හැකිය ofEntries:

Map<String, Object> info = Map.ofEntries(
                Map.entry("age", 27),
                Map.entry("major", "cs")
);

දෙකම ofසහ ofEntriesවෙනස් කළ නොහැකි දෙයක් නැවත ලබා දෙනු ඇත Map, එබැවින් ඉදිකිරීම් වලින් පසු ඔබට ඒවායේ මූලද්‍රව්‍ය වෙනස් කළ නොහැක. JDK 9 මුල් ප්‍රවේශය භාවිතයෙන් ඔබට මෙම විශේෂාංග අත්හදා බැලිය හැකිය .

හොඳයි ... මම enums වලට කැමතියි;)

enum MyEnum {
    ONE   (1, "one"),
    TWO   (2, "two"),
    THREE (3, "three");

    int value;
    String name;

    MyEnum(int value, String name) {
        this.value = value;
        this.name = name;
    }

    static final Map<Integer, String> MAP = Stream.of( values() )
            .collect( Collectors.toMap( e -> e.value, e -> e.name ) );
}

මම පිළිතුරු කියවා ඇති අතර මගේම සිතියම් සාදන්නෙකු ලිවීමට මම තීරණය කළෙමි. පිටපත් කිරීමට හා රස විඳීමට නිදහස් වන්න.

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * A tool for easy creation of a map. Code example:<br/>
 * {@code MapBuilder.of("name", "Forrest").and("surname", "Gump").build()}
 * @param <K> key type (inferred by constructor)
 * @param <V> value type (inferred by constructor)
 * @author Vlasec (for http://stackoverflow.com/a/30345279/1977151)
 */
public class MapBuilder <K, V> {
    private Map<K, V> map = new HashMap<>();

    /** Constructor that also enters the first entry. */
    private MapBuilder(K key, V value) {
        and(key, value);
    }

    /** Factory method that creates the builder and enters the first entry. */
    public static <A, B> MapBuilder<A, B> mapOf(A key, B value) {
        return new MapBuilder<>(key, value);
    }

    /** Puts the key-value pair to the map and returns itself for method chaining */
    public MapBuilder<K, V> and(K key, V value) {
        map.put(key, value);
        return this;
    }

    /**
     * If no reference to builder is kept and both the key and value types are immutable,
     * the resulting map is immutable.
     * @return contents of MapBuilder as an unmodifiable map.
     */
    public Map<K, V> build() {
        return Collections.unmodifiableMap(map);
    }
}

සංස්කරණය කරන්න: මෑතකදී, මම ofනිතර නිතර පොදු ස්ථිතික ක්‍රමවේදය සොයා ගන්නා අතර මම එයට කැමතියි. මම එය කේතයට එකතු කර ඉදිකිරීම්කරු පුද්ගලික කර, ස්ථිතික කර්මාන්තශාලා ක්‍රම රටාවට මාරු වෙමි.

EDIT2: වඩාත් මෑතකදී, ofස්ථිතික ආනයන භාවිතා කිරීමේදී එය නරක යැයි පෙනෙන බැවින් , මම තවදුරටත් ස්ථිතික ක්‍රමයට කැමැතියි . mapOfස්ථිතික ආනයන සඳහා එය වඩාත් සුදුසු කරමින් මම ඒ වෙනුවට නම් කළෙමි .