An object-oriented approach

This problem can also be solved with a bit of good old object orientation, decreasing code repetition and the amount of loops and ifs / strong> in order to facilitate development and have a simpler end result:

public class CacaPalavras {

    public static boolean palavraEncontrada(char[][] tabuleiro, String palavra) {

        for (int posicaoY = 0; posicaoY < tabuleiro.length; posicaoY++) {

            for (int posicaoX = 0; posicaoX < tabuleiro[posicaoY].length; posicaoX++) {

                if (tabuleiro[posicaoY][posicaoX] == palavra.charAt(0)) {

                    for(Direcao direcao: Direcao.values()) {
                        if (TabuleiroNavegavel.existePalavra(palavra, tabuleiro, direcao, 
                                posicaoY, posicaoX)) {
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }
}

I used the same logic as you proposed: scroll through the board from left to right and from top to bottom, and when you find a letter that matches the first letter of the searched word, you scroll through the board in many different directions to see if the whole word is found.

The rest of the code that makes the magic happen is below:

class TabuleiroNavegavel {
    public static boolean existePalavra(String palavra, char[][] tabuleiro, 
                    Direcao direcao, int posicaoInicialY, int posicalInicialX) {

        StringBuilder palavraEncontrada = new StringBuilder();

        NavegadorLetras letras = direcao.letras(tabuleiro, 
                                    posicaoInicialY, posicalInicialX);

        int qtdLetrasLidas = 0;

        while(letras.temProxima() && qtdLetrasLidas <= palavra.length()) {
            palavraEncontrada.append(letras.proxima());
            qtdLetrasLidas++;
        }
        return palavraEncontrada.toString().equals(palavra);
    }
}

interface NavegadorLetras {
    boolean temProxima();
    char proxima();
}

interface LetrasNavegaveis {
    NavegadorLetras navegador(final char[][] tabuleiro, 
            final int posicaoInicialY, final int posicalInicialX);
}

enum Direcao {
    LESTE(new Leste()), 
    SUDESTE(new Sudeste()),
    SUL(new Sul()),
    NORDESTE(new Nordeste());

    private LetrasNavegaveis letrasNavegaveis;

    Direcao(LetrasNavegaveis letrasNavegaveis) {
        this.letrasNavegaveis = letrasNavegaveis; 
    }
    public NavegadorLetras letras(char[][] tabuleiro, 
                            int posicaoInicialY, int posicalInicialX){
        return letrasNavegaveis.navegador(tabuleiro, posicaoInicialY, posicalInicialX);
    }
}

class Leste implements LetrasNavegaveis {

    public NavegadorLetras navegador(final char[][] tabuleiro, 
                            final int posicaoInicialY, final int posicalInicialX) {

        return new NavegadorLetras() {
            int posicaoX = posicalInicialX; 
            int posicaoY = posicaoInicialY;

            public boolean temProxima() {
                return posicaoX < tabuleiro[posicaoY].length;
            }
            public char proxima() {
                char letra = tabuleiro[posicaoY][posicaoX];
                posicaoX++;
                return letra;
            }
        };
    }
}

class Sudeste implements LetrasNavegaveis {

    public NavegadorLetras navegador(final char[][] tabuleiro, 
                            final int posicaoInicialY, final int posicalInicialX) {

        return new NavegadorLetras() {

            int posicaoY = posicaoInicialY;
            int posicaoX = posicalInicialX;

            public boolean temProxima() {
                return posicaoY >= 0 && posicaoY < tabuleiro.length
                    && posicaoX >= 0 && posicaoX < tabuleiro[posicaoY].length;
            }
            public char proxima() {
                char letra = tabuleiro[posicaoY][posicaoX];
                posicaoY++;
                posicaoX++;
                return letra;
            }
        };
    }
}

class Sul implements LetrasNavegaveis {

    public NavegadorLetras navegador(final char[][] tabuleiro, final int posicaoInicialY,
                            final int posicalInicialX) {

        return new NavegadorLetras() {
            int posicaoY = posicaoInicialY;
            int posicaoX = posicalInicialX;

            public boolean temProxima() {
                return posicaoY >= 0 && posicaoY < tabuleiro.length;
            }
            public char proxima() {
                char letra = tabuleiro[posicaoY][posicaoX];
                posicaoY++;
                return letra;
            }
        };
    }
}

class Nordeste implements LetrasNavegaveis {

    public NavegadorLetras navegador(final char[][] tabuleiro, 
                            final int posicaoInicialY, final int posicalInicialX) {

        return new NavegadorLetras() {
            int posicaoY = posicaoInicialY;
            int posicaoX = posicalInicialX;

            public boolean temProxima() {
                return posicaoY >= 0 && posicaoY < tabuleiro.length
                    && posicaoX < tabuleiro[posicaoY].length;
            }
            public char proxima() {
                char letra = tabuleiro[posicaoY][posicaoX];
                posicaoY--;
                posicaoX++;
                return letra;
            }
        };
    }
}

An example consumer code:

@Test
public void cacaPalavras() {

    char[][] tabuleiro = new char[][] { 
            {'R','X','L','X','A'},
            {'X','A','U','X','X'},
            {'R','U','I','V','A'},
            {'X','A','Z','V','X'},
            {'C','X','A','X','A'}};

    assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "RUIVA"));
    assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "RAIVA"));
    assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "LUIZA"));
    assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "CAIXA"));
    assertFalse(CacaPalavras.palavraEncontrada(tabuleiro, "INEXISTENTE"));
}

You can wrap this code up with your logic to read the board from a file and request a list of user words: -)

How to extend the solution

See that I have only implemented the most western standard of reading, so to speak: east, south, southeast, northeast.

But to implement more patterns is very simple. You do not need to enter code in the middle of a large, complex method or reprogram the program flow. Instead, you set a new reading direction in the enumeration and declare a specialized class to read in this direction.

If you want to, for example, implement the southwest direction of reading, simply declare the following class:

class Sudoeste implements LetrasNavegaveis {

    public NavegadorLetras navegador(final char[][] tabuleiro, final int posicaoInicialY,
                            final int posicalInicialX) {

        return new NavegadorLetras() {
            int posicaoY = posicaoInicialY;
            int posicaoX = posicalInicialX;

            public boolean temProxima() {
                return posicaoY < tabuleiro.length
                    && posicaoX >= 0;
            }
            public char proxima() {
                char letra = tabuleiro[posicaoY][posicaoX];
                posicaoY++;
                posicaoX--;
                return letra;
            }
        };
    }
}

And add this new reading direction in the enumeration:

SUDOESTE(new Sudoeste());

Now, in the test below, the word "Red" will be found:

@Test
public void sudoeste() {
    char[][] tabuleiro = new char[][] { 
            {' ',' ',' ',' ','R'},
            {' ',' ',' ','U',' '},
            {' ',' ','I',' ',' '},
            {' ','V',' ',' ',' '},
            {'A',' ',' ',' ',' '}};

    assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "RUIVA"));
}

And soon: -)

Conclusion

I and many of our colleagues consider this code quite simple but I understand that you may not fully understand it yet.

My suggestion, of course, is that you try to understand.

Some Java features that were used there:

• Interface
• Enumeration.
• Enumeration extension: I've added an attribute to each item in the enumeration, which is the specialized object to traverse the board in that direction.

And although I do not consider total number of lines very important, I notice that although my code works it still has fewer rows than the original question code.