Kaip inicijuoti statinį žemėlapį?

Kaip inicijuotumėte statinį Map „Java“?

Pirmasis būdas: statinis iniciatorius
Antrasis būdas: instancijos iniciatorius (anoniminis poklasis) arba kitas metodas?

Kokie yra kiekvieno privalumai ir trūkumai?

Štai pavyzdys, iliustruojantis du metodus:

 import java.util.HashMap; import java.util.Map; public class Test { private static final Map<Integer, String> myMap = new HashMap<Integer, String>(); static { myMap.put(1, "one"); myMap.put(2, "two"); } private static final Map<Integer, String> myMap2 = new HashMap<Integer, String>(){ { put(1, "one"); put(2, "two"); } }; } 
989
03 февр. nustatyti dogbane 03 vasaris 2009-02-03 18:41 '09 18:41 2009-02-03 18:41
ответ 41 atsakymas
  • 1
  • 2

Tokiu atveju egzemplioriaus iniciatorius yra tik sintaksinis cukrus, tiesa? Nesuprantu, kodėl iniciacijai reikalinga papildoma anoniminė klasė. Ir tai neveiks, jei sukurta klasė bus galutinė.

Taip pat galite sukurti nekintamą žemėlapį, naudodami statinį iniciatorių:

 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); } } 
990
03 февр. atsakymą pateikė „ Miserable Variable“ 03 vasaris. 2009-02-03 18:51 '09 at 18:51 2009-02-03 18:51

Man patinka Guava būdas inicijuoti statinį, nekintamą žemėlapį:

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

Kaip matote, tai labai pasakoja (dėl patogių „ ImmutableMap gamyklos metodų).

Jei norite, kad žemėlapyje būtų daugiau nei 5 įrašai, nebegali naudoti „ ImmutableMap.of() . Vietoj to, pabandykite „ ImmutableMap.builder() naudoti šiose eilutėse:

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

Jei norite sužinoti daugiau apie universalaus Gvajavos kolekcijos privalumus, žr. „ Kintamieji“, paaiškinti „Guava“ vartotojo vadove .

(Subset) Guava anksčiau buvo vadinama „Google“ kolekcijomis. Jei dar nesinaudojate šia biblioteka „Java“ projekte, primygtinai rekomenduoju jį išbandyti! „Guava“ greitai tapo viena iš populiariausių ir naudingiausių nemokamų trečiųjų šalių bibliotekų „Java“, nes SO SO vartotojai sutinka . (Jei esate tai naujas, yra puikių mokymosi išteklių už šios nuorodos.)

border=0

Atnaujinimas (2015 m.) . Kalbant apie „ Java 8“ , vis dar naudoju Gvajavos požiūrį, nes jis yra daug švaresnis nei bet kas kitas. Jei jums nereikia priklausomybės nuo Gvajavos, apsvarstykite paprastą senąjį „init“ metodą . Įsilaužimas naudojant dvimatį masyvą ir „Stream“ API yra gana bjaurus, jei manęs klausiate ir gausite, jei reikia sukurti žemėlapį, kurio raktai ir reikšmės neatitinka tipo (pvz., Map<Integer, String> ).

Kalbant apie visą Gvajaus ateitį, kalbant apie „Java 8“, Louis Wasserman tai sakė 2014 m., O 2016 m. [Atnaujinti] buvo paskelbta, kad „ Guava 21“ reikės ir teisingai palaikys „Java 8“ .


Atnaujinimas (2016) : kaip nurodo Tagir Valeev , „ Java 9 “ pagaliau padarys jį švarų, naudojant tik „JDK“, pridėdama patogius gamyklinius metodus kolekcijoms:

 static final Map<Integer, String> MY_MAP = Map.of( 1, "one", 2, "two" ); 
392
31 авг. Atsakymas duotas Jonikui 31 d. 2011-08-31 16:58 '11, 16:58, 2011-08-31 16:58

Norėčiau naudoti:

 public class Test { private static final Map<Integer, String> MY_MAP = createMap(); private static Map<Integer, String> createMap() { Map<Integer, String> result = new HashMap<Integer, String>(); result.put(1, "one"); result.put(2, "two"); return Collections.unmodifiableMap(result); } } 
  • jis vengia anoniminės klasės, kurią aš asmeniškai vertinu blogai, ir vengiu
  • tai daro žemėlapio kūrimą ryškesnę
  • daro žemėlapį nepakeičiamą
  • kadangi MY_MAP yra pastovus, aš jį vadinčiau pastoviu
168
04 февр. Atsakymą pateikė Peter Štibraný 04 vasaris. 2009-02-04 00:40 '09 ne 0:40 2009-02-04 00:40

„Java 5“ pateikia šią kompaktiškesnę sintaksę:

 static final Map<String , String> FLAVORS = new HashMap<String , String>() {{ put("Up", "Down"); put("Charm", "Strange"); put("Top", "Bottom"); }}; 
163
16 июля '09 в 0:29 2009-07-16 00:29 Atsakymą davė Chris Noe liepos 16 d., 09:29, 2009-07-16 00:29

Vienas iš antrojo metodo privalumų yra tas, kad galite jį įvesti Collections.unmodifiableMap() kad įsitikintumėte, jog viskas vėliau nebus atnaujinta:

 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! 
88
03 февр. Atsakymą pateikė Outlaw programuotojas 03 vasaris. 2009-02-03 18:44 '09 18:44 2009-02-03 18:44

Čia yra statinis „Java 8“ žemėlapio iniciatorius:

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

Pakeisti: jei norite inicijuoti Map<Integer, String> kaip Map<Integer, String> , jums reikia kažko panašaus:

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

Redagavimas (2): „i_am_zero“ yra geresnė versija su mišraus tipo pagalba, kuri naudoja srautą „ new SimpleEntry<>(k, v) . Patikrinkite šį atsakymą: ngn-wiki.ru.site/questions/11520 / ...

59
14 сент. Luke Hutchison atsakymas, rugsėjo 14 d 2014-09-14 03:44 '14, 3:44 2014-09-14 03:44

„Java 9“:

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

Išsamesnės informacijos ieškokite JEP 269 . JDK 9 buvo parduotas 2017 m. Rugsėjo mėn.

46
29 дек. Atsakymas pateikiamas Tagir Valeev 29 d. 2015-12-29 13:07 '16 at 13:07 2015-12-29 13:07

Su Eclipse kolekcija (anksčiau GS kolekcija ), visi jie veiks:

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

Taip pat galite statiškai inicijuoti primityvius žemėlapius su „Eclipse“ kolekcijomis.

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

Pastaba: esu „Eclipse“ kolekcijų pasiuntinys

29
19 дек. Donaldas Raabas atsakė gruodžio 19 d. 2012-12-19 02:10 '12, 2:10 2012-12-19 02:10

Aš niekada nesukurčiau anoniminio poklasio šioje situacijoje. Statiniai iniciatoriai veikia taip pat gerai, jei norite, kad žemėlapis būtų nepakeistas, pavyzdžiui:

 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); } 
26
03 февр. atsakymas pateikiamas eljenso 03 vasario mėn. 2009-02-03 18:55 '09 at 18:55 2009-02-03 18:55

„Java 9“

Mes galime naudoti Map.ofEntries kaip:

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

Taip pat galime naudoti „ Map.of kaip siūlė Tagir mūsų atsakyme , tačiau negalime turėti daugiau kaip 10 įrašų naudojant Map.of

„Java 8“ (tvarkingas sprendimas)

Žemėlapyje galime sukurti įrašų srautą. Mes jau turime du „ Entry diegimus „ java.util.AbstractMap kurie yra „ SimpleEntry“ ir „ SimpleImmutableEntry“ . Šiuo pavyzdžiu galime naudoti pirmąjį:

 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)); 
25
23 мая '16 в 10:17 2016-05-23 10:17 atsakymas pateikiamas i_am_zero gegužės 23, 16 d. 10:17 2016-05-23 10:17

Man patinka anoniminė klasė, nes ją lengva tvarkyti:

 public static final Map<?, ?> numbers = Collections.unmodifiableMap(new HashMap<Integer, String>() { { put(1, "some value"); //rest of code here } }); 
16
19 сент. Atsakymas duotas Shushant 19 Sep. 2013-09-19 11:48 '13, 11:48, 2013-09-19 11:48

Pavyzdžiui, gali būti įdomu pamatyti „ Google“ kolekcijas . vaizdo įrašą, kurį jie turi savo puslapyje. Jie suteikia įvairius būdus, kaip inicijuoti žemėlapius ir rinkinius, taip pat pateikti nekintamas kolekcijas.

Atnaujinimas: ši biblioteka dabar vadinama Gvajavu .

16
04 февр. atsakymas pateikiamas Kaarel 04 vasaris. 2009-02-04 00:33 '09 ne 0:33 2009-02-04 00:33
 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); } } 

Jei deklaruojame daugiau nei vieną konstantą, tai šis kodas bus parašytas statiniame bloke, ir ateityje jį bus sunku išlaikyti. Todėl geriau naudoti anoniminę klasę.

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

Ir siūloma naudoti unmodifiableMap konstantoms, kitaip ji negali būti laikoma nuolatine.

11
03 июня '10 в 11:18 2010-06-03 11:18 Atsakymą pateikė Leninkumar Koppoju birželio 10 d. 11 val. 11:18 2010-06-03 11:18

Galėčiau primygtinai pasiūlyti „dvigubo figūrų derinimo“ stilių statinio bloko stiliuje.

Kai kurie gali komentuoti, kad jiems nepatinka anoniminė klasė, pridėtinės vertės, našumas ir pan.

Tačiau aš manau, kad kodų nuskaitymas ir priežiūra yra daugiau. Šiuo požiūriu turiu dvigubą petį, tai yra kodo stilius, o ne statinis metodas.

  • Elementai yra įterpti ir inline.
  • Tai daugiau OO, o ne procedūrinė.
  • našumas yra labai mažas ir gali būti ignoruojamas.
  • Geresnis IDE kontūro palaikymas (o ne daug anoniminių statinių {} blokų)
  • Išsaugojote kelis komentarų eilutes, kad galėtumėte sujungti juos.
  • Neišardyto objekto elemento / elemento nutekėjimo prevencija iš išimties ir bytecode optimizavimo.
  • Nesijaudinkite dėl statinio bloko vykdymo tvarkos.

Be to, žinote anoniminės klasės GC, visada galite konvertuoti jį į įprastą HashMap, naudodami new HashMap(Map map) .

Tai galite padaryti, kol susidursite su kita problema. Jei tai padarysite, turite naudoti kitą kodavimo stilių (pvz., Nestatinė gamyklos klasė).

10
12 дек. Atsakymas duotas Dennis C 12 Dec. 2010-12-12 07:29 '10, 7:29, 2010-12-12 07:29

Kaip įprasta, „Apache-commons“ turi tinkamą MapUtils.putAll metodą (žemėlapis, objektas []) :

Pavyzdžiui, jei norite sukurti spalvų žemėlapį:

 Map<String, String> colorMap = MapUtils.putAll(new HashMap<String, String>(), new String[][] { {"RED", "#FF0000"}, {"GREEN", "#00FF00"}, {"BLUE", "#0000FF"} }); 
8
08 сент. atsakymas pateiktas agad 08 Sep. 2015-09-08 12:32 '15 - 12:32 2015-09-08 12:32

Jei norite, kad žemėlapis nebūtų modifikuotas, pagal klasę „Java“ pridedama klasės gamykla 9. Panašus metodas pridedamas prie „Nustatyti, sąrašas“.

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

6
26 нояб. Atsakymas duotas Bharanidharan K 26 lapkričio. 2017-11-26 06:38 '17, 6:38, 2017-11-26 06:38

Čia yra mano mėgstamiausia, kai nenoriu (arba negaliu) naudoti „Guava ImmutableMap.of() arba jei man reikia keisti 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]); } }}; } 

Jis yra labai kompaktiškas ir ignoruoja klaidingas vertes (t.y. galutinį raktą be vertės).

Naudoti:

 Map<String, String> one = asMap("1stKey", "1stVal", "2ndKey", "2ndVal"); Map<String, Object> two = asMap("1stKey", Boolean.TRUE, "2ndKey", new Integer(2)); 
6
15 сент. atsakymas pateikiamas neu242 15 sep . 2016-09-15 15:09 '16 at 15:09 2016-09-15 15:09

Jūsų sukurta anoniminė klasė veikia gerai. Tačiau turėtumėte žinoti, kad tai yra vidinė klasė, todėl jame bus nuoroda į aplinkinės klasės egzempliorių. Tokiu būdu jūs pamatysite, kad negalite su juo atlikti tam tikrų dalykų (naudodami XStream vienam). Jūs gausite labai keistų klaidų.

Tai pasakius, tiek, kiek žinote, toks požiūris yra geras. Daugiausia laiko naudojasi trumpam visų rūšių kolekcijų inicijavimui.

EDIT: komentaruose teisingai pažymėta, kad tai yra statinė klasė. Akivaizdu, kad aš to nepakankamai atidžiai perskaitiau. Tačiau mano komentarai vis dar taikomi anoniminėms vidinėms klasėms.

5
03 февр. Atsakymą pateikė Brian Agnew 03 vasaris. 2009-02-03 19:31 '09 19:31 2009-02-03 19:31

Norėčiau naudoti statinį iniciatorių, kad būtų išvengta anoniminių klasių (kurios neturėtų jokio kito tikslo), todėl kalbėsiu apie patarimus, inicijuotus statinio iniciatoriaus. Visi išvardyti sprendimai / patarimai yra saugūs pagal tipą.

Pastaba: Klausimas nepateikia nieko, kad žemėlapis būtų nepakeistas, todėl paliksiu jį, bet žinau, kad jį galima lengvai padaryti naudojant Collections.unmodifiableMap(map) .

Pirmasis patarimas

Pirmasis patarimas: galite sukurti vietinę nuorodą į žemėlapį, o jums bus suteiktas trumpas pavadinimas:

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

Antrasis patarimas

Antrasis patarimas: galite sukurti pagalbininko metodą įrašams pridėti; Taip pat galite padaryti šį pagalbininko metodą viešą, jei norite:

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

„Helper“ metodas čia dar kartą nenaudojamas, nes jis gali tik pridėti elementų į „ myMap2 . Norint, kad jis būtų pakartotinai naudojamas, galėtume padaryti žemėlapį pačiu pagalbinio metodo parametru, bet tada iniciacijos kodas nebūtų trumpesnis.

Trečioji peržiūra

Trečiasis patarimas yra tai, kad galite sukurti pagalbinę klasę, kurią galima panaudoti naudojant užpildymo funkcijas. Tai tikrai paprasta, 10 eilių pagalbinė klasė, kuri yra saugi:

 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 } } 
5
22 апр. atsakymas pateikiamas icza 22 Bal 2014-04-22 11:46 '14 at 11:46 2014-04-22 11:46

Jei jums reikia kažko daug ir palyginti saugaus, galite tiesiog perjungti kompiliavimo laiko tipą iki vykdymo laiko:

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

Šis įgyvendinimas turėtų sugauti visas klaidas:

 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); } } } 
4
02 авг. Atsakymas duotas Philip 02 rug. 2013-08-02 04:30 '13, 4:30, 2013-08-02 04:30

Galite naudoti „ StickyMap ir „ MapEntry iš „ Cactoos“ :

 private static final Map<String, String> MAP = new StickyMap<>( new MapEntry<>("name", "Jeffrey"), new MapEntry<>("age", "35") ); 
4
20 июня '17 в 20:28 2017-06-20 20:28 atsakymas pateikiamas „ yegor256“ birželio 20 d. 17:20 20:28 2017-06-20 20:28

Su „Java 8“ atėjau naudoti šį šabloną:

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

Tai nėra trumpiausias ir šiek tiek negailestingas, bet

  • ji nereikalauja nieko už java.util
  • ji rūšiuoja ir lengvai pritaiko įvairių tipų raktus ir vertybes.
4
20 нояб. atsakymas pateikiamas zrvan 20 nov. 2015-11-20 03:26 '15 at 3:26 2015-11-20 03:26

Man nepatinka statinio iniciatoriaus sintaksė ir nesu tikras dėl anoniminių poklasių. Paprastai sutinku su visais statinių iniciatorių trūkumais ir visais anoniminių poklasių, minėtų ankstesniuose atsakymuose, trūkumais. Kita vertus, šiuose postuose atstovaujantys specialistai man nepakanka. Norėčiau naudoti statinį inicijavimo metodą:

 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; } } 
3
27 авг. Stanisław Borowy atsakymas 27 rug. 2012-08-27 09:09 '12 at 9:09 2012-08-27 09:09

Kadangi „Java“ nepalaiko kartografinių literatūrų, žemėlapio atvejai visada turi būti aiškiai sukurti ir apgyvendinti.

Laimei, naudojant gamyklinius metodus, galite apytiksliai įvertinti „Java“ literatūros elgesį.

Pavyzdžiui:

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

Išvada:

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

Tai yra daug patogiau nei kortelės kūrimas ir užpildymas vienu metu.

3
27 февр. atsakymas pateikiamas nazar_art 27 vasaris 2016-02-27 00:53 '16 at 0:53 2016-02-27 00:53

Jūsų antrasis požiūris (dvigubo laikiklio inicijavimas) laikomas anti-modeliu , todėl nustojau prie pirmojo požiūrio.

Kitas paprastas būdas inicijuoti statinį žemėlapį yra naudoti šią paslaugos funkciją:

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

Pastaba: Java 9 galite naudoti Map.of

3
23 мая '17 в 12:29 2017-05-23 12:29 Atsakymą pateikė R. Oosterholt , gegužės 23 d. 17 d. 12:29 2017-05-05 12:29

Aš nemačiau požiūrio, kurį naudoju (ir pradėjau mylėti), įdėjęs į bet kokius atsakymus, todėl čia yra:

Nenoriu naudoti statinių iniciatorių, nes jie yra nepatogūs, ir man nepatinka anonimiškos klasės, nes kiekvienam atvejui sukuriama nauja klasė.

vietoj to, aš norėčiau inicijuoti, kuri atrodo taip:

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

Deja, šie metodai nėra standartinės „Java“ bibliotekos dalis, todėl jums reikės sukurti (arba naudoti) naudingumo biblioteką, kuri apibrėžia šiuos metodus:

  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) 

(galite naudoti „importuoti statinį“, kad išvengtumėte metodo pavadinimo įvedimo)

Man buvo naudinga pateikti panašius statinius metodus kitoms kolekcijoms (sąrašas, rinkinys, rūšiavimas, rinkinys, rūšiavimas ir kt.)

Tai nėra taip gerai, kaip inicijuoti „Json“ objektą, bet tai yra žingsnis šia kryptimi, kiek tai suprantama.

3
03 июня '15 в 23:46 2015-06-03 23:46 atsakymą pateikė josh birželio 15 d. 15, 23:46 2015-06-03 23:46

JEP 269 pateikia kelis patogius API rinkinių gamybos metodus. Šie gamykliniai metodai nėra dabartinėje „Java“ versijoje, kuri yra 8, bet yra planuojama „Java 9“ versijai.

Yra du gamyklos metodai: „ Map of ir „ ofEntries . Naudodami, galite perkelti porų porų / raktų. Pavyzdžiui, jei norite sukurti Map pvz., {age: 27, major: cs} :

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

Šiuo metu yra dešimt perkrautų versijų, todėl galite sukurti žemėlapį, kuriame yra dešimt pagrindinių / vertės porų. Jei jums nepatinka šis apribojimas arba kintamasis raktas / vertės, galite naudoti „

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

Tiek of tiek ir „ ofEntries grąžina ofEntries Map , taigi negalite pakeisti jų elementų po statybos. Šias funkcijas galite išbandyti naudodami „ JDK 9 Early Access“ .

2
10 апр. Atsakymas, kurį pateikė Ali Dehghani, balandžio 10 d 2016-04-10 18:08 '16 at 18:08 2016-04-10 18:08

Na ... man patinka aukcionai;)

 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 ) ); } 
2
ответ дан jglatre 25 окт. '17 в 19:28 2017-10-25 19:28

Если вам нужно добавить только одно значение на карту, вы можете использовать Collections.singletonMap :

 Map<K, V> map = Collections.singletonMap(key, value) 
2
ответ дан Stromata 01 мая '17 в 0:28 2017-05-01 00:28