Braille Java

Salut KX, karkol,

Je ne suis pas vraiment un expert aguerri en Java, et je n'y connais rien en braille.

Mais, comme utilisateur de Perl, où créer des hash et les utiliser est tellement naturel et très performant pour ce type de problèmes, je me dirigerai plutôt vers un hash :

https://docs.oracle.com/javase/7/docs/api/java/util/Hashtable.html

voire : https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html

où la représentation en braille peut servir de clef à la lettre correspondante (et inversement). Est-ce une mauvaise idée ?


Dal

En soit, les enum sont déjà des tables de hachage, ils sont même meilleurs puisque ils se basent sur une IdentityHashMap.

PS. Hashtable est à proscrire depuis Java 2

Voici à quoi ressemble une classe enum en Java (pour la représentation en braille je considère successivement les 6 points de la matrice avec 1 s'il est en relief, 0 sinon).

public static enum Braille
{
    A("100000"), B("110000"), C("100100"), D("100110"), E("100010");
    
    private final int code;
    
    private Braille(String code)
    {
        this.code = Integer.parseInt(code);
    }

    public int getCode()
    {
        return code;
    }
    
    public String getLetter()
    {
        return super.toString();
    }
    
    public String toString()
    {
        return super.toString()+"="+code;
    }
}
    
public static void main(String[] args)
{
    System.out.println(Braille.A);
    System.out.println(Braille.A.getLetter());
    System.out.println(Braille.A.getCode());
    
    Braille a = Braille.valueOf("A");
    System.out.println(a);
}

Salut KX,

J'ai testé ton code. Pour qu'il compile, je crois que ton main devrait être dans les accolades de Braille, et il semble que Java n'aime pas autre chose que "public" pour définir l'enum (et il faut que l'enum soit dans un Braille.java). Sinon, cela marche bien, c'est vraiment étonnant les enums en Java :-)

Avec HashMap, j'aurai fait deux Hash : un dont la clef est une lettre de l'alphabet, pour obtenir l'équivalent en braille, et l'autre dont la clef est la représentation en braille, pour obtenir la lettre de l'alphabet correspondante :

import java.util.HashMap;

public class TestHashes {

    public static void main(String[] args) {

        // Hash pour trouver la représentation en braille à
        // partir d'une lettre de l'alphabet
        HashMap<Character, String> a2b = new HashMap<Character, String>();
        a2b.put('A', "100000");
        a2b.put('B', "110000");
        a2b.put('C', "100100");
        a2b.put('D', "100110");
        a2b.put('E', "100010");

        // Hash pour trouver la lettre de l'alphabet corres-
        // pondant à une représentation en braille
        HashMap<String, Character> b2a = new HashMap<String, Character>();
        b2a.put("100000", 'A');
        b2a.put("110000", 'B');
        b2a.put("100100", 'C');
        b2a.put("100110", 'D');
        b2a.put("100010", 'E');

        System.out.println("\"A\" in braille is: " + a2b.get('A'));
        System.out.println("\"110000\" in braille is: " 
                + b2a.get("110000"));
    }
}

Cela me semble plus économique que de créer un enum. Je suppose qu'on peut aussi faire deux enums dans ton cas (dans deux fichiers .java je suppose...). J'ai un peu expérimenté, mais sans trop de succès, car Java me jette lorsque l'enum consiste en un chiffre tel que 100000.. cela ne serait pas un identificateur acceptable.

Merci pour ta précision sur "Hashtable", tu as tout à fait raison (comme quoi, il faut lire la doc jusqu'au bout).


Dal

Pour le contenu du 2ème HashMap b2a, au lieu de tout ressaisir, on pourrait énumérer les clefs et valeurs du premier et créer le deuxième en les permutant.

Comme cela :

        Iterator<Character> iterateurClef = a2b.keySet().iterator();

        while (iterateurClef.hasNext())
        {
            Character clef = iterateurClef.next();
            b2a.put(a2b.get(clef), clef);
        }

à moins qu'il y ait un moyen plus malin de copier les clefs et valeurs du premier dans le second en les permutant en utilisant les méthodes keySet() et values().


Dal

"J'ai testé ton code. Pour qu'il compile, je crois que ton main devrait être dans les accolades de Braille, et il semble que Java n'aime pas autre chose que "public" pour définir l'enum (et il faut que l'enum soit dans un Braille.java)."

Non, rien de tout ça en fait.
J'ai effectivement un morceau de code, tu peux tester en rajoutant juste ça avant et après :

public class Test
{
    ...
}

Du coup le fichier sera Test.java, le main est bien à part de la déclaration de l'enum. Le static c'est pour définir la classe interne, on pourra ainsi faire

Test.Braille

pour accéder à l'enum.

"j'aurai fait deux Hash : un dont la clef est une lettre de l'alphabet, pour obtenir l'équivalent en braille, et l'autre dont la clef est la représentation en braille, pour obtenir la lettre de l'alphabet correspondante"
Personnellement ça me dérange de faire un HashMap sur un caractère, parce que les wrapper comme Character sont bien plus lourd qu'un simple caractère en terme de consommation mémoire (certes là on en aura qu'une trentaine, mais dans l'esprit c'est mal), en plus cela signifie que l'on va utiliser un entier comme valeur de hachage d'un caractère (qui est plus petit).
Enfin, mais c'est plus technique, les enum permettent de manipuler des IdentityHashMap, ce qui permet de tester deux valeurs directement avec == et donc économiser un appel "coûteux" à la méthode equals. Du coup, un autre avantage est de pouvoir faire un switch sur la valeur des enum.

Après, je suis d'accord que pour être complet, une deuxième Map peut-être nécessaire pour faire la recherche dans l'autre sens, et comme je suis borné je ferais cette Map directement au sein de mon enum, ce qui complétera la méthode "valueOf" (générée automatiquement par l'enum) d'une méthode "valueByCode", elle aussi static :

private static final Map<Integer, Braille> reverse = initReverse();

private static final Map<Integer, Braille> initReverse()
{
    Braille[] tab = Braille.values();
    Map<Integer, Braille> map = new HashMap<Integer, Braille>(tab.length);
    for (Braille b : tab)
        map.put(b.code, b);
    return map;
}

public static final Braille valueByCode(String code)
{
    return reverse.get(Integer.parseInt(code));
}

Remarque : j'ai utilisé un String code, parce que si j'avais mis int code, on aurait pu avoir des problèmes avec les entiers commençant par 0, qui sont considérés en octal (j'avais fait la même triche hier avec le constructeur de l'enum.