Coincidència de caràcters d'una cadena de control amb paraules de matriu

Filtrat i agrupació d'elements de matriu basats en la concordança de cadenes

Solució basada en Java que utilitza bucles imbricats i funcions modulars

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();
    }
}

Solució optimitzada mitjançant fluxos a Java

Solució Java 8+ que aprofita els fluxos per a la llegibilitat i el rendiment

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);
            }
        }
    }
}

Test unitari per a ambdues solucions

Prova basada en JUnit per validar sortides en diferents escenaris

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());
    }
}

Preguntes més freqüents sobre la concordança de cadenes i els bucles imbricats

1. Quina és la finalitat del toCharArray() mètode?
2. El toCharArray() El mètode converteix una cadena en una matriu de caràcters, permetent la iteració sobre cada caràcter per al seu processament.
3. Com funciona el removeDuplicates() funcionen les funcions?
4. El removeDuplicates() La funció crea una cadena nova afegint només caràcters únics de la cadena d'entrada, garantint que no es repeteixi el processament.
5. Per què és startsWith() preferiu la comprovació manual dels caràcters?
6. startsWith() simplifica el codi verificant directament si una cadena comença amb un prefix especificat, fent-la menys propensa a errors.
7. Els fluxos poden gestionar grans conjunts de dades de manera eficient?
8. Sí, els fluxos de Java, especialment amb parallelStream(), pot processar grans conjunts de dades de manera eficient aprofitant el càlcul paral·lel.
9. Quin és l'avantatge d'utilitzar Collectors.joining() per a la sortida?
10. Collectors.joining() agrega elements d'un flux en una única cadena amb delimitadors opcionals, millorant la llegibilitat i el format de sortida.
11. Com poden millorar la fiabilitat les proves unitàries?
12. Les proves unitàries garanteixen cada funció, com ara print(), funciona correctament en diversos escenaris, reduint els errors en la producció.
13. Com ho fa hash-based searching millorar el rendiment?
14. Mitjançant la preindexació de dades en un mapa hash, es poden trobar coincidències en temps constant, fent que el procés sigui més ràpid per a matrius grans.
15. Què és la comparació de cadenes sensible a la configuració regional?
16. Assegura comparacions precises de cadenes en diferents idiomes o codificacions mitjançant eines com Java Collator.
17. Es pot integrar aquest script amb aplicacions frontals?
18. Sí, la lògica es pot adaptar per utilitzar-la en JavaScript o marcs com React per crear sortides interactives i dinàmiques.
19. Quin és l'avantatge de modular el codi?
20. Descompondre el codi en mètodes reutilitzables com removeDuplicates() i matchFirstWithLetter() facilita el seu manteniment i ampliació.

Consideracions finals sobre la concordança eficient de cordes

Per resoldre el problema de fer coincidir caràcters de cadena de control amb paraules matriu, es van destacar tècniques clau com la deduplicació i l'agrupació. Això garanteix resultats precisos i un maneig eficient de grans conjunts de dades. Aquestes solucions són essencials per a aplicacions del món real, com ara els motors de cerca o la categorització de dades.

Els enfocaments de programació modular, demostrats mitjançant mètodes reutilitzables, permeten un manteniment i escalabilitat més fàcils. Tant si s'apliquen a petits projectes com a sistemes a gran escala, aquests conceptes segueixen sent fonamentals. Aprofitant les potents ordres de Java, els desenvolupadors poden resoldre reptes de concordança de cadenes similars de manera eficaç i innovadora. 🧩