Java 两个数组或一个哈希映射来将字符串转换为摩尔斯电码？

我正在尝试转换字符串

字符串输入到摩尔斯电码，然后返回。我很难弄清楚该使用哪种方法以及如何使用它。我正在尝试转换为摩尔斯电码的字符串：
SOS
，它应该转换为
…--…
，并从摩尔斯电码转换为英语：
…--…
-
SOS

我尝试的一种方法是使用两个数组，
String[]alpha={A-Z0-9}
和
String[]morse={morse patterns}
。然后我尝试将
String
输入拆分成一个数组，将字符串输入中的每个字符与
String[]alpha
中的每个字符进行比较，并将每个索引存储在
索引数组[]
中。我使用了
inputArray=input.split（“，-1”）

最后，通过一些
for
循环和
if
语句，我试图使用我想要查找字符串字符的索引，在
string[]morse
中查找摩尔斯电码

我在上面尝试的方法不适用于单词，但适用于一个字符（下面的代码）。它失败了，我想不出如何用那种方式修复它。这是最好的方法吗？或者
HashMap

然后我试着使用一个
HashMap
，用英文字符作为键，用morse作为值

哪种方法是将英文字符串转换为摩尔斯电码以及将摩尔斯电码转换为英文字符串的最佳方法？数组还是哈希映射

阵列：

private String[] alpha = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J",
    "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V",
    "W", "X", "y", "z", "1", "2", "3", "4", "5", "6", "7", "8",
"9", "0", " "};

private String[] morse = {".-", "-...", "-.-.", "-..", ".", "..-.", "--.",
    "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.",
    "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-",
    "-.--", "--..", ".----", "..---", "...--", "....-", ".....",
"-....", "--...", "---..", "----.", "-----", "|"};

我正在进行的循环中断，但不知道如何执行：

public int[] indexOfArray(String englishInput) {
    englishArray = englishInput.split("", -1);
    for (int j = 0; j < englishArray.length; j++) {
        for (int i = 0; i < alpha.length; i++) {
            if (alpha[i].equals(englishArray[j])) {
                indexArray[i] = i;
            }
        }
    }
    return indexArray;
}

public int[]indexOfArray（String englishInput）{
englishArray=englishInput.split（“，-1”）；
对于（int j=0；j

这只适用于一个字符（字符到摩尔斯电码）：

public int indexofarayold（String englishInput）{
for（int i=0；i

哈希映射：

private static HashMap<String, String>; alphaMorse = new HashMap<String, String>();

static {
    alphaMorse.put("A", ".-");
    alphaMorse.put("B", "-...");
    alphaMorse.put("C", "-.-.");
    alphaMorse.put("D", "-..");
    alphaMorse.put("E", ".");
    alphaMorse.put("F", "..-.");
    alphaMorse.put("G", "--.");
    alphaMorse.put("H", "....");
    alphaMorse.put("I", "..");
    alphaMorse.put("J", ".---");
    alphaMorse.put("K", "-.-");
    alphaMorse.put("L", ".-..");
    alphaMorse.put("M", "--");
    alphaMorse.put("N", "-.");
    alphaMorse.put("O", "---");
    alphaMorse.put("P", ".--.");
    alphaMorse.put("Q", "--.-");
    alphaMorse.put("R", ".-.");
    alphaMorse.put("S", "...");
    alphaMorse.put("T", "-");
    alphaMorse.put("U", "..-");
    alphaMorse.put("V", "...-");
    alphaMorse.put("W", ".--");
    alphaMorse.put("X", "-..-");
    alphaMorse.put("y", "-.--");
    alphaMorse.put("z", "--..");
    alphaMorse.put("1", ".----");
    alphaMorse.put("2", "..---");
    alphaMorse.put("3", "...--");
    alphaMorse.put("4", "....-");
    alphaMorse.put("5", ".....");
    alphaMorse.put("6", "-....");
    alphaMorse.put("7", "--...");
    alphaMorse.put("8", "---..");
    alphaMorse.put("9", "----.");
    alphaMorse.put("0", "-----");
    alphaMorse.put(" ", "|");
}

私有静态HashMap；alphaMorse=新HashMap（）；
静止的{
alphaMorse.put（“A”、“-”）；
alphaMorse.put（“B”、“-…”）；
字母莫尔斯put（“C”，“-.-”）；
阿尔法莫尔斯.普特（D），“-…”；
字母莫尔斯。put（“E”，“E”）；
alphaMorse.put（“F”、“.-”）；
alphaMorse.put（“G”，““-.”）；
alphaMorse.put（“H”、“…”）；
alphaMorse.put（“I”，”）；
alphaMorse.put（“J”，“--”）；
字母莫尔斯put（“K”，“-.-”）；
阿尔法莫尔斯.普特（“L”，“-”）；
alphaMorse.put（“M”和“--”）；
alphaMorse.put（“N”，“-”）；
阿尔法摩斯.put（“O”，““--”）；
alphaMorse.put（“P”、“-”）；
阿尔法莫尔斯.普特（“Q”，“-.-”）；
alphaMorse.put（“R”、“-”）；
阿尔法莫尔斯。普特（“S”，即“…”）；
alphaMorse.put（“T”，“-”）；
alphaMorse.put（“U”、“.-”）；
alphaMorse.put（“V”、“…-”）；
alphaMorse.put（“W”、“-”）；
alphaMorse.put（“X”、“-…-”）；
字母莫尔斯。put（“y”，“-.-”）；
阿尔法莫尔斯。普特（“z”，“-…”）；
alphaMorse.put（“1”，“----”；
alphaMorse.put（“2”，“.-”）；
alphaMorse.put（“3”，“…”）；
alphaMorse.put（“4”、“…-”）；
字母莫尔斯。put（“5”，即“…”）；
阿尔法莫尔斯.普特（“6”，“-…”）；
alphaMorse.put（“7”、“-…”）；
阿尔法莫尔斯.普特（“8”和“-----”）；
字母莫尔斯。put（“9”，“----”）；
alphaMorse.put（“0”，“----”）；
alphaMorse.put（“，“|”）；
}
我认为，理想情况下，您有一个二维数组，例如：

    String[][] morseArray = new String[][] {{ "S" , "..." }, { "O", "---" }}; 

然后，如果您希望查找的速度和方便性，您可能希望有两个地图：

private Map<String,String> enToMorse;
private Map<String,String> morseToEn;

私人地图；
私人地图；

和一些私有方法来检索它们：

private Map<String,String> getMorseToEnMap() {
    if(morseToEn==null) {
        morseToEn = new HashMap<String,String>();
        for(String[] x : morseArray) {
            morseToEn.put(x[1], x[0]);
        }
    }
    return morseToEn;
}

private-Map getMorseToEnMap（）{
if（morseToEn==null）{
morseToEn=新HashMap（）；
for（字符串[]x:morserray）{
（x[1]，x[0]）；
}
}
返回摩尔斯通；
}

然后你就可以走了：

 Map<String,String> morse = getMorseToEn();
 String x = morse.get("...");
 [...]

Map morse=getMorseToEn（）；
字符串x=morse.get（“…”）；
[...]

好处是：一方面，你有一种简单的方法来定义映射-两个独立的数组更难保持同步-而另一方面，映射将是查找类似内容的最快、最简单的方法。
使用Hashmap并获取方法来比较它们，最后将键或值附加到字符串：

public String stringToMorse(String str){
    String morse = "";
    for(char s: str.toCharArray()){
        morse += (String) Hashmap.get(s)+" ";
    }
    return morse;
}

对于另一个，请使用此方法而不是get（）：

效率方面，我建议使用并行阵列结构。
我做了这些方法的演示，我不是一个效率向导，所以嵌套循环在这里可能不理想，或者我可能有一些其他缺陷

下面是示例类：

public class MorseTranslator {
private char[] alpha = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
        'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
        'X', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
        ' ' };//Changed this to char to save some memory and to help my methods :3

private String[] morse = { ".-", "-...", "-.-.", "-..", ".", "..-.", "--.",
        "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.",
        "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--",
        "--..", ".----", "..---", "...--", "....-", ".....", "-....",
        "--...", "---..", "----.", "-----", "|" };

private String toMorse(String text) {
    char[] characters = text.toUpperCase().toCharArray();
    StringBuilder morseString = new StringBuilder();
    for (char c : characters) {
        for (int i = 0; i < alpha.length; i++) {
            if (alpha[i] == c) {
                morseString.append(morse[i]+" ");
                break; 
            }
        }
    }
    return morseString.toString();
}

private  String fromMorse(String text){
    String[] strings = text.split(" ");
    StringBuilder translated = new StringBuilder();
    for(String s : strings){
        for(int i=0; i<morse.length; i++){
            if(morse[i].equals(s)){
                translated.append(alpha[i]);
                break;
            }
        }
    }
    return translated.toString();
}

public MorseTranslator(){
    String input = "Hello there";
    String morse = toMorse(input);
    String translated = fromMorse(morse);
    System.out.println("Input: "+input);
    System.out.println("Morse: "+morse);
    System.out.println("Back From morse: "+translated);
}
}

公共类MorsetTranslator{
私有字符[]alpha={A'，B'，C'，D'，E'，F'，G'，H'，I'，J'，
‘K’、‘L’、‘M’、‘N’、‘O’、‘P’、‘Q’、‘R’、‘S’、‘T’、‘U’、‘V’、‘W’，
“X”、“y”、“z”、“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”、“9”、“0”，
''}；//将其更改为char以节省一些内存并帮助我的方法：3
私有字符串[]morse={“-”，“-…”，“-.-”，“-…，”，“-.-”，“-.-”，“-”，
"....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.",
"--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--",
"--..", ".----", "..---", "...--", "....-", ".....", "-....",
"--...", "---..", "----.", "-----", "|" };
私有字符串toMorse（字符串文本）{
char[]characters=text.toUpperCase（）.toCharArray（）；
StringBuilder morseString=新建StringBuilder（）；
for（字符c：字符）{
for（int i=0；ipublic static Object getKeyFromValue(Map hm, Object value) {
    for (Object o : hm.keySet()) {
      if (hm.get(o).equals(value)) {
        return o;
      }
    }
    return null;
}

public class MorseTranslator {
private char[] alpha = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
        'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
        'X', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
        ' ' };//Changed this to char to save some memory and to help my methods :3

private String[] morse = { ".-", "-...", "-.-.", "-..", ".", "..-.", "--.",
        "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.",
        "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--",
        "--..", ".----", "..---", "...--", "....-", ".....", "-....",
        "--...", "---..", "----.", "-----", "|" };

private String toMorse(String text) {
    char[] characters = text.toUpperCase().toCharArray();
    StringBuilder morseString = new StringBuilder();
    for (char c : characters) {
        for (int i = 0; i < alpha.length; i++) {
            if (alpha[i] == c) {
                morseString.append(morse[i]+" ");
                break; 
            }
        }
    }
    return morseString.toString();
}

private  String fromMorse(String text){
    String[] strings = text.split(" ");
    StringBuilder translated = new StringBuilder();
    for(String s : strings){
        for(int i=0; i<morse.length; i++){
            if(morse[i].equals(s)){
                translated.append(alpha[i]);
                break;
            }
        }
    }
    return translated.toString();
}

public MorseTranslator(){
    String input = "Hello there";
    String morse = toMorse(input);
    String translated = fromMorse(morse);
    System.out.println("Input: "+input);
    System.out.println("Morse: "+morse);
    System.out.println("Back From morse: "+translated);
}
}

static class MorseMapping {
    char character;
    String morseCode;
    MorseMapping(char ch, String mc) {
        character = ch;
        morseCode = mc;
    }
}

static MorseMapping[] mappings = new MorseMapping[] {
    new MorseMapping('A', '.-'),
    \\ etc.
}

static Map<String,Character> charToMorseMap;
static Map<Character,String> morseToCharMap;

private static void addPair(String morse, char ch) {
    charToMorseMap.put(ch, morse);
    morseToCharMap.put(morse, ch);
}

static {
    charToMorseMap = new HashMap<>();
    MorseToCharMap = new HashMap<>();
    // add all the characters
}

public class EnglishMorseLetter {

  private String englishLetter;
  private String morseLetter;

public MorseLetter(String english, String morse){
    this.englishLetter = english;
    this.morseLetter = morse;
}

public String getEnglishLetter() {
    return englishLetter;
}
public void setEnglishLetter(String englishLetter) {
    this.englishLetter = englishLetter;
}
public String getMorseLetter() {
    return morseLetter;
}
public void setMorseLetter(String morseLetter) {        
    this.morseLetter = morseLetter;
}

public class Dictionary {

    private static List<MorseLetter> dictionary = new ArrayList<MorseLetter>();

    static {
        dictionary.add(new MorseLetter("", ""));
        dictionary.add(new MorseLetter("A", ".-"));
        dictionary.add(new MorseLetter("B", "-..."));
        dictionary.add(new MorseLetter("C", "-.-."));
        dictionary.add(new MorseLetter("D", "-.."));
        dictionary.add(new MorseLetter("E", "."));
        dictionary.add(new MorseLetter("F", "..-."));
        dictionary.add(new MorseLetter("G", "--."));
        dictionary.add(new MorseLetter("H", "...."));
        dictionary.add(new MorseLetter("I", ".."));
        dictionary.add(new MorseLetter("J", ".---"));
        dictionary.add(new MorseLetter("K", "-.-"));
        dictionary.add(new MorseLetter("L", ".-.."));
        dictionary.add(new MorseLetter("M", "--"));
        dictionary.add(new MorseLetter("N", "-."));
        dictionary.add(new MorseLetter("O", "---"));
        dictionary.add(new MorseLetter("P", ".--."));
        dictionary.add(new MorseLetter("Q", "--.-"));
        dictionary.add(new MorseLetter("R", ".-."));
        dictionary.add(new MorseLetter("S", "..."));
        dictionary.add(new MorseLetter("T", "-"));
        dictionary.add(new MorseLetter("U", "..-"));
        dictionary.add(new MorseLetter("V", "...-"));
        dictionary.add(new MorseLetter("W", ".--"));
        dictionary.add(new MorseLetter("X", "-..-"));
        dictionary.add(new MorseLetter("y", "-.--"));
        dictionary.add(new MorseLetter("z", "--.."));
        dictionary.add(new MorseLetter("1", ".----"));
        dictionary.add(new MorseLetter("2", "..---"));
        dictionary.add(new MorseLetter("3", "...--"));
        dictionary.add(new MorseLetter("4", "....-"));
        dictionary.add(new MorseLetter("5", "....."));
        dictionary.add(new MorseLetter("6", "-...."));
        dictionary.add(new MorseLetter("7", "--..."));
        dictionary.add(new MorseLetter("8", "---.."));
        dictionary.add(new MorseLetter("9", "----."));
        dictionary.add(new MorseLetter("0", "-----"));
        dictionary.add(new MorseLetter(" ", "|"));
    }


    public static MorseLetter english2Morse(MorseLetter letter){
        for(MorseLetter tempLetter : dictionary){
            if(letter.getEnglishLetter().equalsIgnoreCase(tempLetter.getEnglishLetter())){
                letter.setMorseLetter(tempLetter.getMorseLetter());
                break;
            }
        }

        return letter;

    }


    public static MorseLetter morse2English(MorseLetter letter){
        for(MorseLetter tempLetter : dictionary){
            if(letter.getMorseLetter().equalsIgnoreCase(tempLetter.getMorseLetter())){
                letter.setEnglishLetter(tempLetter.getEnglishLetter());
                break;
            }
        }

        return letter;

    }

}

public class EnglishMorseWord{

    private List<EnglishMorseLetter> word;

    public String getEnglishWord(){
        //...you combine your word property into english word
    }

    public void setEnglishWord(String englishWord){
        //...you parse your word and fill word property by using Dictionary
    }

    public String getMorseWord(){
        //...you combine your word property into morse word

    }

}

public enum MorseCode {
    A('A', ".-"),
    B('B', "-..."),
    C('C', "-.-."),
    // ...
    D8('8', "---.."),
    D9('9', "----."),
    D0('0', "-----");

    private static final Map<String, MorseCode> FromCode = new HashMap<>(MorseCode.values().length);
    private static final Map<Character, MorseCode> FromChar = new HashMap<>(MorseCode.values().length);
    static {
        for (MorseCode value : values()) {
            FromCode.put(value.toCode(), value);
            FromChar.put(value.toChar(), value);
        }
    }

    public static MorseCode fromCode(String code) {
        return FromCode.get(code);
    }

    public static MorseCode fromChar(Character character) {
        return FromChar.get(character);
    }

    private final String Code;
    private final Character Character;
    private MorseCode(Character character, String code) {
        Code = code;
        Character = character;
    }

    public char toChar() {
        return Character;
    }

    public String toCode() {
        return Code;
    }
}