Meilleure façon de créer une carte vide en Java

J'ai besoin de créer une carte vide.

if (fileParameters == null)
    fileParameters = (HashMap<String, String>) Collections.EMPTY_MAP;

Le problème est que le code ci-dessus, produit de cet avertissement:
De sécurité de Type: Décoché projetée à partir de la Carte de HashMap

Quelle est la meilleure façon de créer cette carte vide?

Quel est votre type déclaré pour fileParameters?
Vous aurez probablement un ClassCastException trop.
fileParameters devrait être une Carte et pas une HashMap.

InformationsquelleAutor JorgeO | 2009-03-11

217

1) Si la Carte peut être immuable:
```
Collections.emptyMap()

//or, in some cases:
Collections.<String, String>emptyMap()
```
Vous aurez à utiliser ce dernier, parfois, quand le compilateur ne peut pas comprendre à quel type de Carte est nécessaire (ce qui est appelé l'inférence de type). Par exemple, considérons une méthode déclarée comme ceci:
```
public void foobar(Map<String, String> map){ ... }
```
Lors du passage de la Carte vide directement, vous devez être explicite sur le type:
```
foobar(Collections.emptyMap());                 //doesn't compile
foobar(Collections.<String, String>emptyMap()); //works fine
```
2) Si vous avez besoin d'être en mesure de modifier la Carte, par exemple:
```
new HashMap<String, String>()
```
(comme tehblanx souligné)

Additif: Si votre projet utilise des Goyave, vous avez les possibilités suivantes:

1) Immuable carte:
```
ImmutableMap.of()
//or:
ImmutableMap.<String, String>of()
```
Accordé, pas de gros avantages par rapport à Collections.emptyMap(). À partir de la Javadoc:

Cette carte se comporte et effectue comparable à Collections.emptyMap(),
et il est préférable principalement pour des raisons de cohérence et de facilité de maintenance de vos
code.

2) Carte que vous pouvez modifier:
```
Maps.newHashMap()
//or:
Maps.<String, String>newHashMap()
```
Cartes contient similaire usine méthodes pour l'instanciation d'autres types de cartes, comme TreeMap ou LinkedHashMap.

Mise à jour (2018): Sur Java 9 ou plus récent, le plus court de code pour la création d'une immuable vide de la carte est:
```
Map.of()
```
...à l'aide de la nouvelle commodité méthodes de fabrique de JEP 269.
- Dans la plupart des cas, l'inférence de type œuvres (ie. map = Collections.emptyMap() fonctionne)
- Ouais, c'est vrai. J'ai édité la réponse un peu plus complète.
InformationsquelleAutor Jonik
16

Les Collections.emptyMap()
- Le problème est que cette carte ne peut être appliqué à une Carte objet n'est pas une HashMap
- Vous devez (en général), éviter de déclarer des objets de leurs types spécifiques et à l'utilisation de l'interface (ou le résumé des parents) à la place. Essayez d'éviter de "HashMap<String, String> toto;" et l'utilisation "Map<String, String> toto;" à la place
InformationsquelleAutor basszero
14

Le emptyMap méthode de la classe Collections.

InformationsquelleAutor TofuBeer
9

Si vous avez besoin d'une instance de la table de hachage, la meilleure façon est:
```
fileParameters = new HashMap<String,String>();
```
Depuis la Carte est une interface, vous devez choisir une classe qui instancie si vous souhaitez créer un vide d'instance. HashMap semble aussi bonne que les autres - donc, juste l'utiliser.

InformationsquelleAutor AndreiM
7

Soit Collections.emptyMap(), ou si l'inférence de type qui ne fonctionne pas dans votre cas,

Collections.<String, String>emptyMap()

InformationsquelleAutor Peter Štibraný

Depuis dans de nombreux cas, une carte vide est utilisé pour les nuls-conception sûre, vous pouvez utiliser le nullToEmpty méthode utilitaire:

class MapUtils {

  static <K,V> Map<K,V> nullToEmpty(Map<K,V> map) {
    if (map != null) {
      return map;
    } else {
       return Collections.<K,V>emptyMap(); //or guava ImmutableMap.of()
    }
  }

}

De même pour les ensembles:

class SetUtils {

  static <T> Set<T> nullToEmpty(Set<T> set) {
    if (set != null) {
      return set;
    } else {
      return Collections.<T>emptySet();
    }
  }

}

et listes:

class ListUtils {

  static <T> List<T> nullToEmpty(List<T> list) {
    if (list != null) {
      return list;
    } else {
      return Collections.<T>emptyList();
    }
  }

}

InformationsquelleAutor Vitalii Fedorenko

1

Ce sujet :

Map<String, String> s = Collections.emptyMap();
- Vous ne serez pas en mesure de modifier une carte vide créé de cette façon.
InformationsquelleAutor OscarRyz

Vous devez vous connecter pour publier un commentaire.