Java中含分隔符的文本文件字符串递归搜索问题求助

Hey there! Let's break down this problem and fix that annoying error you're seeing. The "仅能添加字符常量" (Only char constants can be added) error almost always means you're mixing up char and String types somewhere in your code—like trying to treat a multi-character substring as a single character, or using single quotes (for chars) around a string value.

First, Let's Diagnose the Root Cause #

Here are the most common mistakes that trigger this error:

• You defined your target substring as a char instead of a String (e.g., char target = 'test';—single quotes only work for single characters)
• You're using character-specific methods (like charAt()) or comparisons (like == for chars) on a String target
• You're passing a String argument to a method parameter that expects a char

Solution: Recursive Substring Search with Proper String Handling #

Below is a working Java recursive implementation that searches for a target substring in a delimiter-separated string. It avoids the type mismatch issues and follows clean recursive logic:

public class DelimitedSubstringSearch {

    // Recursive method to search for target substring in delimiter-separated input
    public static boolean findTargetSubstring(String input, String delimiter, String target) {
        // Base case: If input is empty or null, no match exists
        if (input == null || input.isBlank()) {
            return false;
        }

        int delimiterPos = input.indexOf(delimiter);
        String currentSegment;
        String remainingInput;

        if (delimiterPos == -1) {
            // No more delimiters—this is the final segment
            currentSegment = input.trim();
            remainingInput = "";
        } else {
            // Split into current segment and the rest of the input
            currentSegment = input.substring(0, delimiterPos).trim();
            remainingInput = input.substring(delimiterPos + delimiter.length());
        }

        // Check if current segment contains the target substring
        if (currentSegment.contains(target)) {
            return true;
        }

        // Recurse on the remaining part of the string
        return findTargetSubstring(remainingInput, delimiter, target);
    }

    public static void main(String[] args) {
        // Test case
        String testString = "java,recursion,string-search,debugging";
        String delimiter = ",";
        
        System.out.println(findTargetSubstring(testString, delimiter, "recur")); // true
        System.out.println(findTargetSubstring(testString, delimiter, "python")); // false
    }
}

Key Details About This Implementation #

• Type Safety: We use String for both the target and delimiter, so no more char/string mismatches
• Recursive Logic:
  1. Split the input into the first segment (before the delimiter) and the remaining string
  2. Check if the current segment contains the target
  3. If not, recurse with the remaining part of the string
  4. Base case: When the input is empty, return false (no matches found)
• Flexibility: You can adjust the matching logic—use equals() instead of contains() if you need exact segment matches, or add .toLowerCase() to both the segment and target for case-insensitive searches.

Quick Fixes for Your Original Code #

If you want to adapt your existing code instead of using this example:

1. Replace any char declarations for your target substring with String
2. Swap character-specific checks (like charAt() comparisons) with string methods like contains(), indexOf(), or equals()
3. Make sure you're using double quotes (") for string values, not single quotes (')

内容的提问来源于stack exchange，提问作者Issajatt