คุณจะเริ่มต้นคงที่Mapใน Java อย่างไร

วิธีที่หนึ่ง: แบบเริ่มต้นคงที่
วิธีที่สอง: ตัวเริ่มต้นอินสแตนซ์ (คลาสย่อยแบบไม่ระบุชื่อ) หรือวิธีอื่น ๆ ?

ข้อดีและข้อเสียของแต่ละข้อคืออะไร

นี่คือตัวอย่างที่แสดงวิธีการสองวิธี:

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);
    }
}

ฉันชอบวิธีGuavaในการเริ่มต้นแผนที่คงที่และไม่เปลี่ยนรูปแบบ:

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();

ต้องการเรียนรู้เพิ่มเติมเกี่ยวกับประโยชน์ของฝรั่งของสาธารณูปโภคคอลเลกชันที่ไม่เปลี่ยนรูปให้ดูคอลเลกชันไม่เปลี่ยนรูปอธิบายในฝรั่งคู่มือการใช้งาน

(ส่วนหนึ่งของ) ฝรั่งเคยถูกเรียกว่าGoogle คอลเลกชัน หากคุณยังไม่ได้ใช้ห้องสมุดนี้ในโครงการ Java ของคุณฉันขอแนะนำอย่างยิ่งให้ลอง! ฝรั่งได้อย่างรวดเร็วกลายเป็นหนึ่งในความนิยมมากที่สุดและมีประโยชน์ libs บุคคลที่ 3 ฟรีสำหรับ Java เป็นผู้ใช้ดังนั้นเพื่อนเห็นด้วย (ถ้าคุณยังใหม่กับมันมีแหล่งการเรียนรู้ที่ยอดเยี่ยมอยู่ด้านหลังลิงค์)

Update (2015) : สำหรับJava 8ยังไงฉันก็ยังคงใช้แนวทางของ Guava เพราะมันสะอาดกว่าวิธีอื่น หากคุณไม่ต้องการพึ่งพาฝรั่งพิจารณาวิธี init ธรรมดาเก่า แฮ็คที่มีอาเรย์สองมิติและ Stream APIนั้นค่อนข้างน่าเกลียดถ้าคุณถามฉันและได้รับอัปลักษณ์ถ้าคุณต้องการสร้างแผนที่ซึ่งมีรหัสและค่าที่ไม่เหมือนกัน (เหมือนMap<Integer, String>ในคำถาม)

สำหรับอนาคตของ Guava โดยทั่วไปสำหรับ Java 8 นั้น Louis Wasserman กล่าวว่าย้อนกลับไปในปี 2014 และ [ อัพเดต ] ในปี 2559 ได้มีการประกาศว่าGuava 21 จะต้องการและสนับสนุน Java 8อย่างเหมาะสม

Update (2016) : เป็นTagir Valeev ชี้ให้เห็น , Java 9ในที่สุดก็จะทำให้สะอาดนี้จะทำอย่างไรใช้อะไร แต่บริสุทธิ์ JDK โดยการเพิ่มวิธีการโรงงานสะดวกสบายสำหรับคอลเลกชัน:

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 คงที่ฉันจะตั้งชื่อให้เหมือนค่าคงที่

Java 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!

นี่คือตัวกำหนดค่าเริ่มต้นแผนที่แบบคงที่ Java 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]));

แก้ไข: เพื่อเริ่มต้น a 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): มีรุ่นที่ดีกว่าและหลากหลายประเภทโดย i_am_zero ที่ใช้สตรีมการnew SimpleEntry<>(k, v)โทร ลองดูคำตอบนั้น: https://stackoverflow.com/a/37384773/3950982

Map.of ใน Java 9+

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

ดูJEP 269สำหรับรายละเอียด JDK 9 มาถึงความพร้อมใช้งานทั่วไปในเดือนกันยายน 2017

Java 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รายการโดยใช้

Java 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));

ด้วยEclipse Collectionsสิ่งต่อไปนี้จะได้ผล:

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");
}

นอกจากนี้คุณยังสามารถเริ่มต้นแผนที่แบบดั้งเดิมด้วยการรวบรวม Eclipse

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");
} 

หมายเหตุ:ฉันเป็นคอมมิชชันสำหรับ Eclipse Collections

ฉันจะไม่สร้างคลาสย่อยที่ไม่ระบุชื่อในสถานการณ์นี้ static initializers ทำงานได้ดีเช่นกันหากคุณต้องการทำให้แผนที่ไม่สามารถแก้ไขได้เช่น:

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);
}

อาจเป็นเรื่องที่น่าสนใจในการดูGoogle Collectionsเช่นวิดีโอที่พวกเขามีในหน้าเว็บของพวกเขา พวกเขาให้วิธีการต่างๆในการเริ่มต้นแผนที่และชุดและให้คอลเลกชันที่ไม่เปลี่ยนรูปเช่นกัน

อัปเดต: ห้องสมุดนี้ชื่อGuavaแล้ว

ฉันชอบคลาสนิรนามเพราะง่ายต่อการจัดการ:

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");
        }
    });
}

และแนะนำให้ใช้ unmodifiableMap สำหรับค่าคงที่อื่น ๆ อย่างชาญฉลาดไม่สามารถถือว่าเป็นค่าคงที่

ฉันขอแนะนำสไตล์ "double brace initialization" มากกว่าสไตล์บล็อกแบบคงที่

บางคนอาจแสดงความคิดเห็นว่าพวกเขาไม่ชอบคลาสนิรนามค่าใช้จ่ายประสิทธิภาพ ฯลฯ

แต่ที่ฉันพิจารณาเพิ่มเติมคือการอ่านและบำรุงรักษาโค้ด ในมุมมองนี้ฉันยืนวงเล็บปีกกาสองครั้งเป็นรูปแบบรหัสที่ดีกว่าวิธีการคงที่

1. องค์ประกอบต่างๆซ้อนกันและอินไลน์
2. มันเป็น OO มากขึ้นไม่ใช่ขั้นตอน
3. ผลกระทบต่อประสิทธิภาพมีขนาดเล็กมากและอาจถูกเพิกเฉย
4. การสนับสนุนโครงร่าง IDE ที่ดีขึ้น (แทนที่จะเป็นบล็อก {} แบบไม่ระบุชื่อจำนวนมาก)
5. คุณบันทึกความคิดเห็นไม่กี่บรรทัดเพื่อให้พวกเขามีความสัมพันธ์
6. ป้องกันการรั่วไหลขององค์ประกอบที่เป็นไปได้ / อินสแตนซ์ของวัตถุที่ไม่ได้กำหนดค่าเริ่มต้นจากข้อยกเว้นและเครื่องมือเพิ่มประสิทธิภาพ bytecode
7. ไม่ต้องกังวลกับการสั่งการบล็อกคงที่

นอกจากนี้ยังทราบถึง GC ของชนชั้นที่ไม่ระบุชื่อคุณสามารถแปลงเป็น HashMap new HashMap(Map map)ปกติโดยใช้

คุณสามารถทำได้จนกว่าคุณจะประสบปัญหาอื่น หากคุณทำคุณควรใช้รูปแบบการเข้ารหัสอื่น (เช่นไม่มีสแตติกคลาสจากโรงงาน)

ตามปกติ apache-Commons มีวิธีการที่เหมาะสมMapUtils.putAll (แผนที่, วัตถุ []) :

ตัวอย่างเช่นในการสร้างแผนที่สี:

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

นี่คือสิ่งที่ฉันโปรดปรานเมื่อฉันไม่ต้องการ (หรือไม่สามารถ) ใช้ Guava 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));

หากคุณต้องการแผนที่ที่แก้ไขไม่ได้ในที่สุด java 9 ก็เพิ่มวิธีofการMapเชื่อมต่อที่ยอดเยี่ยมให้กับโรงงาน มีการเพิ่มวิธีที่คล้ายกันในการตั้งค่ารายการเช่นกัน

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

ฉันชอบการใช้ initializer แบบสแตติกเพื่อหลีกเลี่ยงการสร้างคลาสนิรนาม (ซึ่งจะไม่มีวัตถุประสงค์เพิ่มเติม) ดังนั้นฉันจะแสดงรายการเคล็ดลับการเริ่มต้นด้วย initializer แบบคงที่ โซลูชัน / เคล็ดลับที่ปรากฏในรายการทั้งหมดเป็นประเภทที่ปลอดภัย

หมายเหตุ:คำถามไม่ได้พูดอะไรเกี่ยวกับการทำให้แผนที่ไม่สามารถแก้ไขได้ดังนั้นฉันจะออกไป แต่รู้ว่ามันสามารถทำได้Collections.unmodifiableMap(map)ง่าย

เคล็ดลับแรก

เคล็ดลับแรกคือคุณสามารถอ้างอิงท้องถิ่นไปยังแผนที่และให้ชื่อสั้น ๆ :

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");
}

เคล็ดลับที่สอง

เคล็ดลับที่ 2 คือคุณสามารถสร้างวิธีการช่วยเหลือเพื่อเพิ่มรายการ; คุณสามารถทำให้วิธีการช่วยเหลือนี้เป็นแบบสาธารณะได้หากคุณต้องการ:

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);
        }
    }
}

ด้วย Java 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")
);

วิธีการที่สองของคุณ(การกำหนดค่าเริ่มต้นของ Double Brace)นั้นเป็นรูปแบบการต่อต้านดังนั้นฉันจะไปหาวิธีแรก

อีกวิธีที่ง่ายในการเริ่มต้นแผนที่แบบคงที่คือการใช้ฟังก์ชั่นยูทิลิตี้นี้:

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

ฉันไม่ชอบไวยากรณ์เริ่มต้นแบบคงที่และฉันไม่เชื่อว่าจะเป็นคลาสย่อยที่ไม่ระบุชื่อ โดยทั่วไปฉันเห็นด้วยกับข้อเสียทั้งหมดของการใช้ initializers คงที่และข้อเสียทั้งหมดในการใช้คลาสย่อยที่ไม่ระบุชื่อที่กล่าวถึงในคำตอบ previus ในทางกลับกันข้อดีที่นำเสนอในโพสต์เหล่านี้ไม่เพียงพอสำหรับฉัน ฉันชอบที่จะใช้วิธีการเริ่มต้นคงที่:

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;
    }
}

ฉันไม่เห็นวิธีการที่ฉันใช้ (และเพิ่มขึ้นเช่น) โพสต์ในคำตอบใด ๆ ดังนั้นนี่คือ:

ฉันไม่ชอบการใช้ initializers คงที่เพราะพวกมัน clunky และฉันไม่ชอบคลาสที่ไม่ระบุชื่อเพราะมันกำลังสร้างคลาสใหม่สำหรับแต่ละอินสแตนซ์

ฉันต้องการเริ่มต้นแทนที่มีลักษณะดังนี้:

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

น่าเสียดายที่วิธีการเหล่านี้ไม่ได้เป็นส่วนหนึ่งของไลบรารีมาตรฐานของ Java ดังนั้นคุณจะต้องสร้าง (หรือใช้) ไลบรารียูทิลิตี้ที่กำหนดวิธีการดังต่อไปนี้:

 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)

(คุณสามารถใช้ 'นำเข้าคงที่' เพื่อหลีกเลี่ยงการต้องนำหน้าชื่อของวิธีการ)

ฉันพบว่ามีประโยชน์ที่จะให้วิธีการคงที่คล้ายกันสำหรับคอลเลกชันอื่น ๆ (รายการ, ชุด, SortSet, SortMap, ฯลฯ )

มันไม่ดีเท่าการเริ่มต้นวัตถุ json แต่มันเป็นขั้นตอนในทิศทางนั้นเท่าที่เกี่ยวข้องกับการอ่าน

เนื่องจาก Java ไม่รองรับตัวอักษรแผนที่แมปอินสแตนซ์แผนที่จะต้องมีการสร้างอินสแตนซ์และบรรจุอย่างชัดเจนเสมอ

โชคดีที่มันเป็นไปได้ที่จะใกล้เคียงกับพฤติกรรมของตัวอักษรของแผนที่ในจาวาโดยใช้วิธีการโรงงาน

ตัวอย่างเช่น:

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}

สะดวกกว่าการสร้างและเติมองค์ประกอบของแผนที่ในแต่ละครั้ง

JEP 269มีวิธีการอำนวยความสะดวกบางอย่างสำหรับโรงงาน Collections API เมธอดจากโรงงานนี้ไม่ได้อยู่ในเวอร์ชัน Java ปัจจุบันซึ่งคือ 8 แต่ถูกวางแผนสำหรับการปล่อย Java 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แทนทำให้เหมาะสำหรับการนำเข้าแบบคงที่