Trying to create a string from a string array

Question

I'll preface this question with the fact that I'm only 1 month into learning programming, and this assignment for school has me stumped. Specifically, it's the Morse Code to English translator (and vice versa)... here's the part I'm stuck on:

/* 
*  A program that asks the user to select which they would like to do: translate 
*  from English to Morse code, or Morse code to English. The list of characters 
*  for each language is stored using arrays. The program will then perform and return
*  the translations.
*/
import java.util.Scanner;

public class MorseEnglishTranslator
{

    public static void main( String [] args )
    {
        int translateChoice = 0;                   // Variable for person's choice for direction of translation

        Scanner inputText = new Scanner( System.in );  // Create a Scanner to obtain user input
        System.out.print( "Enter 1 to translate from English to Morse code, 2 for Morse code to English: " );
        translateChoice = inputText.nextInt();

        if (translateChoice == 1);
            {        
                System.out.print("Enter a letter, word, or phrase you would like translated: ");
            }    
        if (translateChoice == 2);
            {
                System.out.print("Enter the Morse code you would like translated, separate letters and words with a |: ");
            }
        String userStr = inputText.nextLine();

        translator( translateChoice, userStr);


    } // Closes main

    public static void translator( int translateChoice, String userStr) // Method for translating either direction
    {
        String english [] = {"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", " "};

        String s1 = String.join(" ", english);  // Assigns the contents of english array to one string

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

        String s2 = String.join("|", morse);    // Assigns the contents of morse array to one searchable string

        if (translateChoice == 1);
            {        
                String userStrLower = userStr.toLowerCase();  // In case user capitalized anything, changes everything to lowercase
                for (int allFound=0; allFound <userStrLower.length(); allFound ++)
                {
                    allFound = s1.indexOf( userStrLower );  // Variable 'allFound' to receive the search of s1 using userStrLower
                    System.out.print( allFound );
                } 
            }    
        if (translateChoice == 2);
            {
                for (int allFound=0; allFound <userStr.length(); allFound ++)
                {
                    allFound = s2.indexOf( userStr );  // Variable 'allFound' to receive the search of s2 using userStr
                    System.out.print( allFound );
                }   
            }

    } // Closes translator        
} // Closes class

Strings s1 and s2 are the two options I was contemplating using, but the s1 version tells me after New there was an expected semi-colon. The join option, which I tried as String.join vs join, says no suitable constructor vs cannot find symbol respectively.

Answer 1

I understand that you are in an intro to Java class, so feel free to ask questions, but you 1) don't need to join Strings and 2) indexOf is really inefficient for the purposes you need it for. A HashMap<String, String> is the perfect object for a translator.

I have made this bi-directional map class that can go back-and-forth between two String arrays. Save this into a BiMap.java file.

import java.util.HashMap;

public class BiMap {
    private HashMap<String, String> forwardMap;
    private HashMap<String, String> backwardMap;

    public BiMap(String[] from, String[] to) {
        forwardMap = new HashMap<>();
        backwardMap = new HashMap<>();

        for (int i = 0; i < from.length && i < to.length; i++) {
            forwardMap.put(from[i], to[i]);
            backwardMap.put(to[i], from[i]);
        }
    }

    public String translateForward(String key) {
        return forwardMap.get(key);
    }

    public String translateBackward(String key) {
        return backwardMap.get(key);
    }
}

And here is a sample usage of that class. Feel free to add your user-prompting back to it. Using static final modifiers is recommended for class variable constants. Then, I defined some private methods to extract out the translation logic.

It good practice to write readable and reusable methods as much as possible when learning.

public class MorseEnglishTranslator {

    private static final String[] ENGLISH = new String[]{
            "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 static final String[] MORSE = new String[]{
            ".-", "-...", "-.-.", "-..", ".", "..-.", "--.",
            "....", "..", ".---", "-.-", ".-..", "--", "-.",
            "---", ".--.", "--.-", ".-.", "...", "-", "..-",
            "...-", ".--", "-..-", "-.--", "--..", ".----",
            "..---", "...--", "....-", ".....", "-....",
            "--...", "---..", "----.", "-----", "|"};

    private static final BiMap MORSE_MAP = new BiMap(ENGLISH, MORSE);

    private static final String DELIMITER = " ";

    private static String toMorse(String s) {
        StringBuilder sb = new StringBuilder();
        String lower = s.toLowerCase();
        for (int i = 0; i < lower.length(); i++) {
            String c = String.valueOf(lower.charAt(i));
            sb.append(MORSE_MAP.translateForward(c)).append(DELIMITER);
        }
        return sb.toString();
    }

    private static String fromMorse(String s) {
        String[] split = s.split(DELIMITER);
        StringBuilder sb = new StringBuilder();
        for (String morse : split) {
            sb.append(MORSE_MAP.translateBackward(morse));
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        String sentence = "Hello World";
        String morse = toMorse(sentence);
        String translated = fromMorse(morse);

        System.out.println(sentence);
        System.out.println(morse);
        System.out.println(translated);
        System.out.println(sentence.equalsIgnoreCase(translated));

    }

}

Sample run

Hello World
.... . .-.. .-.. --- | .-- --- .-. .-.. -.. 
hello world
true