Dominando a Verificação de Palíndromos em Java

Introdução

Neste laboratório, aprenderemos como verificar se uma string é um palíndromo ou não em Java. Um palíndromo é uma string que se lê da mesma forma para frente e para trás.

Usando Dois Ponteiros para Verificar Palíndromos

O primeiro método que implementaremos é a abordagem de dois ponteiros (two-pointer approach). Criaremos um método chamado isPalindrome que recebe uma string como entrada e retorna um valor booleano indicando se a string é um palíndromo ou não.

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        int start = 0;
        int end = str.length() - 1;

        while (start < end) {
            char startChar = Character.toLowerCase(str.charAt(start));
            char endChar = Character.toLowerCase(str.charAt(end));

            if (startChar != endChar) {
                return false;
            }

            start++;
            end--;
        }

        return true;
    }
}

O método isPalindrome usa dois ponteiros, start e end, que começam no início e no fim da string, respectivamente. O loop é executado até que os dois ponteiros se encontrem no meio.

Em cada iteração, comparamos os caracteres nos ponteiros start e end. Se eles não forem iguais, retornamos false. Se forem, atualizamos os ponteiros para verificar o próximo conjunto de caracteres na string.

Para testar nosso método, podemos adicionar um método main e chamar o método isPalindrome com várias strings de entrada.

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implementation of isPalindrome method
    }

    public static void main(String[] args) {
        System.out.println("Is 'racecar' a palindrome? " + isPalindrome("racecar"));
        System.out.println("Is 'hello' a palindrome? " + isPalindrome("hello"));
    }
}

Usando Recursão para Verificar Palíndromos

O próximo método que implementaremos é a abordagem recursiva. Criaremos um novo método chamado isPalindromeRecursive que recebe a string, o índice inicial e o índice final como entrada.

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        String lowercaseStr = str.toLowerCase();
        return isPalindromeRecursive(lowercaseStr, 0, lowercaseStr.length() - 1);
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        if(start >= end) {
            return true;
        }

        char startChar = Character.toLowerCase(str.charAt(start));
        char endChar = Character.toLowerCase(str.charAt(end));

        if(startChar != endChar) {
            return false;
        }

        return isPalindromeRecursive(str, start + 1, end - 1);
    }

    public static void main(String[] args) {
        // Tests for isPalindrome and isPalindromeRecursive methods
    }
}

O método isPalindromeRecursive usa recursão para verificar se a string é um palíndromo ou não. Temos dois casos base:

Se o índice start for maior ou igual ao índice end, significa que verificamos todos os caracteres na string e eles correspondem, então retornamos true.
Se os caracteres nos índices start e end não forem iguais, retornamos false.

Se nenhum dos casos base for atendido, chamamos isPalindromeRecursive novamente com os índices atualizados.

Agora podemos testar nosso método recursivo chamando-o dentro do método main.

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implementation of isPalindrome method
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        // Implementation of isPalindromeRecursive method
    }

    public static void main(String[] args) {
        System.out.println("Is 'racecar' a palindrome? " + isPalindromeRecursive("racecar", 0, 6));
        System.out.println("Is 'hello' a palindrome? " + isPalindromeRecursive("hello", 0, 4));
    }
}

Invertendo a String para Verificar Palíndromos

O último método que implementaremos é a abordagem de inversão de string. Criaremos um novo método chamado isPalindromeReverse que recebe uma string como entrada.

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implementation of isPalindrome method
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        // Implementation of isPalindromeRecursive method
    }

    public static boolean isPalindromeReverse(String str) {
        String reversed = "";

        for (int i = str.length() - 1; i >= 0; i--) {
            reversed += str.charAt(i);
        }

        return str.equalsIgnoreCase(reversed);
    }

    public static void main(String[] args) {
        // Tests for isPalindrome and isPalindromeRecursive methods
        System.out.println("Is 'racecar' a palindrome? " + isPalindromeReverse("racecar"));
        System.out.println("Is 'hello' a palindrome? " + isPalindromeReverse("hello"));
    }
}

O método isPalindromeReverse cria uma nova string chamada reversed e a preenche iterando pela string de entrada do fim para o início. Em seguida, retornamos true se as duas strings forem iguais, ignorando a capitalização.

Podemos testar o método adicionando uma chamada para isPalindromeReverse no método main.

Usando Java Streams para Verificar Palíndromos

Finalmente, usaremos a API Java Streams para verificar palíndromos. Criaremos um novo método chamado isPalindromeStream que recebe uma string como entrada.

import java.util.stream.IntStream;

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implementation of isPalindrome method
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        // Implementation of isPalindromeRecursive method
    }

    public static boolean isPalindromeReverse(String str) {
        // Implementation of isPalindromeReverse method
    }

    public static boolean isPalindromeStream(String str) {
        String lowercaseStr = str.toLowerCase();

        return IntStream.range(0, lowercaseStr.length() / 2)
                .noneMatch(i -> lowercaseStr.charAt(i) != lowercaseStr.charAt(lowercaseStr.length() - i - 1));
    }

    public static void main(String[] args) {
        // Tests for isPalindrome and isPalindromeRecursive methods
        System.out.println("Is 'racecar' a palindrome? " + isPalindromeStream("racecar"));
        System.out.println("Is 'hello' a palindrome? " + isPalindromeStream("hello"));
    }
}

O método isPalindromeStream usa a classe IntStream para gerar um intervalo de índices que podemos usar para comparar caracteres na string.

Usamos o método noneMatch para retornar true se nenhum dos caracteres violar a condição de que os caracteres i-ésimo e n-i-1-ésimo sejam iguais, onde n é o comprimento da string e i é o índice.

Podemos testar o método adicionando uma chamada para isPalindromeStream no método main.

Resumo

Neste laboratório, aprendemos como verificar se uma determinada string é um palíndromo ou não em Java. Implementamos quatro métodos diferentes para realizar esta tarefa:

Abordagem de dois ponteiros (two-pointer approach)
Abordagem recursiva (recursive approach)
Abordagem de inversão da string (reversing the string approach)
Abordagem Java Streams (Java Streams approach)

Agora que você entende esses métodos, pode usá-los para resolver problemas mais complexos!

Verificando Palíndromos em Java