字符串拆分，输出问题

Question

有一个字符串
0,0,00:00:00,04:00:00;0,0,07:00:00,10:00:00;0,2,11:00:00,13:00:00;1,2,11:00:00,13:00:00; 
用大类用分号隔开，大类中每一个小项用逗号隔开。
比较分号里的前两个数
例如：
0,0,00:00:00,04:00:00;0,0,07:00:00,10:00:00
前两个数都相同，则只显示1行
0,0,00:00:00~04:00:00&&07:00:00~10:00:00; （两个时间用&&分开）
如果不同
例如：
0,2,11:00:00,13:00:00;1,2,11:00:00,13:00:00; 
第一个分号里第一个数是0，第二个分号里第一个数是1，则显示两行。
0,2,11:00:00,13:00:00
1,2,11:00:00,13:00:00
最终显示结果是：
 0,0,00:00:00~04:00:00&&07:00:00~10:00:00
 0,2,11:00:00~13:00:00 
 1,2,11:00:00~13:00:00

Answer 1

如果0,0,00:00:00,04:00:00;0,0,07:00:00,10:00:00后面还有相同的像0,0,11:00:00,12:00:00;这样的怎么办？
显示0,0,00:00:00~04:00:00&&07:00:00~10:00:00&&11:00:00~12:00:00？？？？？？？？？？？？还是放到下一行？

Answer 2

对！显示0,0,00:00:00~04:00:00&&07:00:00~10:00:00&&11:00:00~12:00:00，只用前两个相同，后面一直下去。

Answer 3

String s="0,0,00:00:00,04:00:00;0,0,07:00:00,10:00:00;0,2,11:00:00,13:00:00;1,2,11:00:00,13:00:00;0,0,10:00:00,11:00:00;";
String[] str = s.split(";");
Map<String,String> result = new HashMap<String,String>();
String temp = "";

for(int i = 0; i < str.length; i ++) {
if(!"".equals(str[i])) {
List<String> same = new ArrayList<String>();// 开头两位相同的字符串
boolean flg = false;
same.add(str[i]);
for(int j = i + 1; j < str.length; j ++) {
if(i < (str.length - 1) && str[j].startsWith(str[i].substring(0,3))) {
same.add(str[j]);
flg = true;
}
}
if(!flg) {
result.put(str[i].substring(0,1), str[i]);
same.remove(str[i]);
}

if(!same.isEmpty()) {
temp = same.get(0);
for(int j = 0; j < same.size(); j ++) {
if(j < same.size() - 1) {
temp = temp  + "&&" + same.get(j + 1).substring(4);
}
if(Arrays.asList(str).contains(same.get(j))) {
s = s.replaceAll(same.get(j), "");
}
}
result.put("1" + temp.substring(0,1), temp);
}
str = s.split(";");
}
}

Set<String> keySet = result.keySet();

Iterator it = keySet.iterator();
while(it.hasNext()) {
System.out.println(result.get(it.next()));
}

Answer 4

public static void main(String[] args) {
     String s = "0,0,00:00:00,04:00:00;0,0,07:00:00,10:00:00;0,2,11:00:00,13:00:00;1,2,11:00:00,13:00:00;";
     //大分类数组
     String[] dafenlei = s.split(";");
     //循环中上一条的小分类字符串
     String[] previous = null;
     for(int i = 0; i < dafenlei.length; i++) {
     String[] xiaofenlei = dafenlei[i].split(",");
     if(null == previous) {
     //上一条为空说明是循环的开始
     previous = new String[2];
     previous[0] = xiaofenlei[0];
     previous[1] = xiaofenlei[1];
     //直接输出
     System.out.print(xiaofenlei[0] + "," + xiaofenlei[1] + "," + xiaofenlei[2] + "~" + xiaofenlei[3]);
     } else {
     //否则是后续，判断是追加，还是换行
         if(previous[0].equals(xiaofenlei[0]) && previous[1].equals(xiaofenlei[1])) {
         //相同追加
         System.out.print("&&" + xiaofenlei[2] + "~" + xiaofenlei[3]);
         } else {
         //不同换行
         System.out.println();
         System.out.print(xiaofenlei[0] + "," + xiaofenlei[1] + "," + xiaofenlei[2] + "~" + xiaofenlei[3]);
         }
         //将当前循环的小分类字符串前两位，保存当作上一条小分类字符串前两位，为下一次循环做判断
         previous[0] = xiaofenlei[0];
     previous[1] = xiaofenlei[1];
     }
     }
    }

Answer 5

public static void main(String[] args) { 
    String s = "0,0,00:00:00,04:00:00;0,0,07:00:00,10:00:00;0,2,11:00:00,13:00:00;1,2,11:00:00,13:00:00;"; 
    //大分类数组 
    String[] dafenlei = s.split(";"); 
    //循环中上一条的小分类字符串 
    String[] previous = null; 
    for(int i = 0; i < dafenlei.length; i++) { 
            String[] xiaofenlei = dafenlei[i].split(","); 
            if(null == previous) { 
                //上一条为空说明是循环的开始 
                previous = new String[2]; 
                previous[0] = xiaofenlei[0]; 
                previous[1] = xiaofenlei[1]; 
                //直接输出 
                System.out.print(xiaofenlei[0] + "," + xiaofenlei[1] + "," + xiaofenlei[2] + "~" + xiaofenlei[3]); 
            } else { 
                //否则是后续，判断是追加，还是换行 
                if(previous[0].equals(xiaofenlei[0]) && previous[1].equals(xiaofenlei[1])) { 
                    //相同追加 
                    System.out.print("&&" + xiaofenlei[2] + "~" + xiaofenlei[3]); 
                } else { 
                    //不同换行 
                    System.out.println(); 
                    System.out.print(xiaofenlei[0] + "," + xiaofenlei[1] + "," + xiaofenlei[2] + "~" + xiaofenlei[3]); 
                } 
                //将当前循环的小分类字符串前两位，保存当作上一条小分类字符串前两位，为下一次循环做判断 
                previous[0] = xiaofenlei[0]; 
                previous[1] = xiaofenlei[1]; 
            } 
        } 
    } 
    
如果 把String s = "0,0,00:00:00,04:00:00;0,0,07:00:00,10:00:00;0,2,11:00:00,13:00:00;1,2,11:00:00,13:00:00;"; 
中的"0,0,00:00:00,04:00:00;"放在最后面,输出结果就不对了！ 
如何解决？ 
0,0,07:00:00,10:00:00;0,2,11:00:00,13:00:00;1,2,11:00:00,13:00:00;0,0,00:00:00,04:00:00;

Answer 6

那反而简单了，你一开始没说有这样的要求：import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;public class TestMain {
public static void main(String[] args) {
        String s = "0,0,00:00:00,04:00:00;0,0,07:00:00,10:00:00;0,2,11:00:00,13:00:00;1,2,11:00:00,13:00:00;0,0,00:00:00,04:00:00;";
        //大分类数组
        String[] dafenlei = s.split(";");
        //循环中上一条的小分类字符串
        Map<String,List<String>> map = new HashMap<String,List<String>>();
        for(int i = 0; i < dafenlei.length; i++) {
         String[] xiaofenlei = dafenlei[i].split(",");
         if(map.containsKey(xiaofenlei[0]+xiaofenlei[1])) {
         List<String> list = map.get(xiaofenlei[0]+xiaofenlei[1]);
         list.add(dafenlei[i]);
         } else {
         List<String> list = new ArrayList<String>();
         list.add(dafenlei[i]);
         map.put(xiaofenlei[0]+xiaofenlei[1], list);
         }
        }
        Collection<List<String>> c = map.values();
        Iterator<List<String>> iterator = c.iterator();
        while(iterator.hasNext()) {
         List<String> list = iterator.next();
         for(int i = 0; i < list.size(); i++) {
         String[] temp = list.get(i).split(",");
         if(i == 0) {
         System.out.print(temp[0]+","+temp[1] + "," + temp[2] + "~" + temp[3]);
         } else {
         System.out.print("&&" + temp[2] + "~" + temp[3]);
         }
         }
         System.out.println();
        }
    }
}

Answer 7

很强！有点小问题能否再解决一下。
String s = "0,0,00:00:00,04:00:00;0,0,07:00:00,10:00:00;0,2,11:00:00,13:00:00;1,2,11:00:00,13:00:00;0,0,01:00:00,04:00:00;0,0,04:00:00,06:00:00;";
这个字符串输出后得到
0,0,00:00:00~04:00:00&&07:00:00~10:00:00&&01:00:00~04:00:00&&04:00:00~06:00:00
0,2,11:00:00~13:00:00
1,2,11:00:00~13:00:00
能否对有这个&&分隔符的排序
比如：
00:00:00~04:00:00&&07:00:00~10:00:00&&01:00:00~050:00&&06:00:00~07:00:00
00:00:00~04:00:00和01:00:00~05:00:00这种情况的合并成00:00:00~05:00:00
最后输出结果是
00:00:00~05:00:00&&06:00:00~07:00:00&&07:00:00~10:00:00
谢谢！

Answer 8

晕倒，LZ，这是小问题？你这不光是排序，还要合并啦（合并要考虑几种情况，下面会说），原来循环内的代码不能用了，而且，为什么LZ一开始不把全部需求说出来？感觉LZ不像是在求助，是像在考验人，如果是考验的话，只能无语。现在要考虑这样几种情况：00:00:00~04:00:00和01:00:00~05:00:00的情况要合并，00:00:00~04:00:00和01:00:00~03:00:00的情况01:00:00~03:00:00要被省略，而00:00:00~04:00:00和04:00:00~05:00:00的情况究竟是合并还是不变我还没搞清楚LZ的意思，我现在照合并做的，合并成00:00:00~05:00:00，LZ如果觉得不应该合并，只要将代码中红色部分<=改成<即可。同时，这段代码不光适合整点（我想01:00:00这样的形式应该是时间吧）的情况，也适合时分秒的形式，即01:23:45，不会再有新的需求了吧？只是这段代码不具有纠错功能，如果输入的字符串不满足LZ所说的形式抛异常我也只能继续无语。代码如下：import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;public class TestMain {
public static void main(String[] args) {
        String s = "0,0,00:00:00,04:00:00;0,0,06:00:00,10:00:00;0,2,11:00:00,13:00:00;1,2,11:00:00,13:00:00;0,0,05:00:00,10:00:00;";
        String[] dafenlei = s.split(";");
        Map<String,List<String>> map = new HashMap<String,List<String>>();
        for(int i = 0; i < dafenlei.length; i++) {
         String[] xiaofenlei = dafenlei[i].split(",");
         if(map.containsKey(xiaofenlei[0]+xiaofenlei[1])) {
         List<String> list = map.get(xiaofenlei[0]+xiaofenlei[1]);
         list.add(dafenlei[i]);
         } else {
         List<String> list = new ArrayList<String>();
         list.add(dafenlei[i]);
         map.put(xiaofenlei[0]+xiaofenlei[1], list);
         }
        }
        Collection<List<String>> c = map.values();
        Iterator<List<String>> iterator = c.iterator();
        while(iterator.hasNext()) {
         List<String> list = iterator.next();
         String[] str = list.toArray(new String[]{});
         //排序
         Arrays.sort(str);
         //每一个小分类的结束时间
         String end = null;
         //每行开始的标记
         boolean isLineStart = true;
         for(int i = 0; i < str.length; i++) {
         String[] temp = str[i].split(",");
         if(isLineStart) {
         System.out.print(temp[0]+","+temp[1] + "," + temp[2] + "~");
         //只有一行的开始才输出上面的形式，所以只需输出一次就将标记置false，关闭这种形式的输出
         //直到另起一行时才开
         isLineStart = false;
         //将当前的结束时间存起来，是否具备输出条件还要看下一次循环
         end = temp[3];
         } else {
         //当前的开始时间
         int currStart = Integer.parseInt(temp[2].replaceAll(":", ""));
         //当前的结束时间
         int currEnd = Integer.parseInt(temp[3].replaceAll(":", ""));
         //上一次循环存的结束时间
         int previousEnd = Integer.parseInt(end.replaceAll(":", ""));
         //如果当前开始时间小于等于上次的结束时间，则说明有可能要合并
          if(currStart <= previousEnd) {
         //同时还要满足当前的结束时间要大于上次的结束时间，否则本次循环的记录要直接被省略掉，
         if(currEnd > previousEnd) {
         //将上次存的结束时间用当前的替换掉
         end = temp[3];
         }
         } else {
         //如果不满足，说明合并结束，该将上次的结束时间输出了
         System.out.print(end);
         //同时将本次的开始时间输出，一个新的小分类的开始
         System.out.print("&&" + temp[2] + "~");
         //同时继续将本次的结束时间存起来，留做下次判断
         end = temp[3];
         }
         }
         }
         //循环结束后由于循环内每次输出的都是上次的结束时间与本次的开始时间
         //始终都少一条结束时间，所以循环结束后直接输出
         System.out.println(end);
        }
    }
}

Answer 9

java代码内的颜色没起效果，但应该能看见，就是这对标签中间的代码可根据LZ的需求更改。希望这是最后一次变更需求，如果是客户这样频繁变更需求会被我同事骂死的，不过做国内项目也难免。