L'initialisation des tables de hachage en Java?

En C#, vous pouvez initialiser les tables de hashage (et de nombreux autres types d'objets) à l'aide de ce type de code -

Hashtable table = new Hashtable {{1, 1}, {2, 2}};

Est-il quelque chose comme cela en Java ou avez-vous juste de déclarer la table de hachage en premier et ensuite mettre manuellement des éléments un par un?

Non, Java n'a pas les initialiseurs d'objets.
En C# et en Java il existe de meilleures alternatives pour un Hashtable classe: C#, préférez Dictionary<TKey, TValue>, et en Java préfèrent HashMap<K, V>.

OriginalL'auteur Jim_CS | 2012-03-08

java

28

Cela est répondu ailleurs, mais vous pouvez utiliser un anonyme sous-classe:
```
new HashMap<Integer, Integer>() {{ put(1, 1); put(2, 2); }};
```
Beaucoup de chaudière de la plaque, mais encore un one-liner :). Ce sera, malheureusement, se plaignent également de l'absence de serialVersionUID constante laquelle vous pouvez ajouter ou d'ignorer l'avertissement.

Il s'agit d'une instance d'initialiseur de bloc, plus d'informations ici.

Il y a un risque de fuite de mémoire ici, cependant. Parce que vous êtes en train de créer une classe anonyme, il va avoir une référence à sa classe englobante (c'est à dire la classe dans laquelle ce code s'affiche). Cela signifie que tant que ce Map est toujours là, donc, est que la classe englobante. Si la classe englobante a un cycle de vie plus court que le Map (par exemple, la Map est de longue vie et de la classe englobante a quelques builder responsable de la création de la Map), alors vous avez une fuite de mémoire.
ouais, un de ces "intelligent, mais pas recommandé d'idées". DBI considérées comme nuisibles 😉

OriginalL'auteur alpian
8

Dans Google Goyave, si vous voulez immuable carte, vous pouvez utiliser:
```
Map<K,V> m = ImmutableMap.of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5);
```
jusqu'à 5 paires Clé/Valeur.

Au-delà, vous pouvez utiliser leur ImmutableMap.Constructeur classe:
```
ImmutableMap<String, Integer> WORD_TO_INT = ImmutableMap.builder()
       .put("one", 1)
       .put("two", 2)
       .put("three", 3)
       .build();
```
Toujours pas aussi bien qu'en C#, mais l'API fluent est un peu utile.

+1, en alternance écrire votre propre utilité: makeMap(A a, B b, Object... remaining) manuellement, puis itérer sur les autres Objets de casting pour A et B en alternance et les ajouter à l'retourné la carte. Pas type-safe, mais concis (utile pour des tests de code peut-être).
non seulement ne serait-ce pas type-safe, mais vous ne pouvez même pas faire appliquer la bonne même nombre arg comte. Mais oui, il pourrait e utile dans un cadre moins formel, tel que test-code.

OriginalL'auteur Kevin Welker

Une autre réponse (en plus de l'évident "non, pas de langue maternelle façon de le faire"):

Créer un Tuple dans une classe statique méthode de fabrique avec une fantaisie-pantalon "_" nom par souci de concision:

import java.util.Map;
import java.util.HashMap;

class Tuple<T1,T2> {
    private T1 t1;
    private T2 t2;
    public Tuple(T1 t1, T2 t2) {
         this.t1 = t1; this.t2 = t2;
    }
    public T1 getT1() {return t1;}
    public T2 getT2() {return t2;}

    static public <X,Y> Tuple<X,Y> _(X t1, Y t2) { return new Tuple<X,Y>(t1,t2); }
    static public <X,Y> Map<X,Y> mapFor(Tuple<X,Y>... tuples) {
        Map<X,Y> map = new HashMap<X,Y>();
        for( Tuple<X,Y> tuple: tuples ) {
           map.put(tuple.getT1(), tuple.getT2());
        }
        return map;
    }

    public static void main(String[] args) {
        Map<String,Integer> map = Tuple.mapFor( _("A", 1), _("B", 2), _("C",3));
    }
}

Si vous voulez autoriser des variations sur ce genre de support de la carte est produite, vous pouvez simplement transmettre que dans la place:

    static public <X,Y> Map<X,Y> mapFor(Map<X,Y> map, Tuple<X,Y>... tuples) {
        for( Tuple<X,Y> tuple: tuples ) {
           map.put(tuple.getT1(), tuple.getT2());
        }
        return map;
    }

OriginalL'auteur Kevin Welker

Essayez ceci:

Hashtable<Integer, String> ht = new Hashtable<Integer, String>(){
    {
        put(1,"One");
        put(2,"Two");
        put(3,"Three");
    }
};

OriginalL'auteur ggrigery

Il y a une chose qu'on appelle la double accolade de l'initialisation, ce qui n'est pas aussi beau...

Hashtable table = new Hashtable() {
    {
        table.put(1, 1);
        table.put(2, 2);
    }
};

Vous pouvez même spécifier à l'aide de anonyme notation de tableau, puis itérer sur vous-même, comme ceci:

Hashtable table = new Hashtable() {
    {
        for (int[] entry : new int[][] { { 1, 1 }, { 2, 2 } }) {
            table.put(entry[0], entry[1]);
        }
    }
};

Peut-être faire une fonction d'utilité si vous êtes vraiment en manque de python 🙂

OriginalL'auteur Adam

0

Un de C#'s caractéristiques qui j'aime bien, c'est sa capacité à initialiser inline comme ça. Malheureusement, Java ne dispose pas de cette fonctionnalité.

La Java Hashtable n'a pas de constructeurs qui permettent ce soit. Voir une liste de ses constructeurs dans la documentation de l'API Java:

http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Hashtable.html

Plus généralement, Java ne prend pas en charge l'initialisation de membre de la liste des constructeurs.

OriginalL'auteur Tyler Treat
0

Si vous avez besoin d'initialiser une HashMap (table de hachage est obsolète), vous pouvez utiliser un bloc d'initialisation statique.

Exemple:
```
private static Map<String, String> map;

static {
    map = new HashMap<String, String>();
    map.put("name1", "value1");
    map.put("name2", "value2");
    ....
}
```
Espère que cela a aidé, amusez-vous!

OriginalL'auteur SimonSez

Une approche sûre est d'utiliser ImmutableMap.of de Goyave et éventuellement enveloppé avec newHashSet si la mutabilité est nécessaire:

Maps.newHashMap(ImmutableMap.of(k1, v1, ...));

Voici un auto-écrit map builder pour les utiliser, par exemple,newMap(1, "one", 2, "two", 3, "three").

public static <K, V> Map<K, V> newMap(final K key, final V value, final Object... elements) {
    Preconditions.checkNotNull(key);
    Preconditions.checkArgument(elements.length % 2 == 0, "Array length can't be " + elements.length);

    final HashMap<Object, Object> map = Maps.newHashMap();
    map.put(key, value);
    for (int i = 0; i < elements.length; i += 2) {
        map.put(elements[i], elements[i + 1]);
    }
    return (Map<K, V>) map;
}

OriginalL'auteur Nowaker

je suggère quelque chose comme ceci:

String[] names={"albert","john","michel"};
int[] id={1234,2345,3456};
Hashtable<int,String> persons = new Hashtable<int,String>();

for(int i=0;i<3;i++)
{
 persons.put(id[i],names[i]);
}

OriginalL'auteur Gal Rom

-1

Ce n'est pas possible en Java. Nous en souffrons tous.

HashMap accomplit la même chose, bien que. Double-vérifier les réponses sont déjà sur le post de discuter de cette chose même.

OriginalL'auteur whysoserious

Vous devez vous connecter pour publier un commentaire.