Làm thế nào bạn sẽ khởi tạo một tĩnh Maptrong Java?

Phương thức một: trình khởi tạo tĩnh
Phương thức hai: trình khởi tạo cá thể (lớp con ẩn danh) hoặc một số phương thức khác?

Những ưu và nhược điểm của mỗi là gì?

Dưới đây là một ví dụ minh họa hai phương pháp:

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

Trình khởi tạo cá thể chỉ là đường cú pháp trong trường hợp này, phải không? Tôi không thấy lý do tại sao bạn cần một lớp ẩn danh bổ sung chỉ để khởi tạo. Và nó sẽ không hoạt động nếu lớp được tạo là cuối cùng.

Bạn cũng có thể tạo bản đồ bất biến bằng cách sử dụng trình khởi tạo tĩnh:

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

Tôi thích cách ổi khởi tạo một bản đồ tĩnh, bất biến:

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

Như bạn có thể thấy, nó rất súc tích (vì các phương pháp nhà máy thuận tiện trong ImmutableMap).

Nếu bạn muốn bản đồ có nhiều hơn 5 mục, bạn không thể sử dụng nữa ImmutableMap.of(). Thay vào đó, hãy thử ImmutableMap.builder()dọc theo những dòng này:

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

Để tìm hiểu thêm về lợi ích của các tiện ích bộ sưu tập bất biến của Guava, hãy xem Bộ sưu tập không thay đổi được giải thích trong Hướng dẫn sử dụng ổi .

(Một tập hợp con) Quả ổi từng được gọi là Bộ sưu tập của Google . Nếu bạn không sử dụng thư viện này trong dự án Java của bạn nêu ra, tôi mạnh mẽ khuyên cố gắng nó ra! Quả ổi đã nhanh chóng trở thành một trong những libs bên thứ 3 miễn phí phổ biến và hữu ích nhất cho Java, khi những người dùng SO đồng ý . (Nếu bạn chưa quen với nó, có một số tài nguyên học tập tuyệt vời đằng sau liên kết đó.)

Cập nhật (2015) : Đối với Java 8 , tốt, tôi vẫn sẽ sử dụng cách tiếp cận Guava vì nó sạch hơn bất kỳ thứ gì khác. Nếu bạn không muốn phụ thuộc vào ổi, hãy xem xét một phương pháp init cũ đơn giản . Việc hack với mảng hai chiều và API Stream khá xấu nếu bạn hỏi tôi và trở nên xấu hơn nếu bạn cần tạo một Bản đồ có các khóa và giá trị không cùng loại (như Map<Integer, String>trong câu hỏi).

Về tương lai của Guava nói chung, liên quan đến Java 8, Louis Wasserman cho biết điều này trở lại vào năm 2014 và [ cập nhật ] vào năm 2016 đã thông báo rằng Guava 21 sẽ yêu cầu và hỗ trợ đúng cách cho Java 8 .

Cập nhật (2016) : Như Tagir Valeev đã chỉ ra , Java 9 cuối cùng sẽ làm cho điều này trở nên rõ ràng để không sử dụng gì ngoài JDK thuần túy, bằng cách thêm các phương thức nhà máy tiện lợi cho các bộ sưu tập:

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

Tôi sẽ dùng:

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. nó tránh một lớp ẩn danh, mà cá nhân tôi coi là một phong cách xấu, và tránh
2. nó làm cho việc tạo bản đồ rõ ràng hơn
3. nó làm cho bản đồ không thể thay đổi
4. vì MY_MAP là hằng số, tôi sẽ đặt tên nó là hằng số

Java 5 cung cấp cú pháp nhỏ gọn hơn này:

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

Một lợi thế của phương pháp thứ hai là bạn có thể gói nó Collections.unmodifiableMap()để đảm bảo rằng không có gì sẽ cập nhật bộ sưu tập sau:

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!

Đây là trình khởi tạo bản đồ tĩnh một dòng 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]));

Chỉnh sửa: để khởi tạo Map<Integer, String>như trong câu hỏi, bạn cần một cái gì đó như thế này:

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

Chỉnh sửa (2): Có một phiên bản tốt hơn, có khả năng hỗn hợp của i_am_zero sử dụng luồng new SimpleEntry<>(k, v)cuộc gọi. Kiểm tra câu trả lời đó: https://stackoverflow.com/a/37384773/3950982

Map.of trong Java 9+

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

Xem JEP 269 để biết chi tiết. JDK 9 đạt mức khả dụng chung vào tháng 9 năm 2017.

Java 9

Chúng tôi có thể sử dụng Map.ofEntries, gọi Map.entry( k , v )để tạo từng mục.

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

Chúng tôi cũng có thể sử dụng Map.oftheo đề xuất của Tagir trong câu trả lời của mình tại đây nhưng chúng tôi không thể có hơn 10 mục sử dụngMap.of .

Java 8 (Giải pháp gọn gàng)

Chúng tôi có thể tạo một luồng các mục bản đồ. Chúng tôi đã có hai triển khai Entrytrong java.util.AbstractMapđó là SimpleEntry và SimpleImmutableEntry . Trong ví dụ này, chúng ta có thể sử dụng trước đây như:

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

Với Bộ sưu tập Eclipse , tất cả những điều sau đây sẽ hoạt động:

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

Bạn cũng có thể khởi tạo tĩnh các bản đồ nguyên thủy với Bộ sưu tập 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");
} 

Lưu ý: Tôi là người đi làm cho Bộ sưu tập Eclipse

Tôi sẽ không bao giờ tạo một lớp con ẩn danh trong tình huống này. Công cụ khởi tạo tĩnh hoạt động tốt như nhau, nếu bạn muốn làm cho bản đồ không thể thay đổi được, ví dụ:

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

Có lẽ thật thú vị khi xem Bộ sưu tập của Google , ví dụ: video mà họ có trên trang của họ. Họ cung cấp nhiều cách khác nhau để khởi tạo bản đồ và bộ, đồng thời cung cấp các bộ sưu tập bất biến.

Cập nhật: Thư viện này hiện có tên là Guava .

Tôi thích lớp ẩn danh, vì nó dễ đối phó với nó:

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

Nếu chúng ta khai báo nhiều hơn một hằng số thì mã đó sẽ được viết trong khối tĩnh và điều đó khó duy trì trong tương lai. Vì vậy, tốt hơn là sử dụng lớp ẩn danh.

public class Test {

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

Và nó được đề xuất sử dụng unmodifiableMap cho các hằng số khác, nó không thể được coi là hằng số.

Tôi mạnh mẽ có thể đề xuất kiểu "khởi tạo cú đúp" so với kiểu khối tĩnh.

Ai đó có thể nhận xét rằng họ không thích lớp ẩn danh, chi phí chung, hiệu suất, v.v.

Nhưng điều mà tôi xem xét nhiều hơn là khả năng đọc và bảo trì mã. Theo quan điểm này, tôi đứng một cú đúp là một kiểu mã tốt hơn là phương thức tĩnh.

1. Các yếu tố được lồng và nội tuyến.
2. Nó là OO nhiều hơn, không phải là thủ tục.
3. tác động hiệu suất là rất nhỏ và có thể bị bỏ qua.
4. Hỗ trợ phác thảo IDE tốt hơn (thay vào đó là nhiều khối {} tĩnh ẩn danh)
5. Bạn đã lưu vài dòng bình luận để mang lại cho họ mối quan hệ.
6. Ngăn chặn rò rỉ phần tử / phần tử dẫn của đối tượng chưa được khởi tạo từ ngoại lệ và trình tối ưu hóa mã byte.
7. Không phải lo lắng về thứ tự thực hiện của khối tĩnh.

Ngoài ra, bạn biết được GC của lớp ẩn danh, bạn luôn có thể chuyển đổi nó thành HashMap bình thường bằng cách sử dụng new HashMap(Map map).

Bạn có thể làm điều này cho đến khi bạn phải đối mặt với một vấn đề khác. Nếu bạn làm như vậy, bạn nên sử dụng hoàn thành một kiểu mã hóa khác (ví dụ: không có lớp tĩnh, lớp nhà máy) cho nó.

Như apache-commons thông thường có phương thức thích hợp MapUtils.put ALL (Map, Object []) :

Ví dụ: để tạo bản đồ màu:

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

Đây là sở thích của tôi khi tôi không muốn (hoặc không thể) sử dụng Guava ImmutableMap.of()hoặc nếu tôi cần một người có thể thay đổi 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]);
        }
    }};
}

Nó rất nhỏ gọn và nó bỏ qua các giá trị đi lạc (tức là khóa cuối cùng không có giá trị).

Sử dụng:

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

Nếu bạn muốn bản đồ không thể thay đổi, cuối cùng java 9 đã thêm một phương thức xuất xưởng thú vị ofvào Mapgiao diện. Phương pháp tương tự được thêm vào Set, List.

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

Tôi thích sử dụng trình khởi tạo tĩnh để tránh tạo các lớp ẩn danh (sẽ không có mục đích nào nữa), vì vậy tôi sẽ liệt kê các mẹo khởi tạo với trình khởi tạo tĩnh. Tất cả các giải pháp / lời khuyên được liệt kê là loại an toàn.

Lưu ý: Câu hỏi không nói bất cứ điều gì về việc làm cho bản đồ không thể thay đổi, vì vậy tôi sẽ bỏ qua nó, nhưng biết rằng nó có thể dễ dàng thực hiện được Collections.unmodifiableMap(map).

Mẹo đầu tiên

Mẹo đầu tiên là bạn có thể tạo một tham chiếu cục bộ cho bản đồ và bạn đặt cho nó một tên NGẮN:

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

Mẹo thứ hai

Mẹo thứ 2 là bạn có thể tạo một phương thức trợ giúp để thêm các mục; bạn cũng có thể công khai phương thức trợ giúp này nếu bạn muốn:

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

Phương thức trợ giúp ở đây không thể sử dụng lại được vì nó chỉ có thể thêm các phần tử vào myMap2. Để làm cho nó có thể sử dụng lại, chúng ta có thể biến bản đồ thành một tham số của phương thức trợ giúp, nhưng sau đó mã khởi tạo sẽ không ngắn hơn nữa.

Mẹo thứ ba

Mẹo thứ 3 là bạn có thể tạo một lớp trình trợ giúp giống như trình xây dựng có thể sử dụng lại với chức năng điền. Đây thực sự là một lớp trợ giúp 10 dòng đơn giản, an toàn cho loại:

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

Lớp ẩn danh bạn đang tạo hoạt động tốt. Tuy nhiên, bạn nên biết rằng đây là một lớp bên trong và do đó, nó sẽ chứa một tham chiếu đến thể hiện của lớp xung quanh. Vì vậy, bạn sẽ thấy bạn không thể làm một số điều nhất định với nó (sử dụng XStream cho một cái). Bạn sẽ nhận được một số lỗi rất lạ.

Phải nói rằng, miễn là bạn biết thì cách tiếp cận này là tốt. Tôi sử dụng nó hầu hết thời gian để khởi tạo tất cả các loại bộ sưu tập một cách súc tích.

EDIT: Đã chỉ ra một cách chính xác trong các ý kiến ​​rằng đây là một lớp tĩnh. Rõ ràng là tôi đã không đọc nó đủ chặt chẽ. Tuy nhiên ý kiến của tôi làm vẫn áp dụng đối với các lớp bên trong vô danh.

Nếu bạn muốn một cái gì đó ngắn gọn và tương đối an toàn, bạn có thể chuyển dịch kiểm tra kiểu biên dịch sang thời gian chạy:

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

Việc thực hiện này sẽ bắt được bất kỳ lỗi nào:

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

Với Java 8 tôi đã sử dụng mẫu sau:

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

Nó không phải là đường vòng ngắn nhất và ngắn nhất, nhưng

• nó không yêu cầu bất cứ điều gì bên ngoài java.util
• nó an toàn và dễ dàng cung cấp các loại khác nhau cho khóa và giá trị.

Nếu bạn chỉ cần thêm một giá trị vào bản đồ, bạn có thể sử dụng Collections.singletonMap :

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

Bạn có thể sử dụng StickyMapvà MapEntrytừ Cactoos :

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

Cách tiếp cận thứ hai của bạn (khởi tạo Double Brace) được cho là kiểu chống , vì vậy tôi sẽ chọn cách tiếp cận đầu tiên.

Một cách dễ dàng khác để khởi tạo Bản đồ tĩnh là sử dụng chức năng tiện ích này:

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

Lưu ý: trong Java 9bạn có thể sử dụng Map.of

Tôi không thích cú pháp khởi tạo tĩnh và tôi không bị thuyết phục với các lớp con ẩn danh. Nói chung, tôi đồng ý với tất cả các khuyết điểm của việc sử dụng Trình khởi tạo tĩnh và tất cả các khuyết điểm của việc sử dụng các lớp con ẩn danh đã được đề cập trong các câu trả lời trước. Mặt khác - ưu điểm được trình bày trong các bài viết này là không đủ cho tôi. Tôi thích sử dụng phương thức khởi tạo tĩnh:

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

Tôi chưa thấy cách tiếp cận tôi sử dụng (và đã trở nên thích) được đăng trong bất kỳ câu trả lời nào, vì vậy đây là:

Tôi không thích sử dụng các trình khởi tạo tĩnh bởi vì chúng rất cồng kềnh và tôi không thích các lớp ẩn danh vì nó đang tạo một lớp mới cho mỗi trường hợp.

thay vào đó, tôi thích khởi tạo giống như thế này:

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

thật không may, các phương thức này không phải là một phần của thư viện Java tiêu chuẩn, vì vậy bạn sẽ cần tạo (hoặc sử dụng) một thư viện tiện ích xác định các phương thức sau:

 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)

(bạn có thể sử dụng 'nhập tĩnh' để tránh cần phải thêm tiền tố vào tên của phương thức)

Tôi thấy hữu ích khi cung cấp các phương thức tĩnh tương tự cho các bộ sưu tập khác (list, set, sortset, sortMap, v.v.)

Nó không hoàn toàn đẹp như khởi tạo đối tượng json, nhưng đó là một bước theo hướng đó, khi có liên quan đến khả năng đọc.

Bởi vì Java không hỗ trợ bằng chữ theo bản đồ, các thể hiện bản đồ phải luôn được khởi tạo và điền rõ ràng.

May mắn thay, có thể tính gần đúng hành vi của các chữ bản đồ trong Java bằng các phương thức xuất xưởng .

Ví dụ:

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

Đầu ra:

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

Nó thuận tiện hơn rất nhiều so với việc tạo và điền vào bản đồ một yếu tố tại một thời điểm.

JEP 269 cung cấp một số phương thức nhà máy tiện lợi cho Bộ sưu tập API. Các phương thức xuất xưởng này không có trong phiên bản Java hiện tại, là 8, nhưng được lên kế hoạch phát hành Java 9.

Vì Mapcó hai phương pháp nhà máy: ofvà ofEntries. Sử dụng of, bạn có thể chuyển các cặp khóa / giá trị xen kẽ. Ví dụ: để tạo một lượt Mapthích {age: 27, major: cs}:

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

Hiện tại có mười phiên bản quá tải cho of, vì vậy bạn có thể tạo bản đồ chứa mười cặp khóa / giá trị. Nếu bạn không thích giới hạn này hoặc khóa / giá trị xen kẽ, bạn có thể sử dụng ofEntries:

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

Cả hai ofvà ofEntriessẽ trả lại một bất biến Map, vì vậy bạn không thể thay đổi các yếu tố của chúng sau khi xây dựng. Bạn có thể thử các tính năng này bằng cách sử dụng JDK 9 Early Access .

Chà ... tôi thích enum;)

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

Tôi đã đọc câu trả lời và tôi quyết định viết công cụ xây dựng bản đồ của riêng mình. Hãy sao chép-dán và thưởng thức.

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

EDIT: Gần đây, tôi tiếp tục tìm phương pháp tĩnh công khai of khá thường xuyên và tôi khá thích nó. Tôi đã thêm nó vào mã và làm cho hàm tạo riêng tư, do đó chuyển sang mẫu phương thức tĩnh của nhà máy.

EDIT2: Thậm chí gần đây, tôi không còn thích phương thức tĩnh được gọi nữa of, vì nó trông khá tệ khi sử dụng nhập tĩnh. Tôi đã đổi tên nó thành mapOfthay thế, làm cho nó phù hợp hơn cho nhập khẩu tĩnh.