Java 根据hashmap检查字符串

我想建立一个程序，将英语翻译成摩尔斯电码，反之亦然，我已经决定使用哈希映射来实现这一点，但我不确定如何通过哈希映射运行字符串，并在最后得到翻译。这是我目前的代码：

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

public class MorseCodeTranslator{

public static String translateToMorseCode() {
    String englishtoMorse = "";
    String translation = null;

    Map<Character, String> morse = new HashMap<Character, String>();
    morse.put('a', "._");
    morse.put('b', "_...");
    morse.put('c',  "_._");
    morse.put('d',  "_..");
    morse.put('e',    ".");
    morse.put('f', ".._.");
    morse.put('g',  "__.");
    morse.put('h', "....");
    morse.put('i',   "..");
    morse.put('j', ".___");
    morse.put('k',   "_.");
    morse.put('l', "._..");
    morse.put('m',   "__");
    morse.put('n',   "_.");
    morse.put('o',  "___");
    morse.put('p', ".__.");
    morse.put('q', "__._");
    morse.put('r', "._.");
    morse.put('s',  "...");
    morse.put('t',   "_");
    morse.put('u',  ".._");
    morse.put('v', "..._");
    morse.put('w',  ".__");
    morse.put('x', "_.._");
    morse.put('y', "_.__");
    morse.put('z', "__..");

    return translation;
}    

public static String translateFromMorseCode() {
    String morsetoEnglish = "";
    String translation = null;

    Map<Character, String> morse = new HashMap<Character, String>();
    morse.put('a', "._");
    morse.put('b', "_...");
    morse.put('c',  "_._");
    morse.put('d',  "_..");
    morse.put('e',    ".");
    morse.put('f', ".._.");
    morse.put('g',  "__.");
    morse.put('h', "....");
    morse.put('i',   "..");
    morse.put('j', ".___");
    morse.put('k',   "_.");
    morse.put('l', "._..");
    morse.put('m',   "__");
    morse.put('n',   "_.");
    morse.put('o',  "___");
    morse.put('p', ".__.");
    morse.put('q', "__._");
    morse.put('r', "._.");
    morse.put('s',  "...");
    morse.put('t',   "_");
    morse.put('u',  ".._");
    morse.put('v', "..._");
    morse.put('w',  ".__");
    morse.put('x', "_.._");
    morse.put('y', "_.__");
    morse.put('z', "__..");  

    return translation;
}
}  

import java.util.HashMap；
导入java.util.Map；
公共类莫尔斯电码转换器{
公共静态字符串translateToMorseCode（）{
字符串englishtomores=“”；
字符串转换=null；
Map morse=newhashmap（）；
莫尔斯.普特（'a'，“）；
莫尔斯.普特（'b'，“…）；
莫尔斯放；
莫尔斯.普特（'d'，“..”）；
莫尔斯.普特（'e'，”）；
莫尔斯.普特（'f'，”）；
莫尔斯.普特（'g'，“__”）；
morse.put（'h'，“…”）；
莫尔斯.普特（'我'，''）；
莫尔斯.普特（'j'，”）；
莫尔斯.普特（'k'，“_”）；
莫尔斯.普特（'l'，”）；
莫尔斯放；
莫尔斯.普特（'n'，'u'）；
莫尔斯放；
莫尔斯.普特（'p'，”）；
莫尔斯放；
莫尔斯.普特（'r'，”）；
莫尔斯.普特（'s'，“…”）；
莫尔斯放；
摩尔斯电码put（'u'，”）；
莫尔斯.普特（'v'，“…”）；
莫尔斯.普特（'w'，”）；
莫尔斯.普特（'x'，“..”）；
莫尔斯.普特（'y'，'uuuuu.'uuuu'）；
莫尔斯.普特（'z'，”）；
返回翻译；
}    
公共静态字符串translateFromorSecode（）{
字符串morsetoEnglish=“”；
字符串转换=null；
Map morse=newhashmap（）；
莫尔斯.普特（'a'，“）；
莫尔斯.普特（'b'，“…）；
莫尔斯放；
莫尔斯.普特（'d'，“..”）；
莫尔斯.普特（'e'，”）；
莫尔斯.普特（'f'，”）；
莫尔斯.普特（'g'，“__”）；
morse.put（'h'，“…”）；
莫尔斯.普特（'我'，''）；
莫尔斯.普特（'j'，”）；
莫尔斯.普特（'k'，“_”）；
莫尔斯.普特（'l'，”）；
莫尔斯放；
莫尔斯.普特（'n'，'u'）；
莫尔斯放；
莫尔斯.普特（'p'，”）；
莫尔斯放；
莫尔斯.普特（'r'，”）；
莫尔斯.普特（'s'，“…”）；
莫尔斯放；
摩尔斯电码put（'u'，”）；
莫尔斯.普特（'v'，“…”）；
莫尔斯.普特（'w'，”）；
莫尔斯.普特（'x'，“..”）；
莫尔斯.普特（'y'，'uuuuu.'uuuu'）；
莫尔斯.普特（'z'，”）；
返回翻译；
}
}  

---

我希望能够通过哈希映射运行

englishtoMorse

或

morsetoEnglish

中的任何内容，并将字符转换为哈希映射中与之关联的值，然后在

翻译中输出它们

您可以在此处使用

BiMap

。我认为它更适合你的情况

BiMap<Character, String> biMap = HashBiMap.create();

biMap.put('a', "._");
biMap.put('b', "_..");

System.out.println("morse code = " + biMap.get('a'));
System.out.println("alphabet = " + biMap.inverse().get("._"));

BiMap BiMap=HashBiMap.create（）；
biMap.put（'a'，“）；
biMap.put（'b'，“..”）；
System.out.println（“摩尔斯电码=“+biMap.get（'a'））；
System.out.println（“alphabet=“+biMap.inverse（）.get”（；

---

您可以使用

guava

。访问创建地图作为静态字段。加上摩尔斯字母表。然后创建一个方法 它获取要翻译的文本作为参数。然后迭代文本以翻译每个字符，并使用翻译后的字符创建将返回的字符串

我已经用你的代码和我的解释做了一个例子。 该代码仅适用于摩尔斯电码中的英文文本。您必须添加另一个方向

import java.util.*;
import java.lang.*;
import java.io.*;

class Ideone
{

    private static final Map<Character, String> morse = new HashMap<Character, String>();
    static {
    morse.put('a', "._");
    morse.put('b', "_...");
    morse.put('c',  "_._");
    morse.put('d',  "_..");
    morse.put('e',    ".");
    morse.put('f', ".._.");
    morse.put('g',  "__.");
    morse.put('h', "....");
    morse.put('i',   "..");
    morse.put('j', ".___");
    morse.put('k',   "_.");
    morse.put('l', "._..");
    morse.put('m',   "__");
    morse.put('n',   "_.");
    morse.put('o',  "___");
    morse.put('p', ".__.");
    morse.put('q', "__._");
    morse.put('r', "._.");
    morse.put('s',  "...");
    morse.put('t',   "_");
    morse.put('u',  ".._");
    morse.put('v', "..._");
    morse.put('w',  ".__");
    morse.put('x', "_.._");
    morse.put('y', "_.__");
    morse.put('z', "__..");
    morse.put(' ', " ");
    }
    public static void main (String[] args) throws java.lang.Exception
    {
        String str = "Hello World";
        System.out.println(translate(str));
    }



    public static String translate(String text) {
        StringBuilder builder = new StringBuilder();
        String lower = text.toLowerCase();
        for (int i = 0; i < text.length(); i++) {
            builder.append(morse.get(lower.charAt(i)));
        }
        return builder.toString();
    }    

}

工作示例：

对于“English to Morse”用例，请使用

作为循环，如下所示：

StringBuilder sb = new StringBuilder();
for ( int i = 0; i < englishtoMorse.length(); i++) {
    char c = englishtoMorse.charAt(i);
    sb.append(morse.get(c));
}
translate = sb.toString();

StringTokenizer st = new StringTokenizer(morseToEnglish);
StringBuilder result = new StringBuilder();
while( st.hasMoreTokens()) {
    result.append(morse.findKey(st.nextToken()));
}
translation = sb.toString();

我希望这有帮助。
您应该初始化映射一次（例如，在静态数据成员中，如Zelldon建议的）。完成此操作后，可以使用Java 8的流式API将字符串从英语优雅地转换为morse：

public static String translateToMorseCode(String english) {
    return english.chars()
                  .boxed()
                  .map(c -> morse.get((char) c.intValue()))
                  .collect(Collectors.joining());
}

编辑：

正如JB Nizet所评论的，使用
mapToObj
会更优雅（大概也更高效）：

您可以根据需要使用HashMap：

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

    public class MorseCodeTranslator{
    public static Map<Character, String> morse = new HashMap<Character, String>();
    public static Map<String, Character> english = new HashMap<>();
    public MorseCodeTranslator(){
    morse.put('a', "._");
    morse.put('b', "_...");
    morse.put('c',  "_._");
    morse.put('d',  "_..");
    morse.put('e',    ".");
    morse.put('f', ".._.");
    morse.put('g',  "__.");
    morse.put('h', "....");
    morse.put('i',   "..");
    morse.put('j', ".___");
    morse.put('k',   "_.");
    morse.put('l', "._..");
    morse.put('m',   "__");
    morse.put('n',   "_.");
    morse.put('o',  "___");
    morse.put('p', ".__.");
    morse.put('q', "__._");
    morse.put('r', "._.");
    morse.put('s',  "...");
    morse.put('t',   "_");
    morse.put('u',  ".._");
    morse.put('v', "..._");
    morse.put('w',  ".__");
    morse.put('x', "_.._");
    morse.put('y', "_.__");
    morse.put('z', "__..");
    morse.forEach( (c,s) -> english.put(s, c));
    }


    public static String translateToMorseCode(final String english) {
    char[] data = english.toCharArray();
    StringBuilder result = new StringBuilder();
    for(char c: data) result.append(morse.get(new Character(c)));
    return result.toString();
    }

    public static String translateFromMorseCode(final String morseCode) {
    String[] data = morseCode.split(" ");
    StringBuilder result = new StringBuilder();
    for(String s:data) result.append(english.get(s));
    return result.toString();
    }
    }

import java.util.HashMap；
导入java.util.Map；
公共类莫尔斯电码转换器{
公共静态映射morse=newhashmap（）；
public static Map english=new HashMap（）；
公共MorseCodeTranslator（）{
莫尔斯.普特（'a'，“）；
莫尔斯.普特（'b'，“…）；
莫尔斯放；
莫尔斯.普特（'d'，“..”）；
莫尔斯.普特（'e'，”）；
莫尔斯.普特（'f'，”）；
莫尔斯.普特（'g'，“__”）；
morse.put（'h'，“…”）；
莫尔斯.普特（'我'，''）；
莫尔斯.普特（'j'，”）；
莫尔斯.普特（'k'，“_”）；
莫尔斯.普特（'l'，”）；
莫尔斯放；
莫尔斯.普特（'n'，'u'）；
莫尔斯放；
莫尔斯.普特（'p'，”）；
莫尔斯放；
莫尔斯.普特（'r'，”）；
莫尔斯.普特（'s'，“…”）；
莫尔斯放；
摩尔斯电码put（'u'，”）；
莫尔斯.普特（'v'，“…”）；
莫尔斯.普特（'w'，”）；
莫尔斯.普特（'x'，“..”）；
莫尔斯.普特（'y'，'uuuuu.'uuuu'）；
莫尔斯.普特（'z'，”）；
morse.forEach（（c，s）->english.put（s，c））；
}
公共静态字符串translateToMorseCode（最终字符串英语）{
char[]data=english.toCharArray（）；
StringBuilder结果=新建StringBuilder（）；
for（char c:data）result.append（morse.get（新字符（c））；
返回result.toString（）；
}
公共静态字符串translateFromorSecode（最终字符串morseCode）{
字符串[]数据=morseCode.split（“”）；
StringBuilder结果=新建StringBuilder（）；
for（字符串s:data）result.append（english.get（s））；
返回result.toString（）；
}
}
使用一个表并使用Map.entrySet（）进行反向搜索。别忘了一个分隔符

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.StringTokenizer;

public class MorseCodeTranslator{
    public static Map<Character, String> getMorseTable(){
        Map<Character, String> morse = new HashMap<Character, String>();
        morse.put('a', "._");
        morse.put('b', "_...");
        morse.put('c',  "_._");
        morse.put('d',  "_..");
        morse.put('e',    ".");
        morse.put('f', ".._.");
        morse.put('g',  "__.");
        morse.put('h', "....");
        morse.put('i',   "..");
        morse.put('j', ".___");
        morse.put('k',   "_.");
        morse.put('l', "._..");
        morse.put('m',   "__");
        morse.put('n',   "_.");
        morse.put('o',  "___");
        morse.put('p', ".__.");
        morse.put('q', "__._");
        morse.put('r', "._.");
        morse.put('s',  "...");
        morse.put('t',   "_");
        morse.put('u',  ".._");
        morse.put('v', "..._");
        morse.put('w',  ".__");
        morse.put('x', "_.._");
        morse.put('y', "_.__");
        morse.put('z', "__..");
        return morse;
    }
    public static String toMorse(String text){      
        Map<Character, String> table  = getMorseTable();
        StringBuilder result = new StringBuilder();
        // get every char in text
        for(int i = 0; i < text.length(); i++){
            char c = text.charAt(i);
            // and add morse character from table
            result.append(table.get(c));
            // put character separator
            result.append("|");
        }
        // delete last character separator
        result.deleteCharAt(result.length() - 1);
        return result.toString();
    }

    public static String fromMorse(String morse){
        Map<Character, String> table  = getMorseTable();
        // use string tokenizer to separate morse characters
        StringTokenizer st = new StringTokenizer(morse,"|");
        StringBuilder result = new StringBuilder();
        // get every morse character
        while( st.hasMoreTokens()) {
            String morseChar = st.nextToken();
            // and find equivalent letter in morse table
            for (Entry<Character, String> entry : table.entrySet()) {
                if (entry.getValue().equals(morseChar)) {
                   result.append(entry.getKey());
                   break;
                }
            }
        }
        return result.toString();
    }

    public static void main(String[] args){
        String text = "abcxyz";
        System.out.println(text);
        String morse = toMorse(text);
        System.out.println(morse);
        String back = fromMorse(morse);
        System.out.println(back);
    }
}

在
translateFromorSecode
中切换键值对。如果要使用此方法，请将HashMap初始化移到方法之外。除了希望映射与
translateFromorSecode
相反之外，这听起来很合理。你遇到了一个特定的问题吗？这还不够，因为莫尔斯电码的长度不相等。是的，这也是个好主意。谢谢，如果你可以使用番石榴，考虑把你的映射放在一个不可变的BIMAP中，这样你就不必同时维护这两个映射。并一次性构建它并重用同一个map实例
    import java.util.HashMap;
    import java.util.Map;

    public class MorseCodeTranslator{
    public static Map<Character, String> morse = new HashMap<Character, String>();
    public static Map<String, Character> english = new HashMap<>();
    public MorseCodeTranslator(){
    morse.put('a', "._");
    morse.put('b', "_...");
    morse.put('c',  "_._");
    morse.put('d',  "_..");
    morse.put('e',    ".");
    morse.put('f', ".._.");
    morse.put('g',  "__.");
    morse.put('h', "....");
    morse.put('i',   "..");
    morse.put('j', ".___");
    morse.put('k',   "_.");
    morse.put('l', "._..");
    morse.put('m',   "__");
    morse.put('n',   "_.");
    morse.put('o',  "___");
    morse.put('p', ".__.");
    morse.put('q', "__._");
    morse.put('r', "._.");
    morse.put('s',  "...");
    morse.put('t',   "_");
    morse.put('u',  ".._");
    morse.put('v', "..._");
    morse.put('w',  ".__");
    morse.put('x', "_.._");
    morse.put('y', "_.__");
    morse.put('z', "__..");
    morse.forEach( (c,s) -> english.put(s, c));
    }


    public static String translateToMorseCode(final String english) {
    char[] data = english.toCharArray();
    StringBuilder result = new StringBuilder();
    for(char c: data) result.append(morse.get(new Character(c)));
    return result.toString();
    }

    public static String translateFromMorseCode(final String morseCode) {
    String[] data = morseCode.split(" ");
    StringBuilder result = new StringBuilder();
    for(String s:data) result.append(english.get(s));
    return result.toString();
    }
    }

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.StringTokenizer;

public class MorseCodeTranslator{
    public static Map<Character, String> getMorseTable(){
        Map<Character, String> morse = new HashMap<Character, String>();
        morse.put('a', "._");
        morse.put('b', "_...");
        morse.put('c',  "_._");
        morse.put('d',  "_..");
        morse.put('e',    ".");
        morse.put('f', ".._.");
        morse.put('g',  "__.");
        morse.put('h', "....");
        morse.put('i',   "..");
        morse.put('j', ".___");
        morse.put('k',   "_.");
        morse.put('l', "._..");
        morse.put('m',   "__");
        morse.put('n',   "_.");
        morse.put('o',  "___");
        morse.put('p', ".__.");
        morse.put('q', "__._");
        morse.put('r', "._.");
        morse.put('s',  "...");
        morse.put('t',   "_");
        morse.put('u',  ".._");
        morse.put('v', "..._");
        morse.put('w',  ".__");
        morse.put('x', "_.._");
        morse.put('y', "_.__");
        morse.put('z', "__..");
        return morse;
    }
    public static String toMorse(String text){      
        Map<Character, String> table  = getMorseTable();
        StringBuilder result = new StringBuilder();
        // get every char in text
        for(int i = 0; i < text.length(); i++){
            char c = text.charAt(i);
            // and add morse character from table
            result.append(table.get(c));
            // put character separator
            result.append("|");
        }
        // delete last character separator
        result.deleteCharAt(result.length() - 1);
        return result.toString();
    }

    public static String fromMorse(String morse){
        Map<Character, String> table  = getMorseTable();
        // use string tokenizer to separate morse characters
        StringTokenizer st = new StringTokenizer(morse,"|");
        StringBuilder result = new StringBuilder();
        // get every morse character
        while( st.hasMoreTokens()) {
            String morseChar = st.nextToken();
            // and find equivalent letter in morse table
            for (Entry<Character, String> entry : table.entrySet()) {
                if (entry.getValue().equals(morseChar)) {
                   result.append(entry.getKey());
                   break;
                }
            }
        }
        return result.toString();
    }

    public static void main(String[] args){
        String text = "abcxyz";
        System.out.println(text);
        String morse = toMorse(text);
        System.out.println(morse);
        String back = fromMorse(morse);
        System.out.println(back);
    }
}

abcxyz
._|_...|_._|_.._|_.__|__..
abcxyz