Java morse code program - the program gets stuck on input

Ok so here is the new and improved program based on everyone's input. First, the main program:

public static void main(String[] args)
{
Scanner input = new Scanner(System.in);

String WhichConversion; // 1 means EngToMorse, 2 means MorseToEng

String EngInput; // raw string input for EngToMorse
String CodeOutput; // Output from EngToMorse
char[] EngInputArray; // EngInput converted to char array

String CodeInput; // raw code input for MorseToEng
String EngOutput; // Output from MorseToEng

// First we identify if we are going eng - morse or vice versa
System.out.println("for Eng -> Morse, enter 1.  for Morse -> Eng, enter 2");
WhichConversion = input.next();

// English to Morse
if (WhichConversion.equals("1"))
{
   System.out.println("What is the text you would like coded?"
   + " (lowercase a-z and 0-9 with a space between words, " + "please) 
   ");

EngInput = input.nextLine(); // this line is here twice
EngInput = input.nextLine(); // to avoid nextInt/nextLine issue

// declare array after EngInput is defined
EngInputArray = new char[EngInput.length() + 1];

// Convert EngInput to EngInputArray
for (int index = 0; index < EngInput.length(); index++)
{
    EngInputArray[index] += EngInput.charAt(index);
}
System.out.print(EngInputArray);
System.out.println(" ");

convertToMorse(EngInputArray);
}
 '''

And here is the method for the conversion from English to morse code:

private static void convertToMorse(char[] EngInputArray)
{
    char[] EngArray =
    { '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' };

    String[] MorseArray =
    { ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", 
        "-.- ", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "…", "-", "..- 
        ", "...-", ".--", "-..-", "-.--", "--..", "-----", ".----", "..---", 
        "...--", "....-", ".....", "-....", "--...", "---..", "----." 
    };

int KeyIndex = 0;
int InputIndex = 0;

for (InputIndex = 0; InputIndex < EngArray.length; InputIndex++)
{
    KeyIndex = 0;
    System.out.print(" ");

    while (KeyIndex < EngArray.length & InputIndex < EngInputArray.length)
    {
        if (EngArray[KeyIndex] == EngInputArray[InputIndex])
        {
             System.out.print(MorseArray[KeyIndex] + " ");
             KeyIndex = EngArray.length;
             break;
        } else if (EngInputArray[InputIndex] == ' ')
        {
            System.out.print(" | ");
            KeyIndex = EngArray.length;
            break;
        } else if (EngInputArray[InputIndex] != ' ' & EngArray[KeyIndex] != 
            EngInputArray[InputIndex])
        {
           KeyIndex++;
        }
       }
    }
} // End EngToMorse

"... when executing the code I seem to be stuck in an input mode before the [int KeyIndex = 0;] line. ..."

Use the next method if you're parsing more than one value from the input line.
Othewise, use the nextLine method.

String WhichConversion = input.nextLine();

Then, the CharString assignment will only require one nextLine call.

I'd like to illustrate how using arithmetic on char types can simplify this code. It's not really related to the question about input.

First, the Morse code array should be static data of the class. After all, the same data will be needed to encode to Morse as decode from Morse.

public class Puppy_with_pinecone {
    
    private static final String[] MORSE_CODE =  { 
          // letters a to z (lowercase)
          "•‒", "‒•••", "‒•‒•", "‒••", "•" , "••‒•", "‒‒•", "••••", "••"
        , "•‒‒‒", "‒•‒ ", "•‒••", "‒‒", "‒•", "‒‒‒", "•‒‒•", "‒‒•‒", "•‒•"
        , "•••", "‒", "••‒", "•••‒", "•‒‒", "‒••‒", "‒•‒‒", "‒‒••"
         // digits 0 to 9      
        , "‒‒‒‒‒", "•‒‒‒‒", "••‒‒‒", "•••‒‒", "••••‒" 
        , "•••••", "‒••••", "‒‒•••", "‒‒‒••", "‒‒‒‒•"    
    };
    
    private static final char SPACE = ' ';

    public static void main(String[] args) {
    ...
}

The following works because the letters A to Z are consecutive in ASCII, as are the letters a to z and the digits 0 to 9.[1] And Unicode is based on ASCII.

The char type in Java is an integer type primitive. So, char data can be used for arithmetic.

    
    public static String toMorse (String input) {

        StringBuilder output = new StringBuilder(input.length() * 6);           
            
        for (int inpIndex = 0; inpIndex < input.length(); inpIndex++) {
            char letter = Character.toLowerCase(input.charAt(inpIndex));
            if (letter >= 'a' && letter <= 'z') {
                output.append (MORSE_CODE [letter - 'a']).append(SPACE);
            } else if (letter >= '0' && letter <= '9') {
                output.append (MORSE_CODE [letter - '0' + 26]).append (SPACE);
            }
            else if (Character.isWhitespace(letter))  {
                output.append (" | ");
            }
        }
        return output.toString();
    }  

• Returning a String is in keeping with separation of responsibilities design. Having the output handled outside the method that does the conversion makes it easier to reuse the conversion method. You might, for example, want to write the Morse code to a file, or pass it to a method that generates the sound of Morse code.

[1] Note this is not true of EBCDIC.