Java 从具有最大长度且不应重复字符的字符串中找出子字符串

我想从字符串s=characteristic中查找子字符串。 要求是子字符串不应包含重复字符，并且子字符串应具有最大长度。如何在核心java中实现这一点？ 请帮助我，因为我是java新手。

希望这对我有所帮助：

   import java.util.HashSet;
   import java.util.Scanner;
   import java.util.Set;

   public class MyLongestSubstr {

   static Set<String> SubStringList = new HashSet<String>();
   static int Size = 0;

    public static  Set<String> getLongestSubstr(String input){
    SubStringList.clear();
    Size = 0;
    boolean[] flag = new boolean[256];
    int j = 0;
    char[] inputCharArr = input.toCharArray();
    for (int i = 0; i < inputCharArr.length; i++) {
        char c = inputCharArr[i];
        if (flag[c]) {
            extractSubString(inputCharArr,j,i);
            for (int k = j; k < i; k++) {
                if (inputCharArr[k] == c) {
                    j = k + 1;
                    break;
                }
                flag[inputCharArr[k]] = false;
            }  
        } else {
            flag[c] = true;
        }
    }
    extractSubString(inputCharArr,j,inputCharArr.length);
    return SubStringList;
}

private static String extractSubString(char[] inputArr, int start, int end){

    StringBuilder sb = new StringBuilder();
    for(int i=start;i<end;i++){
        sb.append(inputArr[i]);
    }
    String subStr = sb.toString();
    if(subStr.length() > Size){
        Size = subStr.length();
        SubStringList.clear();
        SubStringList.add(subStr);
    } else if(subStr.length() == Size){
        SubStringList.add(subStr);
    }

    return sb.toString();
}

public static void main(String a[]){
    Scanner sc = new Scanner(System.in);
    String str = sc.next();
    System.out.println(getLongestSubstr(str));

}
}  

此解决方案打印出具有最大长度且无重复字符的此类可能的子字符串

试试这个：-

/**
 * Method to get List of all possible non-repetitive String from input String
 */
public ArrayList<String> getUniqueSubstring(String input) {
    ArrayList<String> matchingString = new ArrayList<String>();
    for (int i = 0; i < input.length(); i++) {
        String s = String.valueOf(input.charAt(i));
        for (int j = i + 1; j < input.length(); j++)
            if (!s.contains(String.valueOf(input.charAt(j))))
                s += String.valueOf(input.charAt(j));
            else
                break;
        matchingString.add(s);
        if (s.length() == input.length())
            break;
    }

    return matchingString;
}

/**
 * Method to get longest String out of List
 */


public String getLongestString(List<String> list) {
      int maxLength = 0;
      String longestString = null;
      for (String s : list) {
          if (s.length() > maxLength) {
              maxLength = s.length();
              longestString = s;
          }
      }
      return longestString;
  }

/**
 * Main method to test & print the longest string
 */
public static void main(String[] args) {
    StringPattern s = new StringPattern();
    System.out.println(s.getLongestString(s.getUniqueSubstring("CHARACTERSTIC")));
}

产出：-演员

---

PS:-请尝试自己创建逻辑，如果您被困在某个地方，请在这里寻求帮助，而不是现成的代码。如果您是新手，请从Oracle文档开始学习，希望这对您有所帮助。

您可能希望将原始字符串中的每个字符附加到另一个字符串或StringBuilder中，直到附加新字符串中已有的字符为止。一旦到达原始字符串的末尾或出现重复字符，请检查新字符串是否最长，如果最长，请保留它

样本：

public static void main(String[] args) throws Exception {
    String s = "CHARACTERSTIC";
    StringBuilder sb = new StringBuilder();

    String maxString = "";
    int maxStringLength = 0;
    int index = 0;
    while (index < s.length()) {
        String c = String.valueOf(s.charAt(index));
        if (sb.indexOf(c) == -1) {
            sb.append(c);
            index++; // Go to the next character
        } 

        // Check if we're at the end of the string of if the next character is duplicate
        if (index == s.length() || sb.indexOf(String.valueOf(s.charAt(index))) > -1) {
            System.out.println("Possible substring: " + sb);

            // Have to check the last substring
            if (sb.length() > maxStringLength) {
                maxString = sb.toString();
                maxStringLength = maxString.length();
                sb.setLength(0);
            }
        }
    }

    System.out.println("Max String: " + maxString);
    System.out.println("Max Length: " + maxStringLength);
}

---

这对@Shar1er80代码进行了修复，该代码适用于类似abcan的字符串，其中最大字符串可能是bcan：

public String getMaxSubstring(String s) {
    StringBuilder currentString = new StringBuilder();
    String maxString = "";
    int index = 0;
    while(index < s.length()) {
            if(currentString.indexOf(String.valueOf(s.toCharArray()[index])) == -1) {
                currentString.append(s.toCharArray()[index]);

            }else {
                // this will take care of already skipped substrings
                String ns = currentString.substring(currentString.indexOf(String.valueOf(s.toCharArray()[index]))+1) + String.valueOf(s.toCharArray()[index]);
                currentString = new StringBuilder(ns);
                currentString.setLength(ns.length());
            }               
            if(currentString.length() > maxString.length()) {
                maxString = currentString.toString();
            }               
            index++;
    }        
    return maxString;
}

---

java新手？没问题，试试伪代码，我们会帮你用java翻译

public String getMaxSubstring(String s) {
    StringBuilder currentString = new StringBuilder();
    String maxString = "";
    int index = 0;
    while(index < s.length()) {
            if(currentString.indexOf(String.valueOf(s.toCharArray()[index])) == -1) {
                currentString.append(s.toCharArray()[index]);

            }else {
                // this will take care of already skipped substrings
                String ns = currentString.substring(currentString.indexOf(String.valueOf(s.toCharArray()[index]))+1) + String.valueOf(s.toCharArray()[index]);
                currentString = new StringBuilder(ns);
                currentString.setLength(ns.length());
            }               
            if(currentString.length() > maxString.length()) {
                maxString = currentString.toString();
            }               
            index++;
    }        
    return maxString;
}