Matcha tecken från en kontrollsträng till arrayord

Filtrera och gruppera matriselement baserat på strängmatchning

Java-baserad lösning med kapslade loopar och modulära funktioner

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

Optimerad lösning med strömmar i Java

Java 8+-lösning som utnyttjar strömmar för läsbarhet och prestanda

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

Enhetstest för båda lösningarna

JUnit-baserat test för att validera utdata i olika scenarier

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

Vanliga frågor om strängmatchning och kapslade slingor

1. Vad är syftet med toCharArray() metod?
2. De toCharArray() metod konverterar en sträng till en teckenuppsättning, vilket möjliggör iteration över varje tecken för bearbetning.
3. Hur fungerar removeDuplicates() fungerar funktionen?
4. De removeDuplicates() funktionen bygger en ny sträng genom att endast lägga till unika tecken från inmatningssträngen, vilket säkerställer ingen upprepad bearbetning.
5. Varför är det startsWith() föredras framför manuell kontroll av tecken?
6. startsWith() förenklar koden genom att direkt verifiera om en sträng börjar med ett specificerat prefix, vilket gör den mindre felbenägen.
7. Kan strömmar hantera stora datamängder effektivt?
8. Ja, Java strömmar, speciellt med parallelStream(), kan bearbeta stora datamängder effektivt genom att utnyttja parallell beräkning.
9. Vad är fördelen med att använda Collectors.joining() för utgång?
10. Collectors.joining() aggregerar element från en ström till en enda sträng med valfria avgränsare, vilket förbättrar läsbarheten och utdataformateringen.
11. Hur kan enhetstester förbättra tillförlitligheten?
12. Enhetstest säkerställer varje funktion, som print(), fungerar korrekt under olika scenarier, vilket minskar buggar i produktionen.
13. Hur gör hash-based searching förbättra prestanda?
14. Genom att förindexera data till en hashkarta kan matchningar hittas i konstant tid, vilket gör processen snabbare för stora arrayer.
15. Vad är språkkänslig strängjämförelse?
16. Det säkerställer korrekta jämförelser för strängar på olika språk eller kodningar med hjälp av verktyg som Java Collator.
17. Kan det här skriptet integreras med front-end-applikationer?
18. Ja, logiken kan anpassas för användning i JavaScript eller ramverk som React för att skapa interaktiva och dynamiska utdata.
19. Vad är fördelen med att modularisera koden?
20. Dela upp koden i återanvändbara metoder som removeDuplicates() och matchFirstWithLetter() gör det lättare att underhålla och bygga ut.

Sista tankar om effektiv strängmatchning

För att lösa problemet med att matcha kontrollsträngstecken med arrayord, framhävdes nyckeltekniker som deduplicering och gruppering. Dessa säkerställer korrekta resultat och effektiv hantering av stora datamängder. Sådana lösningar är väsentliga för tillämpningar i verkliga världen, såsom sökmotorer eller datakategorisering.

Modulära programmeringsmetoder, demonstrerade genom återanvändbara metoder, möjliggör enklare underhåll och skalbarhet. Oavsett om de tillämpas på små projekt eller storskaliga system, förblir dessa koncept grundläggande. Genom att utnyttja Javas kraftfulla kommandon kan utvecklare lösa liknande strängmatchningsutmaningar effektivt och innovativt. 🧩