Combinando caracteres de uma string de controle com palavras de array

Filtrando e agrupando elementos da matriz com base na correspondência de strings

Solução baseada em Java usando loops aninhados e funções modulares

public class Main {
    public static void main(String[] args) {
        String[] array = {"reference", "class", "method", "type", "constructor", "recursive"};
        String keyWord = "structure";
        print(array, keyWord);
    }

    // Function to filter and print matching results
    static void print(String[] array, String keyWord) {
        String filteredKeyWord = removeDuplicates(keyWord.toLowerCase());
        for (char c : filteredKeyWord.toCharArray()) {
            StringBuilder matches = new StringBuilder();
            for (String word : array) {
                if (word.charAt(0) == c) {
                    if (matches.length() > 0) {
                        matches.append(", ");
                    }
                    matches.append(word);
                }
            }
            if (matches.length() > 0) {
                System.out.println(c + ": " + matches);
            }
        }
    }

    // Helper function to remove duplicate characters from a string
    static String removeDuplicates(String str) {
        StringBuilder result = new StringBuilder();
        for (char c : str.toCharArray()) {
            if (result.indexOf(String.valueOf(c)) == -1) {
                result.append(c);
            }
        }
        return result.toString();
    }
}

Solução otimizada usando Streams em Java

Solução Java 8+ aproveitando fluxos para legibilidade e desempenho

import java.util.*;
import java.util.stream.*;

public class Main {
    public static void main(String[] args) {
        String[] array = {"reference", "class", "method", "type", "constructor", "recursive"};
        String keyWord = "structure";
        printWithStreams(array, keyWord);
    }

    static void printWithStreams(String[] array, String keyWord) {
        String filteredKeyWord = keyWord.toLowerCase().chars()
                .distinct()
                .mapToObj(c -> (char) c)
                .map(String::valueOf)
                .collect(Collectors.joining());

        for (char c : filteredKeyWord.toCharArray()) {
            String matches = Arrays.stream(array)
                    .filter(word -> word.startsWith(String.valueOf(c)))
                    .collect(Collectors.joining(", "));

            if (!matches.isEmpty()) {
                System.out.println(c + ": " + matches);
            }
        }
    }
}

Teste de unidade para ambas as soluções

Teste baseado em JUnit para validar resultados em diferentes cenários

import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class MainTest {
    @Test
    void testPrint() {
        String[] array = {"reference", "class", "method", "type", "constructor", "recursive"};
        String keyWord = "structure";
        ByteArrayOutputStream outContent = new ByteArrayOutputStream();
        System.setOut(new PrintStream(outContent));

        Main.print(array, keyWord);
        String expectedOutput = "t: type\nr: reference, recursive\nc: class, constructor\n";
        assertEquals(expectedOutput, outContent.toString());
    }

    @Test
    void testPrintWithStreams() {
        String[] array = {"reference", "class", "method", "type", "constructor", "recursive"};
        String keyWord = "structure";
        ByteArrayOutputStream outContent = new ByteArrayOutputStream();
        System.setOut(new PrintStream(outContent));

        Main.printWithStreams(array, keyWord);
        String expectedOutput = "t: type\nr: reference, recursive\nc: class, constructor\n";
        assertEquals(expectedOutput, outContent.toString());
    }
}

Perguntas frequentes sobre correspondência de strings e loops aninhados

1. Qual é o propósito do toCharArray() método?
2. O toCharArray() O método converte uma string em uma matriz de caracteres, permitindo a iteração de cada caractere para processamento.
3. Como é que removeDuplicates() função funciona?
4. O removeDuplicates() A função cria uma nova string anexando apenas caracteres exclusivos da string de entrada, garantindo nenhum processamento repetido.
5. Por que é startsWith() preferido em vez de verificar manualmente os caracteres?
6. startsWith() simplifica o código verificando diretamente se uma string começa com um prefixo especificado, tornando-a menos propensa a erros.
7. Os fluxos podem lidar com grandes conjuntos de dados com eficiência?
8. Sim, fluxos Java, especialmente com parallelStream(), pode processar grandes conjuntos de dados com eficiência, aproveitando a computação paralela.
9. Qual é a vantagem de usar Collectors.joining() para saída?
10. Collectors.joining() agrega elementos de um fluxo em uma única string com delimitadores opcionais, melhorando a legibilidade e a formatação de saída.
11. Como os testes unitários podem melhorar a confiabilidade?
12. Os testes unitários garantem cada função, como print(), funciona corretamente em vários cenários, reduzindo bugs na produção.
13. Como é que hash-based searching melhorar o desempenho?
14. Ao pré-indexar os dados em um mapa hash, as correspondências podem ser encontradas em tempo constante, tornando o processo mais rápido para grandes arrays.
15. O que é comparação de strings sensíveis à localidade?
16. Ele garante comparações precisas para strings em diferentes linguagens ou codificações usando ferramentas como Java Collator.
17. Este script pode ser integrado a aplicativos front-end?
18. Sim, a lógica pode ser adaptada para uso em JavaScript ou frameworks como React para criar saídas interativas e dinâmicas.
19. Qual é a vantagem de modularizar o código?
20. Dividir o código em métodos reutilizáveis ​​como removeDuplicates() e matchFirstWithLetter() torna mais fácil manter e expandir.

Considerações finais sobre correspondência eficiente de strings

Ao resolver o problema de combinar caracteres de string de controle com palavras de array, técnicas importantes como desduplicação e agrupamento foram destacadas. Isso garante resultados precisos e manuseio eficiente de grandes conjuntos de dados. Essas soluções são essenciais para aplicações do mundo real, como motores de busca ou categorização de dados.

Abordagens de programação modular, demonstradas através de métodos reutilizáveis, permitem manutenção e escalabilidade mais fáceis. Quer sejam aplicados a pequenos projetos ou sistemas de grande escala, estes conceitos permanecem fundamentais. Ao aproveitar os comandos poderosos do Java, os desenvolvedores podem resolver desafios semelhantes de correspondência de strings de maneira eficaz e inovadora. 🧩