Khớp các ký tự từ chuỗi điều khiển với các từ mảng

Lọc và nhóm các phần tử mảng dựa trên kết hợp chuỗi

Giải pháp dựa trên Java sử dụng các vòng lặp lồng nhau và các hàm mô-đun

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

Giải pháp tối ưu hóa sử dụng luồng trong Java

Giải pháp Java 8+ tận dụng các luồng để có khả năng đọc và hiệu suất

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

Kiểm tra đơn vị cho cả hai giải pháp

Thử nghiệm dựa trên JUnit để xác thực kết quả đầu ra trong các tình huống khác nhau

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

Các câu hỏi thường gặp về So khớp chuỗi và Vòng lặp lồng nhau

1. Mục đích của việc này là gì toCharArray() phương pháp?
2. các toCharArray() phương thức chuyển đổi một chuỗi thành một mảng ký tự, cho phép lặp qua từng ký tự để xử lý.
3. Làm thế nào removeDuplicates() chức năng làm việc?
4. các removeDuplicates() hàm xây dựng một chuỗi mới bằng cách chỉ thêm các ký tự duy nhất từ ​​chuỗi đầu vào, đảm bảo không xử lý lặp lại.
5. Tại sao là startsWith() được ưu tiên hơn việc kiểm tra ký tự theo cách thủ công?
6. startsWith() đơn giản hóa mã bằng cách trực tiếp xác minh xem một chuỗi có bắt đầu bằng tiền tố được chỉ định hay không, làm cho chuỗi ít xảy ra lỗi hơn.
7. Các luồng có thể xử lý các tập dữ liệu lớn một cách hiệu quả không?
8. Có, các luồng Java, đặc biệt là với parallelStream(), có thể xử lý các tập dữ liệu lớn một cách hiệu quả bằng cách tận dụng tính toán song song.
9. Lợi ích của việc sử dụng là gì Collectors.joining() cho đầu ra?
10. Collectors.joining() tổng hợp các phần tử từ luồng thành một chuỗi duy nhất với các dấu phân cách tùy chọn, nâng cao khả năng đọc và định dạng đầu ra.
11. Làm thế nào các bài kiểm tra đơn vị có thể cải thiện độ tin cậy?
12. Kiểm tra đơn vị đảm bảo từng chức năng, như print(), hoạt động chính xác trong nhiều tình huống khác nhau, giảm lỗi trong quá trình sản xuất.
13. Làm thế nào hash-based searching cải thiện hiệu suất?
14. Bằng cách lập chỉ mục trước dữ liệu vào bản đồ băm, các kết quả khớp có thể được tìm thấy trong thời gian không đổi, giúp quá trình này nhanh hơn đối với các mảng lớn.
15. So sánh chuỗi nhạy cảm với miền địa phương là gì?
16. Nó đảm bảo so sánh chính xác các chuỗi ở các ngôn ngữ hoặc mã hóa khác nhau bằng các công cụ như Java Collator.
17. Tập lệnh này có thể được tích hợp với các ứng dụng front-end không?
18. Có, logic có thể được điều chỉnh để sử dụng trong JavaScript hoặc các khung như React để tạo đầu ra tương tác và năng động.
19. Lợi ích của việc mô-đun hóa mã là gì?
20. Chia mã thành các phương thức có thể sử dụng lại như removeDuplicates() Và matchFirstWithLetter() làm cho nó dễ dàng hơn để duy trì và mở rộng.

Suy nghĩ cuối cùng về việc so khớp chuỗi hiệu quả

Để giải quyết vấn đề khớp các ký tự chuỗi điều khiển với các từ trong mảng, các kỹ thuật chính như loại bỏ trùng lặp và nhóm đã được nêu bật. Những điều này đảm bảo kết quả chính xác và xử lý hiệu quả các tập dữ liệu lớn. Những giải pháp như vậy rất cần thiết cho các ứng dụng trong thế giới thực, chẳng hạn như công cụ tìm kiếm hoặc phân loại dữ liệu.

Các phương pháp lập trình mô-đun, được thể hiện thông qua các phương pháp có thể tái sử dụng, cho phép bảo trì và mở rộng dễ dàng hơn. Dù được áp dụng cho các dự án nhỏ hay hệ thống quy mô lớn, những khái niệm này vẫn là nền tảng. Bằng cách tận dụng các lệnh mạnh mẽ của Java, các nhà phát triển có thể giải quyết các thách thức khớp chuỗi tương tự một cách hiệu quả và sáng tạo. 🧩