Memadankan Aksara daripada Rentetan Kawalan kepada Kata Susunan

Penapisan dan Pengumpulan Elemen Tatasusunan Berdasarkan Padanan Rentetan

Penyelesaian berasaskan Java menggunakan gelung bersarang dan fungsi modular

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

Penyelesaian Dioptimumkan Menggunakan Strim dalam Java

Penyelesaian Java 8+ memanfaatkan aliran untuk kebolehbacaan dan prestasi

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

Ujian Unit untuk Kedua-dua Penyelesaian

Ujian berasaskan JUnit untuk mengesahkan output dalam senario yang berbeza

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

Soalan Lazim tentang Padanan Rentetan dan Gelung Bersarang

1. Apakah tujuan toCharArray() kaedah?
2. The toCharArray() kaedah menukar rentetan kepada tatasusunan aksara, membolehkan lelaran ke atas setiap aksara untuk diproses.
3. Bagaimana caranya removeDuplicates() kerja fungsi?
4. The removeDuplicates() fungsi membina rentetan baharu dengan menambahkan hanya aksara unik daripada rentetan input, memastikan tiada pemprosesan berulang.
5. kenapa startsWith() lebih suka daripada menyemak aksara secara manual?
6. startsWith() memudahkan kod dengan mengesahkan secara langsung jika rentetan bermula dengan awalan tertentu, menjadikannya kurang terdedah kepada ralat.
7. Bolehkah strim mengendalikan set data yang besar dengan cekap?
8. Ya, aliran Java, terutamanya dengan parallelStream(), boleh memproses set data yang besar dengan cekap dengan memanfaatkan pengiraan selari.
9. Apakah kelebihan menggunakan Collectors.joining() untuk keluaran?
10. Collectors.joining() mengagregatkan elemen daripada aliran menjadi satu rentetan dengan pembatas pilihan, meningkatkan kebolehbacaan dan pemformatan output.
11. Bagaimanakah ujian unit boleh meningkatkan kebolehpercayaan?
12. Ujian unit memastikan setiap fungsi, seperti print(), berfungsi dengan betul di bawah pelbagai senario, mengurangkan pepijat dalam pengeluaran.
13. Bagaimana hash-based searching meningkatkan prestasi?
14. Dengan pra-mengindeks data ke dalam peta cincang, padanan boleh ditemui dalam masa yang tetap, menjadikan proses lebih cepat untuk tatasusunan besar.
15. Apakah perbandingan rentetan sensitif setempat?
16. Ia memastikan perbandingan yang tepat untuk rentetan dalam bahasa yang berbeza atau pengekodan menggunakan alat seperti Java Collator.
17. Bolehkah skrip ini disepadukan dengan aplikasi bahagian hadapan?
18. Ya, logik boleh disesuaikan untuk digunakan dalam JavaScript atau rangka kerja seperti React untuk mencipta output interaktif dan dinamik.
19. Apakah faedah memodulasi kod?
20. Memecahkan kod kepada kaedah yang boleh digunakan semula seperti removeDuplicates() dan matchFirstWithLetter() menjadikannya lebih mudah untuk mengekalkan dan mengembangkannya.

Pemikiran Akhir tentang Padanan Rentetan yang Cekap

Dalam menyelesaikan masalah pemadanan aksara rentetan kawalan dengan perkataan tatasusunan, teknik utama seperti penyahduplikasian dan pengelompokan telah diserlahkan. Ini memastikan keputusan yang tepat dan pengendalian set data besar yang cekap. Penyelesaian sedemikian adalah penting untuk aplikasi dunia sebenar, seperti enjin carian atau pengkategorian data.

Pendekatan pengaturcaraan modular, ditunjukkan melalui kaedah boleh guna semula, membolehkan penyelenggaraan dan skalabiliti yang lebih mudah. Sama ada digunakan untuk projek kecil atau sistem berskala besar, konsep ini kekal asas. Dengan memanfaatkan arahan berkuasa Java, pembangun boleh menyelesaikan cabaran pemadanan rentetan yang serupa dengan berkesan dan inovatif. 🧩