在字符串中找出连续最长的数字串

Question

public class Test {
public static void main(String[] args) {
Test test =new Test();
System.out.println(test.Continumax("abcd12345ss54321", null));
}
public int Continumax(String intputStr,  StringBuffer outputStr){
int maxlength=0;
StringBuffer maxNumberStr = null;

int nowlength=0;
StringBuffer nowNumberStr = null;
for(int i=0;i<intputStr.length();i++){
if((intputStr.charAt(i))>=48 && (intputStr.charAt(i))<=57){
if(nowlength==0){
nowNumberStr = new StringBuffer(String.valueOf(intputStr.charAt(i)));
nowlength++;
}else{ nowNumberStr.append(intputStr.charAt(i));
nowlength++;}

if(nowlength>=maxlength){
maxNumberStr = nowNumberStr;
maxlength = nowlength;
}
}else{
nowlength=0;
nowNumberStr =null;
}

}

System.out.println(maxNumberStr);
return maxlength;
}
}
看行不

Answer 1

public class Test {
public static void main(String[] args) {
Test test =new Test();
System.out.println(test.Continumax("abcd12345ss54321", null));
}

//设计思路：用一个字符变量表示最大的连续数字字符串在用另一个表示当前连续数字字符，当前连续数字字符的长度大于最大的连续数字字符串时就将其赋个最大的连续数字字符串
public int Continumax(String intputStr,  StringBuffer outputStr){
int maxlength=0; //统计最大连续数字字符川长度
StringBuffer maxNumberStr = null;//统计最大连续数字字符串

int nowlength=0;//当前连续数字字符串长度
StringBuffer nowNumberStr = null;//当前连续数字字符串长度
for(int i=0;i<intputStr.length();i++){
if((intputStr.charAt(i))>=48 && (intputStr.charAt(i))<=57){//判断字符是否是数字
if(nowlength==0){//第一个数字字符的处理
nowNumberStr = new StringBuffer(String.valueOf(intputStr.charAt(i)));
nowlength++;
}else{ nowNumberStr.append(intputStr.charAt(i));
nowlength++;}

if(nowlength>=maxlength){
maxNumberStr = nowNumberStr;
maxlength = nowlength;
}
}else{ //当出现非数字字符的时候吧nowlength、nowNumberStr清空
nowlength=0;
nowNumberStr =null;
}

}

System.out.println(maxNumberStr);
return maxlength;
}
}我想你这样应该看的懂了哇

Answer 2

import java.lang.*;class Test
{
public static void main(String[] args)
{
String sInput = "abcd12345ed125ss123456789";
StringBuffer sb = new StringBuffer();

int length = Continumax(sInput,  sb);
System.out.println("输出"+sb.toString()+"，函数返回值"+length);
}

static int Continumax(String inputStr,  StringBuffer outputStr)
{
String stemp = "";
for(int i=0;i<inputStr.length();i++)
{
char ch = inputStr.charAt(i);
if (ch>='0' && ch<='9')
outputStr.append(ch);
else
{
if (outputStr.length() > stemp.length())
{
stemp = outputStr.toString();
}
outputStr.delete(0,outputStr.length());
}
}
if (outputStr.length() > stemp.length())
{
stemp = outputStr.toString();
}
outputStr.replace(0,outputStr.length(),stemp);
return stemp.length();
}
}

Answer 3

用正则貌似更简单啊!package zhangming.csdn;import java.util.Scanner;public class MaxNumString
{
static int continueMax(String inputStr,StringBuffer outputStr)
{
String[] str = inputStr.split("[^0-9]{1,}"); //^[0-9]{1,}至少有一个非数字的字符串
int temp = 0;
for(String s: str)
if(s.length() >= temp)
{
temp = s.length();
outputStr.replace(0,temp,s);
}
System.out.print("输出" + outputStr.toString());
return temp;
}
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
while(sc.hasNext())
{
String inputStr = sc.nextLine();
StringBuffer outputStr = new StringBuffer();
System.out.println(",函数返回值" + continueMax(inputStr,outputStr));
}
}
}

Answer 4

花了半天时间按我思路写出来了，即：12345这样的才是连续数字串，像123678这样的整个不是，可分为123，678.反过来像54321，876321也是一样。
 public static int Continumax(String intputStr, StringBuffer outputStr) {
        char[] charArray = intputStr.toCharArray();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < charArray.length; i++) {
            if (Character.isDigit(charArray[i])) {
                sb.append(charArray[i]);
            } else {
                sb.append(",");
            }
        }
        String[] digitArray = sb.toString().replaceAll("(,)+", ",").split(",");//得到数字数组
        if (digitArray.length <= 1) {
            System.out.println("没有数字串！");
            return 0;
        }
        List<String> digitList = new ArrayList<String>(Arrays.asList(digitArray));//转化为list方便操作
        List<String> positiveDigitList = fetchContinueDigitByPositiveSort(digitList);//得到正向连续的数字比如1234，345
        List<String> backDigitList = fetchContinueDigitByBackSort(digitList);//得到反向连续的数字比如4321，765
        List<String> lastList = new ArrayList<String>();
        lastList.addAll(positiveDigitList);
        lastList.addAll(backDigitList);
        int maxLength = 0;
        String maxValue = "";
        for (String s : lastList) {         //找出最长并且是最后一个的值和长度
            if (s.length() >= maxLength) {
                maxLength = s.length();
                maxValue = s;
            }
        }
        System.out.println("最大连续数字串为：" + maxValue);
        System.out.println("其长度为：" + maxLength);
        return maxLength;
    }    private static List<String> fetchContinueDigitByPositiveSort(List<String> digitList) {
        List<String> lastDigitList = new ArrayList<String>();
        for (String s : digitList) {
            if (s.equals("")) {
                continue;
            }
            char[] charArray = s.toCharArray();
            int start = Integer.parseInt(String.valueOf(charArray[0]));
            int begin = Integer.parseInt(String.valueOf(charArray[0]));
            int startIndex = 0;
            for (int j = 1; j < charArray.length; j++) {
                if (begin + 1 == Integer.parseInt(String.valueOf(charArray[j])) && j != charArray.length - 1) {
                    begin = begin + 1;
                    continue;
                }
                begin = Integer.parseInt(String.valueOf(charArray[j]));
                if (start == begin) {
                    lastDigitList.add(String.valueOf(start));
                } else if (j == charArray.length - 1 && Integer.parseInt(String.valueOf(charArray[j])) - 1 == Integer.parseInt(String.valueOf(charArray[j - 1]))) {
                    lastDigitList.add(String.valueOf(charArray).substring(startIndex, j + 1));
                } else {
                    lastDigitList.add(String.valueOf(charArray).substring(startIndex, j));
                    if (j == charArray.length - 1) {
                        lastDigitList.add(String.valueOf(charArray[j]));
                    }
                }
                start = begin;
                startIndex = j;
            }        }
        return lastDigitList;    }    private static List<String> fetchContinueDigitByBackSort(List<String> digitList) {
        List<String> lastDigitList = new ArrayList<String>();
        for (String s : digitList) {
            if (s.equals("")) {
                continue;
            }
            char[] charArray = s.toCharArray();
            int start = Integer.parseInt(String.valueOf(charArray[0]));
            int begin = Integer.parseInt(String.valueOf(charArray[0]));
            int startIndex = 0;
            for (int j = 1; j < charArray.length; j++) {
                if (begin - 1 == Integer.parseInt(String.valueOf(charArray[j])) && j != charArray.length - 1) {
                    begin = begin - 1;
                    continue;
                }
                begin = Integer.parseInt(String.valueOf(charArray[j]));
                if (start == begin) {
                    lastDigitList.add(String.valueOf(start));
                } else if (j == charArray.length - 1 && Integer.parseInt(String.valueOf(charArray[j])) + 1 == Integer.parseInt(String.valueOf(charArray[j - 1]))) {
                    lastDigitList.add(String.valueOf(charArray).substring(startIndex, j + 1));
                } else {
                    lastDigitList.add(String.valueOf(charArray).substring(startIndex, j));
                    if (j == charArray.length - 1) {
                        lastDigitList.add(String.valueOf(charArray[j]));
                    }
                }
                start = begin;
                startIndex = j;
            }        }
        return lastDigitList;    }    public static void main(String[] arg) {
        Continumax("abcd123456ed125ss123456789", null);
    }
run:
最大连续数字串为：123456789
其长度为：9
成功构建 (总时间: 0 秒)

Answer 5

有个小BUG就是只有一个数字时没有判断，下面加了：
    public static int Continumax(String intputStr, StringBuffer outputStr) {
        char[] charArray = intputStr.toCharArray();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < charArray.length; i++) {
            if (Character.isDigit(charArray[i])) {
                sb.append(charArray[i]);
            } else {
                sb.append(",");
            }
        }
        String[] digitArray = sb.toString().replaceAll("(,)+", ",").split(",");//得到数字数组
        if (digitArray.length <= 1) {
            System.out.println("没有数字串！");
            return 0;
        }
        List<String> digitList = new ArrayList<String>(Arrays.asList(digitArray));//转化为list方便操作
        List<String> positiveDigitList = fetchContinueDigitByPositiveSort(digitList);//得到正向连续的数字比如1234，345
        List<String> backDigitList = fetchContinueDigitByBackSort(digitList);//得到反向连续的数字比如4321，765
        List<String> lastList = new ArrayList<String>();
        lastList.addAll(positiveDigitList);
        lastList.addAll(backDigitList);
        int maxLength = 0;
        String maxValue = "";
        for (String s : lastList) {         //找出最长并且是最后一个的值和长度
            if (s.length() >= maxLength) {
                maxLength = s.length();
                maxValue = s;
            }
        }
        System.out.println("最大连续数字串为：" + maxValue);
        System.out.println("其长度为：" + maxLength);
        return maxLength;
    }    private static List<String> fetchContinueDigitByPositiveSort(List<String> digitList) {
        List<String> lastDigitList = new ArrayList<String>();
        for (String s : digitList) {
            if (s.equals("")) {
                continue;
            }
            char[] charArray = s.toCharArray();
            int start = Integer.parseInt(String.valueOf(charArray[0]));
            int begin = Integer.parseInt(String.valueOf(charArray[0]));
            int startIndex = 0;
            if (charArray.length == 1) {
                lastDigitList.add(String.valueOf(start));
                return lastDigitList;
            }
            for (int j = 1; j < charArray.length; j++) {
                if (begin + 1 == Integer.parseInt(String.valueOf(charArray[j])) && j != charArray.length - 1) {
                    begin = begin + 1;
                    continue;
                }
                begin = Integer.parseInt(String.valueOf(charArray[j]));
                if (start == begin) {
                    lastDigitList.add(String.valueOf(start));
                } else if (j == charArray.length - 1 && Integer.parseInt(String.valueOf(charArray[j])) - 1 == Integer.parseInt(String.valueOf(charArray[j - 1]))) {
                    lastDigitList.add(String.valueOf(charArray).substring(startIndex, j + 1));
                } else {
                    lastDigitList.add(String.valueOf(charArray).substring(startIndex, j));
                    if (j == charArray.length - 1) {
                        lastDigitList.add(String.valueOf(charArray[j]));
                    }
                }
                start = begin;
                startIndex = j;
            }        }
        return lastDigitList;    }    private static List<String> fetchContinueDigitByBackSort(List<String> digitList) {
        List<String> lastDigitList = new ArrayList<String>();
        for (String s : digitList) {
            if (s.equals("")) {
                continue;
            }
            char[] charArray = s.toCharArray();
            int start = Integer.parseInt(String.valueOf(charArray[0]));
            int begin = Integer.parseInt(String.valueOf(charArray[0]));
            int startIndex = 0;
            if (charArray.length == 1) {
                lastDigitList.add(String.valueOf(start));
                return lastDigitList;
            }
            for (int j = 1; j < charArray.length; j++) {
                if (begin - 1 == Integer.parseInt(String.valueOf(charArray[j])) && j != charArray.length - 1) {
                    begin = begin - 1;
                    continue;
                }
                begin = Integer.parseInt(String.valueOf(charArray[j]));
                if (start == begin) {
                    lastDigitList.add(String.valueOf(start));
                } else if (j == charArray.length - 1 && Integer.parseInt(String.valueOf(charArray[j])) + 1 == Integer.parseInt(String.valueOf(charArray[j - 1]))) {
                    lastDigitList.add(String.valueOf(charArray).substring(startIndex, j + 1));
                } else {
                    lastDigitList.add(String.valueOf(charArray).substring(startIndex, j));
                    if (j == charArray.length - 1) {
                        lastDigitList.add(String.valueOf(charArray[j]));
                    }
                }
                start = begin;
                startIndex = j;
            }        }
        return lastDigitList;    }    public static void main(String[] arg) {
        Continumax("abcd1", null);
    }

Answer 6

一时间只想到一个笨方法。
把字符串按charat有这个方法吧 存到char数组后，对char进行 数字的判断，
然后把得出的长度结果和数据存入 map中，然后用map调出数据，这块有一个需要
考虑的就是相同的2个一样长的怎么办，在存入map的时候加一个判断条件，不让map
覆盖key值相同的数据，我觉得就差不多了，代码的现实，楼主加油吧

Answer 7

package j2se_519;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
 * 在字符串中找出连续最长的数字串   afaf12345ajlfha54321afaf
 * 思路：1.把确定的字符存进字符串里面  2.定义一个最大字符串随时更新
 * 
 * @author 王二麻子
 *
 */
public class LargeString {
public static void main(String[] args) throws IOException {
BufferedReader sb = new BufferedReader(new InputStreamReader(System.in));
String s = sb.readLine();
/*定义两个字符串 s2 和 maxs，以便存入数字*/
String s2 = "";
String maxs = "";
for(int i=0; i<s.length(); i++){
if(s.charAt(i) > '0' && s.charAt(i) < '9'){
s2 += s.charAt(i);
if(s2.length() >= maxs.length()){
maxs = s2;
}
}
else
s2 = "";
}
System.out.println("连续最长的数字串：" + maxs + " 最大字符串的长度为： " + maxs.length());
}
}

Answer 8

 are you sure??我都跑出来了怎么会不是？你把你那个输出不是的串发出来我看看

Answer 9

好的，我发出来大神看一下!
abcd12ss34e891

Answer 10

public class Test {    public static String getMaxLenNumStr(String inputStr) {
        int maxlen = 0, index = 0, i,k = 0,j= 0;
        for (i = 0; i < inputStr.length(); i++) {
            char c = inputStr.charAt(i);
            if (c >= '0' && c <= '9') {
                j ++;
                continue;
            } else {
                if (maxlen <= j) {
                    maxlen = j;
                    k = i;
                }
                j = 0;
            }
        }        if (maxlen <= j) {
            maxlen = j;
            k = i;
        }        return inputStr.substring(k-maxlen, k);
    }    public static void main(String[] args) {
        String str = "54321test12345";
        System.out.println(getMaxLenNumStr(str));
    }
}

Answer 11

这个仍然是不是输出最长连续的数字串
比如输入54321test123457应输出54321，是连续的

Answer 12

public class GetLongestNumber
{    public static void main(String[] args)
    {
        System.out.print("请输入目标字符串：");
        Scanner sc = new Scanner(System.in);        String intputStr = sc.nextLine();        StringBuffer outputStr = new StringBuffer();
        int maxLength = Continumax(intputStr, outputStr);        System.out.println("输出:" + outputStr + ",函数返回值:" + maxLength);
    }    private static int Continumax(String intputStr, StringBuffer outputStr)
    {        //为空直接返回
        if (null == intputStr || intputStr.length() == 0)
        {
            return 0;
        }        //初始化报错结果的工具
        StringBuilder sb = new StringBuilder(10);
        //数字串计数器
        int counter = 0;        char temp;
        //单个字符匹配
        for (int i = 0; i < intputStr.length(); i++)
        {
            temp = intputStr.charAt(i);
            //非数字字符
            if (temp < '0' || temp > '9')
            {
                //若计数器大于最大长度，则替换最大长度，计数器清零
                if (counter >= outputStr.length())
                {
                    outputStr.setLength(0);
                    outputStr.append(sb);                    counter = 0;
                    sb.setLength(0);
                }
            }
            else
            {
                counter++;
                sb.append(temp);
            }
        }
        return outputStr.length();
    }
}

Answer 13

修改下：
public class GetLongestNumber
{    public static void main(String[] args)
    {
        System.out.print("请输入目标字符串：");
        Scanner sc = new Scanner(System.in);        String intputStr = sc.nextLine();        StringBuffer outputStr = new StringBuffer();
        int maxLength = Continumax(intputStr, outputStr);        System.out.println("输出:" + outputStr + ",函数返回值:" + maxLength);
    }    private static int Continumax(String intputStr, StringBuffer outputStr)
    {        //为空直接返回
        if (null == intputStr || intputStr.length() == 0)
        {
            return 0;
        }        String result = "";        //初始化报错结果的工具
        StringBuilder sb = new StringBuilder(10);
        //数字串计数器
        int counter = 0;        char temp;
        //单个字符匹配
        for (int i = 0; i < intputStr.length(); i++)
        {
            temp = intputStr.charAt(i);
            //非数字字符
            if (temp < '0' || temp > '9')
            {
                //若计数器大于最大长度，则替换最大长度，计数器清零
                if (counter != 0 && counter >= outputStr.length())
                {
                    result = sb.toString();                    counter = 0;
                    sb.setLength(0);
                }
            }
            else
            {
                counter++;
                sb.append(temp);
            }
        }
        if (counter != 0 && counter >= outputStr.length())
        {
            result = sb.toString();
        }
        outputStr.append(result);
        return result.length();
    }
}

Answer 14

abcd12ss34e891 我试了是
最大连续数字串为：54321
其长度为：5
成功构建 (总时间: 0 秒)这个有问题嘛？你不要告诉我891也是连续的？？
还有对于这个54321test123457按你所说的应该是12345，因为最大连续数相同时取最后一个。我那有个BUG就是这种正倒序两种情况所得的最大数相同时是有问题，就像54321test123457，我那返回的是54321应该是12345才对，回头我再修改修改，其它应该没什么问题

Answer 15

发错了，是这个abcd12ss34e891run:
最大连续数字串为：89
其长度为：2
成功构建 (总时间: 1 秒)

Answer 16

我改进了一下你在试试
 public static int Continumax(String intputStr, StringBuffer outputStr) {
        char[] charArray = intputStr.toCharArray();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < charArray.length; i++) {
            if (Character.isDigit(charArray[i])) {
                sb.append(charArray[i]);
            } else {
                sb.append(",");
            }
        }
        String[] digitArray = sb.toString().replaceAll("(,)+", ",").split(",");//得到数字数组
        if (digitArray.length <= 1) {
            System.out.println("没有数字串！");
            return 0;
        }
        List<String> digitList = new ArrayList<String>(Arrays.asList(digitArray));//转化为list方便操作
        List<String> positiveDigitList = fetchContinueDigitByPositiveSort(digitList, true);//得到正向连续的数字比如1234，345
        List<String> backDigitList = fetchContinueDigitByPositiveSort(digitList, false);//得到反向连续的数字比如4321，765
        List<String> lastList = new ArrayList<String>();
        lastList.addAll(positiveDigitList);
        lastList.addAll(backDigitList);
        int maxLength = 0;
        String maxValue = "";
        List<String> endStrList = new ArrayList<String>();
        for (String s : lastList) {         //找出最长并且是最后一个的值和长度
            if (s.length() > maxLength) {
                maxLength = s.length();
            }
        }
        for (String s : lastList) {         //找出最长并且是最后一个的值和长度
            if (s.length() == maxLength) {
                endStrList.add(s);
            }
        }
        int startIndex = 0;
        for (String s : endStrList) {
            if (intputStr.lastIndexOf(s) >= startIndex) {
                startIndex = intputStr.lastIndexOf(s);
                maxValue = s;
                maxLength = s.length();
            }
        }
        System.out.println("最大连续数字串为：" + maxValue);
        System.out.println("其长度为：" + maxLength);
        return maxLength;
    }    private static List<String> fetchContinueDigitByPositiveSort(List<String> digitList, boolean isPositive) {
        List<String> lastDigitList = new ArrayList<String>();
        for (String s : digitList) {
            if (s.equals("")) {
                continue;
            }
            char[] charArray = s.toCharArray();
            int start = Integer.parseInt(String.valueOf(charArray[0]));
            int begin = Integer.parseInt(String.valueOf(charArray[0]));
            int startIndex = 0;
            if (charArray.length == 1) {
                lastDigitList.add(String.valueOf(start));
                return lastDigitList;
            }
            for (int j = 1; j < charArray.length; j++) {
                if (isPositive) {
                    if (begin + 1 == Integer.parseInt(String.valueOf(charArray[j])) && j != charArray.length - 1) {
                        begin = begin + 1;
                        continue;
                    }
                } else {
                    if (begin - 1 == Integer.parseInt(String.valueOf(charArray[j])) && j != charArray.length - 1) {
                        begin = begin - 1;
                        continue;
                    }
                }
                begin = Integer.parseInt(String.valueOf(charArray[j]));
                if (start == begin) {
                    lastDigitList.add(String.valueOf(start));
                } else if (j == charArray.length - 1 && ((isPositive && Integer.parseInt(String.valueOf(charArray[j])) - 1 == Integer.parseInt(String.valueOf(charArray[j - 1])))
                        || (Integer.parseInt(String.valueOf(charArray[j])) + 1 == Integer.parseInt(String.valueOf(charArray[j - 1]))))) {
                    lastDigitList.add(String.valueOf(charArray).substring(startIndex, j + 1));
                } else {
                    lastDigitList.add(String.valueOf(charArray).substring(startIndex, j));
                    if (j == charArray.length - 1) {
                        lastDigitList.add(String.valueOf(charArray[j]));
                    }
                }
                start = begin;
                startIndex = j;
            }        }
        return lastDigitList;    }    public static void main(String[] arg) {
        Continumax("54321test123457 ", null);
    }

Answer 17

29楼的大神确实功力深厚，但是还有一点小瑕疵，就是输入54321test123457，要输出54321

Answer 18

按你的说 String str=12345679adk中是没有连续的数字串的？你敢说1234567不是？如果你认为不是那我觉得你这题就很简单了，并且这种思路我是接受不了的。所以我不写了。

Answer 19

import java.util.regex.Matcher;
import java.util.regex.Pattern;public class Hello {
    public static void main(String[] args) {
        String str = "abcd12345ed125ss123456789";
        String result = null;        Pattern pattern = Pattern.compile("\\d+");
        Matcher matcher = pattern.matcher(str);        while (matcher.find()) {
            String matched = matcher.group(0);            if ((result == null) || (matched.length() >= result.length())) {
                result = matched;
            }
        }        System.out.println(result);
    }
}

Answer 20

这是你想要的？
  public static int Continumax(String intputStr, StringBuffer outputStr) {
        List<String> digitList = new ArrayList<String>();//转化为list方便操作
        Pattern pattern = Pattern.compile("\\d+");
        Matcher matcher = pattern.matcher(intputStr);
        while (matcher.find()) {
            digitList.add(matcher.group(0));
        }
        if (digitList.isEmpty()) {
            System.out.println("没有数字串！");
            return 0;
        }
        int maxLength = 0;
        String maxValue = "";
        for (int i = digitList.size() - 1; i >= 0; i--) {
            if (!isContinue(digitList.get(i).toCharArray())) {
                digitList.remove(i);
            } else if (digitList.get(i).length() >= maxLength) {
                maxLength = digitList.get(i).length();
            } else {
                digitList.remove(i);
            }
        }
        int startIndex = 0;
        for (String s : digitList) {
            if (intputStr.lastIndexOf(s) >= startIndex) {
                startIndex = intputStr.lastIndexOf(s);
                maxValue = s;
                maxLength = s.length();
            }
        }
        System.out.println("最大连续数字串为：" + maxValue);
        System.out.println("其长度为：" + maxLength);
        return maxLength;
    }
    private static boolean isContinue(char[] array) {
        return Math.abs(array[array.length - 1] - array[0]) == array.length - 1;
    }
    public static void main(String[] arg) {
        Continumax("abcd12ss34e891", null);
    }

Answer 21

再给你个版面，我想你问题应该解决了吧？    public static int Continumax(String intputStr, StringBuffer outputStr) {
        List<String> digitList = new ArrayList<String>();//转化为list方便操作
        Pattern pattern = Pattern.compile("\\d+");
        Matcher matcher = pattern.matcher(intputStr);
        while (matcher.find()) {
            digitList.add(matcher.group(0));
        }
        if (digitList.isEmpty()) {
            System.out.println("没有数字串！");
            return 0;
        }
        for (int i = digitList.size() - 1; i >= 0; i--) {
            if (!isContinue(digitList.get(i).toCharArray())) {
                digitList.remove(i);
            }
        }
        Collections.sort(digitList, new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                int thisLength = String.valueOf(o1).length();
                int otherLength = String.valueOf(o2).length();
                return thisLength - otherLength;
            }
        });
        System.out.println("最大连续数字串为：" + digitList.get(digitList.size() - 1) + "其长度为：" + digitList.get(digitList.size() - 1).length());
        return digitList.get(digitList.size() - 1).length();
    }    private static boolean isContinue(char[] array) {
        return Math.abs(array[array.length - 1] - array[0]) == array.length - 1;
    }    public static void main(String[] arg) {
        Continumax("abcd12345ss54321", null);
    }

Answer 22

public static int longestNumberStr(String str){
int maxLen = 0;
int curLen = 0;
char[] cArray = str.toCharArray();
for(int i=0; i<cArray.length; i++){
if(cArray[i] >= '0' && cArray[i] <= '9'){
curLen ++;
if(i == cArray.length-1){
maxLen = curLen > maxLen? curLen : maxLen; 
curLen = 0;
}
}else{
maxLen = curLen > maxLen? curLen : maxLen; 
curLen = 0;
}
}
System.out.println(maxLen);
return maxLen;
}

Answer 23

public static int longestNumberStr(String str){
int maxLen = 0;
int curLen = 0;
char[] cArray = str.toCharArray();
for(int i=0; i<cArray.length; i++){
if(cArray[i] >= '0' && cArray[i] <= '9'){
curLen ++;
if(i == cArray.length-1){
maxLen = curLen > maxLen? curLen : maxLen; 
curLen = 0;
}
}else{
maxLen = curLen > maxLen? curLen : maxLen; 
curLen = 0;
}
}
System.out.println(maxLen);
return maxLen;
}

Answer 24

static int Continumax(String intputStr,  String outputStr){
    //out="";
outputStr="";
String curStr="";

char[] cArray = intputStr.toCharArray();
for(int i=0; i<cArray.length; i++){
if(cArray[i] >= '0' && cArray[i] <= '9'){
curStr+=cArray[i];

}else{

outputStr = curStr.length() >= outputStr.length()? curStr : outputStr; 
curStr = "";
}
}

System.out.println(outputStr);
return outputStr.length();
 }

Answer 25

static int Continumax(String intputStr,  String outputStr){
    //out="";
outputStr="";
String curStr="";

char[] cArray = intputStr.toCharArray();
for(int i=0; i<cArray.length; i++){
if(cArray[i] >= '0' && cArray[i] <= '9'){
curStr+=cArray[i];

}else{
//长度相同，保存后者，所以相等的时候也要交换，所以保留等号
outputStr = curStr.length() >= outputStr.length()? curStr : outputStr; 
curStr = "";
}
}

System.out.println(outputStr);
return outputStr.length();
 }

Answer 26

求各位大神帮我看看这个代码哪里有错误：功能是求给定字符串中最长的连续递增数字串private static String longestNumbers(String s) {
// TODO Auto-generated method stub
int begin = 0;
int end = 0 ;
int length = end - begin;
for(int i = 0;i<s.length();i++){
begin = end =i;
if(s.charAt(i)>='0'&&s.charAt(i)<='9'&&end<s.length()){
end++;
for(int j = i;j<s.length()-1&&end<s.length();j++){
if(s.charAt(j+1)-s.charAt(j)==1)
end++;
else
break;
}
}
int length1 = end - begin ;
if(length<length1)
length = length1;
}
return s.substring(begin, end);
}
[/b]