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

输入描述:

输入一个字符串。

输出描述:

输出字符串中最长的数字字符串和它的长度。

输入例子:

abcd12345ed125ss123058789，如果有重复的最大长度的数字串，则一起输出，如1456jk4789，输出14564789,4

输出例子:

123058789,9


思路：先把字符串中的数字串取出来，然后取出长度最大的数字字串并输出，刚开始我使用HashMap的key存储数字字串，value存字串长度，考虑到HashMap存储无序，故改为LInkedHashMap,然后根据Map的value值排序，取出value值最大的map元素并输出，但是忽略一个特殊情况，就是当最大子串有若干个且相同，则map由于key不能重复，只会存储一个，故有缺陷，但是却被AC，后来使用list来存储，解决了此问题并被AC，

先上有缺陷代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;

public class Test10 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String s = sc.next();
            Map<String,Integer> mp = new LinkedHashMap<String,Integer>();//使用Linked哈希保证元素的有序性
            String s1 = s.replaceAll("[a-z]", " ");//把字符串中的字母全部替换为空格
            String[] str = s1.split(" ");//以空格分割字符串
            for (int i = 0; i < str.length; i++) {//把字符串中连续的数字串存至map中，其中key为数字串，value为数字串长度
                if (str[i].length() != 0) {//由于有连续空格，使用空格分割时会出现多个空子串，空子串不予考虑，故有此判断
                    if (str[i].charAt(0) != ' ') {
                        mp.put(str[i], str[i].length());
                    }
                }
            }
//System.out.println(mp);
//System.out.println("-------");

            List<Map.Entry<String, Integer>> li = new ArrayList<Map.Entry<String,Integer>>();//用来存储Map.Entry<String, Integer>类型
            Set<Entry<String, Integer>>se = mp.entrySet();//获得map的Map.Entry<String, Integer>类型
            Iterator<Entry<String, Integer>> it = se.iterator();
            while(it.hasNext()){//把Map.Entry<String, Integer>类型元素存入list中，以便排序
                Entry<String, Integer> en = it.next();
                li.add(en);
//System.out.println(en);
            }
//System.out.println("-------");
            Collections.sort(li, new Comparator<Entry<String, Integer>>() {//使用Collections集合工具类对list中Entry类型元素按照value进行自然升序排序

                @Override
                public int compare(Entry<String, Integer> o1,
                        Entry<String, Integer> o2) {
                    // TODO Auto-generated method stub
                    return o1.getValue().compareTo(o2.getValue());
                }
            });
            
//Iterator<Entry<String, Integer>> it1 = se.iterator();            
//while(it1.hasNext()){
//System.out.println(it1.next());
//            }
//System.out.println("-------");


            StringBuffer sb = new StringBuffer();//用来存储长度最大且相等的数字串
            for(int i=0;i<li.size();i++){
                if(li.get(li.size()-1).getValue()==li.get(i).getValue()){
                    sb.append(String.valueOf(li.get(i).getKey()));
                }
            }
            System.out.println(sb+","+li.get(li.size()-1).getValue());
        }
    }
}

上面代码如果输入时1234hj1234，则不会输出正确结果12341234,4 ，会输出1234,4，下面使用list

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class Test11 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String s = sc.next();
            List<String> li = new ArrayList<String>();
            String s1 = s.replaceAll("[a-z]", " ");// 把字符串中的字母全部替换为空格
            String[] str = s1.split(" ");// 以空格分割字符串
            for (int i = 0; i < str.length; i++) {// 把字符串中连续的数字串存至map中，其中key为数字串，value为数字串长度
                if (str[i].length() != 0) {// 由于有连续空格，使用空格分割时会出现多个空子串，空子串不予考虑，故有此判断
                    if (str[i].charAt(0) != ' ') {
                        li.add(str[i]);
                    }
                }
            }

            Collections.sort(li, new Comparator<String>() {

                @Override
                public int compare(String o1, String o2) {//这里根据list中的字符串元素长度大小进行自然排序
                    // TODO Auto-generated method stub
                    return Integer.valueOf(o1.length()).compareTo(
                            Integer.valueOf(o2.length()));
                }
            });
            StringBuffer sb = new StringBuffer();//用来存储长度最大且相等的数字串
            for (int i = 0; i < li.size(); i++) {
                if (li.get(i).length() == li.get(li.size() - 1).length()) {
                    sb.append(li.get(i));
                }
            }

            System.out.println(sb + "," + li.get(li.size() - 1).length());
        }
    }
}