Java Program for Morse Code Translator Encoder Decoder

Introduction

The morse code translator java tutorial builds a complete encoder and decoder for the famous code developed by Samuel Morse and Alfred Vail in the 1830s. Morse code was the first widely used digital communication system, predating the telephone by several decades. It is still used today in amateur radio, aviation, and as an accessibility aid for people with disabilities. This morse code translator java tutorial builds a lookup table for the 26 letters, the 10 digits, and a few common punctuation marks, then implements both the encoding and decoding directions.

Morse code is interesting from a programming perspective because it uses a variable-length encoding rather than fixed-length codes. The most common letters (E, T) have the shortest codes (a single dot or dash), while the less common letters (Q, Z) have longer codes. This is an early example of frequency-based encoding, the same principle used in modern compression algorithms like Huffman coding.

What is the Morse Code Translator?

The morse code translator is a Java program that converts text to Morse code and vice versa. The encoding direction takes a string of letters and digits and produces a string of dots, dashes, and spaces. The decoding direction takes a string of Morse code and produces the original text.

Compared to a substitution cipher, the morse code translator is an encoding, not a cipher. It does not use a key, and the output can be decoded by anyone who knows the standard Morse code table. The translator is useful as a building block for cipher systems that use Morse code as the first stage (such as the Fractionated Morse cipher).

The Morse code uses three symbols: dot, dash, and space. Letters are separated by short spaces (represented as a single space in the textual form), and words are separated by long spaces (represented as three spaces in the textual form). Within a letter, the dots and dashes are concatenated without separators.

How the Morse Code Translator Works Step by Step

Step 1: Build the Morse code lookup table. Each letter A to Z has a standard Morse code, and each digit 0 to 9 has a standard Morse code. For example, A is dot-dash, B is dash-dot-dot-dot, and 5 is five dots.

Step 2: Take the plaintext. We use HELLO WORLD as the plaintext. The translator splits the plaintext into words on whitespace, and each word into letters.

Step 3: For each letter, look up its Morse code and append it to the output. Letters within a word are separated by a single space, and words are separated by three spaces.

Step 4: Decrypt by splitting the Morse code into tokens on whitespace. Three consecutive spaces indicate a word boundary, and a single space indicates a letter boundary within a word.

Step 5: For each Morse code token, look up the corresponding letter in the inverse table and append it to the output.

Java Program for Morse Code Translator

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

public class MorseCodeTranslator {

    private static final Map<Character, String> TEXT_TO_MORSE = new HashMap<>();
    private static final Map<String, Character> MORSE_TO_TEXT = new HashMap<>();

    static {
        String[] letters = {
            ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....",
            "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.",
            "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-",
            "-.--", "--.."
        };
        String[] digits = {
            "-----", ".----", "..---", "...--", "....-",
            ".....", "-....", "--...", "---..", "----."
        };
        for (int i = 0; i < 26; i++) {
            char c = (char) ('A' + i);
            TEXT_TO_MORSE.put(c, letters[i]);
            MORSE_TO_TEXT.put(letters[i], c);
        }
        for (int i = 0; i < 10; i++) {
            char c = (char) ('0' + i);
            TEXT_TO_MORSE.put(c, digits[i]);
            MORSE_TO_TEXT.put(digits[i], c);
        }
    }

    public static String encode(String text) {
        StringBuilder sb = new StringBuilder();
        String[] words = text.toUpperCase().split(" ");
        for (int w = 0; w < words.length; w++) {
            if (w > 0) sb.append(" / ");     // word separator
            String word = words[w];
            for (int i = 0; i < word.length(); i++) {
                char ch = word.charAt(i);
                String morse = TEXT_TO_MORSE.get(ch);
                if (morse != null) {
                    sb.append(morse);
                    if (i < word.length() - 1) sb.append(" ");
                }
            }
        }
        return sb.toString();
    }

    public static String decode(String morse) {
        StringBuilder sb = new StringBuilder();
        String[] words = morse.split(" / ");
        for (int w = 0; w < words.length; w++) {
            if (w > 0) sb.append(" ");
            String[] letters = words[w].trim().split("\s+");
            for (String letter : letters) {
                Character ch = MORSE_TO_TEXT.get(letter);
                if (ch != null) sb.append(ch);
            }
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        String plain = "HELLO WORLD";
        String morse = encode(plain);
        String back = decode(morse);
        System.out.println("Plain: " + plain);
        System.out.println("Morse: " + morse);
        System.out.println("Back : " + back);
    }
}

Code Explanation Line by Line

The static initializer builds the two lookup tables. The letters array holds the standard Morse codes for the 26 letters A to Z. The digits array holds the standard Morse codes for the 10 digits 0 to 9. Both arrays are loaded into the TEXT_TO_MORSE and MORSE_TO_TEXT maps in the same loop, which is the standard pattern for building an inverse map.

The encode method uppercases the input and splits it into words on whitespace. For each word, it splits the word into letters, looks up each letter in TEXT_TO_MORSE, and appends the Morse code to the output. Letters within a word are separated by a single space, and words are separated by the three-character sequence slash-space-slash surrounded by spaces, which is a common textual representation of the Morse word separator.

The decode method splits the Morse code on the word separator and then splits each word on whitespace to get the individual Morse codes. Each Morse code is looked up in MORSE_TO_TEXT, and the resulting letter is appended to the output. The split uses the regular expression backslash-s-plus to handle multiple consecutive whitespace characters gracefully.

The main method demonstrates a round trip. The plaintext HELLO WORLD is encoded to a Morse code string, and the decoded output matches the original plaintext. The Morse code uses slashes as word separators, which is a common textual convention.

Sample Input and Output

Plain: HELLO WORLD
Morse: .... . .-.. .-.. --- / .-- --- .-. .-.. -..
Back : HELLO WORLD

The plaintext HELLO WORLD is encoded to the Morse code string. Each letter is converted to its standard Morse code, letters within a word are separated by spaces, and words are separated by the slash character. The decoded output matches the original plaintext exactly.

Common Mistakes to Avoid

First, using an inconsistent word separator. The textual representation of Morse code uses several conventions, including three spaces, the slash character, and the backslash character. Pick one convention and use it consistently in both encode and decode.

Second, not handling lowercase input. The TEXT_TO_MORSE map uses uppercase keys, so lowercase input would produce null lookups. Always uppercase the input in encode.

Third, splitting on a single space instead of one or more spaces. The decode method uses the regular expression backslash-s-plus, which handles multiple consecutive whitespace characters gracefully. Splitting on a single space would produce empty tokens when the input has multiple consecutive spaces.

Fourth, forgetting to handle digits and punctuation. The standard Morse code includes codes for the digits 0 to 9 and a few common punctuation marks. Including these in the lookup table makes the translator more useful for real-world input.

Real-World Applications

Morse code is still used in amateur radio, where it is one of the simplest and most reliable communication modes. The narrow bandwidth of Morse code means it can be decoded by ear even in noisy conditions where voice communication would be impossible.

In aviation, Morse code is used to identify navigational beacons. Each beacon transmits a two or three letter Morse code identifier, which the pilot can hear over the radio and use to verify the beacon identity.

In accessibility, Morse code is used as an input method for people with limited mobility. A single switch can be used to enter Morse code, which is then translated to text by software. This is the same application demonstrated by this tutorial, and many modern accessibility tools still support Morse code input.

In modern systems, the variable-length encoding principle used by Morse code is the same principle used by compression algorithms like Huffman coding. The most common symbols get the shortest codes, which minimizes the total encoded length. Studying Morse code is the fastest way to understand the variable-length encoding principle.

In capture the flag events, Morse code is sometimes used as a puzzle layer. The hint is usually a string of dots, dashes, and spaces, which the solver must decode to recover the plaintext. The decode method shown in this tutorial is exactly the tool needed to solve such puzzles.

The Morse code translator is also a useful demonstration of the principle of lookup tables. The encode and decode methods are essentially table lookups, which is the simplest and fastest way to implement a code with a fixed mapping. The same pattern is used in URL encoding, HTML entity encoding, and Base64 encoding.

Conclusion

The Morse code translator encodes text to Morse code and decodes Morse code back to text. We built the lookup table for the 26 letters and 10 digits, encoded by looking up each letter, and decoded by looking up each Morse code in the inverse table. Next you should study the Fractionated Morse cipher (which uses Morse code as the first stage of a cipher), the Baudot code (a fixed-length telegraphy code that predates ASCII), and the ASCII code (the modern fixed-length encoding for text).