En Java, puis-je déclarer un HashMap constante?

Je suis en train d'écrire un programme simple pour convertir un nombre en un mot représentant un nombre (13 => "treize").

Je me rends compte que j'ai pu obtenir quelques-uns des mots avec une constante Chaîne de tableau comme ceci:

private static final String[] tensNames = {"", " ten", " twenty", " thirty", " forty", " fifty", " sixty", " seventy", " eighty", " ninety" };

...et accéder à l'index, mais je voulais essayer avec une table de hachage comme ceci:

final HashMap<Integer, String> tensNumberConversion = new HashMap<Integer, String>();
    tensNumberConversion.put(2, "twenty");
    tensNumberConversion.put(3, "thirty");
    tensNumberConversion.put(4, "forty");
    tensNumberConversion.put(5, "fifty");
    tensNumberConversion.put(6, "sixty");
    tensNumberConversion.put(7, "seventy");
    tensNumberConversion.put(8, "eighty");
    tensNumberConversion.put(9, "ninety");

J'ai été instruit par un professeur de faire de ces constantes. Peut la table de hachage être une constante? Comme un débutant, ce n'était pas tout à fait clair comment les termes "constante" et "statique" et "finale" sont liées, et ce que fait exactement une constante. (statique seul? final seul? static final de l'ensemble?).

J'ai essayé de faire c'private static final de la table de hachage, mais l'Ide m'a donné une erreur (modificateur "privé" pas autorisé ici...même pour la "statique").

Toutefois, il ne compile à partir de mon terminal sans erreurs. Si une table de hachage peut être une constante, est-ce la bonne façon de déclarer un? Merci!

Il peut être une constante, où en êtes-vous de déclarer votre HashMap?
Double Possible de Comment puis-je initialiser une Carte statique?
Selon ce que je vois, j'ai accepté votre réponse, le 12 Mai. Est-ce différent de ce que vous voyez?

OriginalL'auteur Hoonta | 2017-05-11

11

Il y a deux aspects ici:
- Vous disposez d'une variable qui contient une référence à une carte. Il vous suffit de déclarer la variable à final; et voilà, vous ne pouvez pas modifier la variable de point de un autre de référence.
- Mais cela ne vous empêche pas de modification de la état de l'objet de référence est le pointant du doigt. Alors, même si vous avez un Carte finale objet, vous pouvez toujours l'appeler à mettre/enlever/... les méthodes de cette Carte.
Afin de venir à un véritable "constante" de la Carte, vous allez faire ceci:

D'abord vous créer un carte contenant toutes les valeurs souhaitées.

Puis vous utilisez Collections.unmodifiableMap() dans le but de créer une carte qui ne peut pas être changé.

La seule chose à faire attention: vous devez vous assurer que vous ne fuient pas une référence à la carte d'origine de l'objet en tant que immuables de la carte est juste un wrapper autour de cette carte initiale. Vous pourriez le faire dans une petite aide de la méthode par exemple.

Si vous demandez: est-il un moyen d'écrire une carte de déclaration dans un spécial "littéralement" (comme pour les tableaux) - il n'y en a pas. Eh bien, vous pouvez changer la méthode d'assistance à prendre Object ... comme paramètre; et puis vous allez par le biais de ces paramètres, l'un est un nombre, suivant une chaîne de caractères, et l'utiliser pour remplir la carte. Donc, vous pouvez ensuite appeler la méthode avec une seule séquence de valeurs. Mais probablement pas en vaut la peine ...

Une mise à jour rapide: Java9 ajoutés divers statique méthodes d'assistance qui vous permettent d'écrire des cartes en quelque sorte "littéral", voir ici par exemple.

Les Collections.unmodifiableMap

OriginalL'auteur GhostCat

Oui, il peut être une constante. Vous devez déclarer votre HashMap instance comme suit:

class <class name> {
    private static final HashMap<Integer, String> tensNumberConversion = new HashMap<>();

    static {
        tensNumberConversion.put(2, "twenty");
        tensNumberConversion.put(3, "thirty");
        tensNumberConversion.put(4, "forty");
        tensNumberConversion.put(5, "fifty");
        tensNumberConversion.put(6, "sixty");
        tensNumberConversion.put(7, "seventy");
        tensNumberConversion.put(8, "eighty");
        tensNumberConversion.put(9, "ninety");
    }
}

Cependant, ce n'est qu'une référence constante. Bien que vous ne pouvez pas réaffecter tensNumberConversion à quelque chose d'autre, vous pouvez modifier le contenu de votre carte, plus tard, au moment de l'exécution:

tensNumberConversion = new HashMap<>(); //won't compile
tensNumberConversion.put(9, "one"); //succeeds

Si vous souhaitez que le contenu de votre carte constant trop, vous devez envelopper la HashMap dans un inmodifiable carte:

class <class name> {
    private static final Map<Integer, String> tensNumberConversion = initMap();

    private static Map<Integer, String> initMap() {
        Map<Integer, String> map = new HashMap<>();
        map.put(2, "twenty");
        map.put(3, "thirty");
        map.put(4, "forty");
        map.put(5, "fifty");
        map.put(6, "sixty");
        map.put(7, "seventy");
        map.put(8, "eighty");
        map.put(9, "ninety");
        return Collections.unmodifiableMap(map);
    }
}

Beaucoup mieux maintenant.

OriginalL'auteur ZhekaKozlov

Juste une BTW, avec Java 9, il y a méthodes statiques dans le Map de l'interface pour créer immuable Cartes avec un certain nombre d'entrées comme:

Map<String,String> m = Map.of("k1", "v1",
                              "K2", "v2");

Ou si plus de 10 entrées sont nécessaires:

import static java.util.Map.entry;
Map<String, String> m = Map.ofEntries(
    entry("k1", "v1"), entry("k2", "v2"), …);

OriginalL'auteur eckes

J'ai raté quelque sorte la forme la plus facile pour direct de l'initialisation de la table de hachage ici

private static final Map<Integer, String> tensNumberConversion_internal = new HashMap<Integer, String>()
{
    {
        put(2, "twenty");
        put(3, "thirty");
        put(4, "forty");
        put(5, "fifty");
        put(6, "sixty");
        put(7, "seventy");
        put(8, "eighty");
        put(9, "ninety");
    };
};

et comme pour rendre immuable, vous avez déjà Collections.unmodifiableMap de la accepté de répondre à donc, ne

public static final Map<Integer, String> tensNumberConversion = Collections.unmodifiableMap(tensNumberConversion_internal);

ils doivent être créés dans cet ordre, bien sûr 😉

Je ne dirais pas que le plus "simple", la double accolade de l'initialisation du truc est assez lourd hack: stackoverflow.com/questions/924285/...

OriginalL'auteur derHugo

0

Au lieu d'utiliser le compostage pour obtenir une constante de la table de hachage, vous pourriez utiliser l'héritage pour hériter d'une nouvelle classe à partir de la table de hachage, puis remplacer la table de hachage.put (), méthode pour afficher un message d'échec...

class MyMap extends java.util.HashMap{ @Override public V put (K key, V value){ System.out.println("Operation Not Supported"); return null; } }

Noter que ce n'est pas la seule méthode, mais l'une des nombreuses méthodes possibles

mais c'est essentiellement ce que la carte retournée par Collections.unmodifiableMap le fait déjà - à l'exception qu'il jette au lieu de faire semblant de travailler - toutes les méthodes de modification de jeter UnsupportedOperationException.

OriginalL'auteur Jagreet

Vous devez vous connecter pour publier un commentaire.