在java中如何返回字符串中最长的字符序列？

下面是我最后做的事情，但我并没有找到正确的答案

示例-如果我有序列“hellloo”，那么输出将是“lll”。请告诉我怎么了

public class LongestSequenceOfChar {
    static String testcase1="hellloo";

    public static void main(String[] args) {
        LongestSequenceOfChar test = new LongestSequenceOfChar();
        String result = test.longestSequenceOfChar(testcase1);
        System.out.println(result);
    }
    public String longestSequenceOfChar(String str){
        String result="";
        for(int i=0;i<str.length();i++){
            char ch=str.charAt(i);
            for(int j=i+1;j<str.length();j++){
                char ch1=str.charAt(j);
                if(ch!=ch1){
                    continue;
                }
                result+=ch;
            }
        }
        return result;
    }
}

公共类最长的字符序列{
静态字符串testcase1=“hellloo”；
公共静态void main（字符串[]args）{
LongestSequenceOfChar测试=新的LongestSequenceOfChar（）；
字符串结果=test.longestSequenceOfChar（testcase1）；
系统输出打印项次（结果）；
}
公共字符串longestSequenceOfChar（字符串str）{
字符串结果=”；
对于（int i=0；i您现在应该有一个计数器来计算最长序列的数量。当您找到一个较长的序列时，您应该重置
result
并相应地更新计数器

但是，您可以有更好的解决方案：


有一个大小为26的数组（英文字母表的大小）。现在你在字符串上迭代，对于其中的每个
char
，你在助手数组的相应单元格中添加1
使用一个
HashMap
，它以
char
作为键，数字作为值。如果它是一个新的
char
，您只需将它与0值放在一起，如果它存在，则增加现有值

提示：使用调试器可以挽救您的生命。
1.创建HashMap..Integer-->count
1. Create a HashMap<Character,Integer>.. Integer-->count
2. Start from the beginning of your String.. For each character, check if it is already present in the hashmap
  a. If Yes, just increment the count
  b. if No, then add the character as key to the Map and set its count value to 1. 

2.从字符串的开头开始..对于每个字符，请检查其是否已存在于hashmap中
a、 如果是，只需增加计数
b、 如果否，则将字符作为键添加到贴图中，并将其计数值设置为1。
如果有三个“l”，则只需添加两个，下一步是两个“l”，并添加其中一个。然后添加一个的两个“o”也是如此。只需在跳转到下一个字母时清除结果字符串，然后将结果保存到另一个变量中，但前提是其长度更长

public String longestSequenceOfChar(String str){
    String interimresult="";
    String result="";              //final result
    for(int i=0;i<str.length();i++){
        char ch=str.charAt(i);
        interimresult += ch;       //add the letter once
        for(int j=i+1;j<str.length();j++){
            char ch1=str.charAt(j);
            if(ch!=ch1){
                break;
            }
            interimresult +=ch;
        }
        if(interimresult.length()>result.length())//store the result if it is longer 
            result = interimresult;
        interimresult = "";                   //clear to continue with the next letter
    }
    return result;
}

公共字符串longestSequenceOfChar（字符串str）{
字符串interimresult=“”；
String result=“；//最终结果
对于（int i=0；i，这里有一个解决方案：

public String longestSequenceOfChar(String str) {
    String result = "";

    for (int i = 0; i < str.length(); i++) {
        int j = i;
        while(j < str.length() && str.charAt(j) == str.charAt(i)) {
            j++;
        }

        // If this one is longer than previous, then asign it to result.
        if(j - i > result.length()) {
            result = str.substring(i, j);
        }
    }
    return result;
}

公共字符串longestSequenceOfChar（字符串str）{
字符串结果=”；
对于（int i=0；iresult.length（））{
结果=str.子串（i，j）；
}
}
返回结果；
}
试试这个

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println(maxLen(null));
        System.out.println(maxLen(""));
        System.out.println(maxLen("a"));
        System.out.println(maxLen("aa"));
        System.out.println(maxLen("abcddd"));
        System.out.println(maxLen("abcd"));
        System.out.println(maxLen("aabbba"));
    }

    public static String maxLen(String input) {
        // Avoid NPEs
        if (input == null) {
            return null;
        }
        int maxLen = 0;
        int tempLen = 0;
        char prevChar = 0;
        char c = 0;
        char repeatChar = 0;
        for (int i = 0; i < input.length(); i++) {
            c = input.charAt(i);
            if (c == prevChar) {
                tempLen++;
                if (tempLen > maxLen)
                    repeatChar = c;
            } else {
                maxLen = (tempLen > maxLen) ? tempLen : maxLen;
                prevChar = c;
                tempLen = 1;
            }
        }
        maxLen = (tempLen > maxLen) ? tempLen : maxLen;
        if (maxLen == 0 || maxLen == 1)
            return "no sequence found";
        else {
            String str = "";
            for (int i = 1; i <= maxLen; i++)
                str += String.valueOf(repeatChar);
            return str;
        }
    }
}

公共类HelloWorld{
公共静态void main（字符串[]args）{
System.out.println（maxLen（null））；
System.out.println（maxLen（“”）；
System.out.println（maxLen（“a”）；
系统输出打印LN（maxLen（“aa”））；
系统输出打印LN（maxLen（“abcddd”）；
System.out.println（maxLen（“abcd”）；
System.out.println（maxLen（“aabbba”）；
}
公共静态字符串maxLen（字符串输入）{
//避免NPE
如果（输入==null）{
返回null；
}
int maxLen=0；
int-tempLen=0；
char-prevChar=0；
字符c=0；
char repeatChar=0；
对于（int i=0；i最大值）
repeatChar=c；
}否则{
maxLen=（tempLen>maxLen）？tempLen:maxLen；
prevChar=c；
tempLen=1；
}
}
maxLen=（tempLen>maxLen）？tempLen:maxLen；
如果（maxLen==0 | | maxLen==1）
返回“未找到序列”；
否则{
字符串str=“”；
对于（int i=1；i这可以使用HashMap轻松解决。请检查以下示例代码：

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class MaximumOccuringCharUsingHashMap {
  public static void main(String[] args) {
  String test = "test samples";
  MaximumOccuringCharUsingHashMap mc = 
      new MaximumOccuringCharUsingHashMap();
  System.out.println( mc.findMaximunOccurenceCharacter(test));
}
  char findMaximunOccurenceCharacter(String input){
      Map<Character, Integer> countHash = 
          new HashMap<Character, Integer>();
      for(int i=0; i<input.length() ;i++ ){
          char currentChar = input.charAt(i);
          if(countHash.get(currentChar)==null){
              countHash.put(currentChar, 1);
          }else{
              countHash.
              put(currentChar, countHash.get(currentChar)+1);
          }
      }

      int max = Collections.max(countHash.values());

      char maxCharacter =0;
      for(Entry<Character, Integer> entry :countHash.entrySet()){
          if(entry.getValue() == max){
              maxCharacter = entry.getKey();
          }
      }
      return maxCharacter;
  }
}

import java.util.Collections；
导入java.util.HashMap；
导入java.util.Map；
导入java.util.Map.Entry；
使用HashMap的公共类最大占用计费{
公共静态void main（字符串[]args）{
String test=“测试样本”；
使用HashMap mc=
新的MaximumOccuringCharUsingHashMap（）；
System.out.println（mc.findMaximuneCharacter（test））；
}
char FindMaximunOccurrenceCharacter（字符串输入）{
映射countHash=
新的HashMap（）；
对于（int i=0；iAs Sotirios提到，学习此类任务的调试器非常有帮助。只需在方法的开头放置断点，然后逐步检查结果发生了什么。我是java初学者。我不希望使用函数。我必须在循环的帮助下才能这样做。请帮助。我打算建议使用更面向对象的方法接近它。有一个带有值和频率的
字母
类。这提供了一些直接映射，可能会使代码更清晰。只是注释给OP另一个角度。因为我是java初学者。我不知道Hashmap及其用法？任何更简单的解决方案都会有帮助。@user3305143-这可能比你的方法更简单…：）..5到6行代码就可以了..非常感谢您的帮助。我发现我的错误@kai您的代码返回字符串中最常出现的字符，但我必须找到最长的字符序列。例如，如果字符串为“Pressure”，则输出为“ss”，但输出为“rr”。现在它可以工作了，但这是一个很小的错误，您可以自己发现。您只需更改继续中断。但您的代码具有相同的行为。它也计算发生次数，因为您没有中断循环，就像（ch==ch1）结果+ch；这是计算发生率的典型要求。非常感谢您帮助我解决这个问题@ashot@user3305143，顺便说一句，更有效的“补丁”：）从for循环中删除
i++
，然后在
if{}
（if之外）添加
i=j
；