刚才的字符串拆分忽略引号内拆分符号题目，给分少了，结了重开

Question

刚才那贴看大家都很热情，可惜60分太少，所以就结了下，有兴趣的来这边讨论好了。之前也有些规则没写明白，重新补充下：规则如下：1、已知一字符串数组，这些字符串有以下特点：
   a、字符串由随机数字或字母以及引号和逗号组成
   b、如果字符串中含有逗号，则字符串 头尾一定有引号
   c、如果字符串中没有逗号，则字符串 头尾可能有引号，也可能没有引号
   d、引号会且仅会出现在字符串的头尾，不会出现在中间位置如：[1] ["123"] ["12,33"] [7a] ["s1,c4,t7s"] [ccc] ["ss"]    ----每一个[]内表示一个字符串
现在把所有字符串用逗号连起来。
1，"123"，"12,33"，7a，"s1,c4,t7s"，ccc，"ss" 求将连接后的字符串 拆分回原字符串数组。
注：
1、原题是直接拆字符串成数组，我只是总结出被拆出来的字符串的规律，所以不用建议我换其他连接符连接啦
2、与之前题相比就是不用拆完后去掉引号了，因为拆成数组后去引号太容易了=.=
有兴趣的继续跟帖吧。我悲剧的想用正则省代码，被老大说了，不要用正则，万一出问题了其他人怎么维护，而且效率也不高。
好吧我老老实实遍历了....

Answer 1

不用正则：
split两次，第一次用" 第二次用,
第一次split的结果中，只有下标除以2不尽的才是""内部的，不需要进行第二次split
        String[] ss1 = str.split("\"");
        for (int i=0; i<ss1.length; i++) {
         if (i%2==0) {
         String[] ss2 = ss1[i].split(",");
         for (int j=0; j<ss2.length; j++)
         if (ss2[j].length()>0) System.out.println(ss2[j]);
         } else
         if (ss1[i].length()>0) System.out.println(ss1[i]);
        }

Answer 2

have a tryimport java.util.*;public class Test {
    public static void main(String[] args) {
        String s = "1,\"123\",\"12,33\",7a,\"s1,c4,t7s\",ccc,\"ss\"";
        List<String> result = new ArrayList<String>();
        StringBuilder buf = new StringBuilder();
        Stack<String> stack = new Stack<String>();
        for (char c : s.toCharArray()) {
            if (c == '"') {
                buf.append("\"");
                if (stack.size() == 0) {
                    stack.push(String.valueOf(c));
                } else {
                    stack.pop();
                    result.add(buf.toString());
                    buf.delete(0, buf.length());
                }                
            } else if (c == ',') {
                if (stack.size() > 0) {
                    buf.append(",");
                } else {
                    if (buf.length() > 0) {
                        result.add(buf.toString());
                        buf.delete(0, buf.length());
                     }
                }
            } else {
                buf.append(c);
            }
        }
        if (buf.length() > 0) {result.add(buf.toString());}        for (String ss : result) {
            System.out.println(ss);
        }
    }
}

Answer 3

String s = "1,\"123\",\"12,33\",7a,\"s1,c4,t7s\",ccc,\"ss\"";
        List<String> list = new ArrayList<String>();
        boolean isFlag = false;
        
        StringBuilder temp = new StringBuilder();
        for(char ch : s.toCharArray())
        {
            if('"' == ch)
            {
                isFlag = !isFlag;
            }
            else if(',' != ch)
            {
                temp.append(ch);
            }
            else
            {
                if(isFlag)
                {
                    temp.append(ch);
                }
                else
                {
                    list.add(temp.toString());
                    temp = new StringBuilder();
                }
            }
        }
        //添加结尾的字符
        list.add(temp.toString());
        
        for(String ss : list)
        {
            System.out.println(ss);
        }

Answer 4

直接使用split，还是像刚才那个帖子一样
public class Test {
    public static void main(String[] args) {
        String s = "1,\"123\",\"12,33\",7a,\"s1,c4,t7s\",ccc,\"ss\"";
        String [] result = s.split("\",|,\"|\",\""); //使用|
        for (String ss : result) {
            System.out.println(sss.repalceAll("\"", ""));
        } 
    }
}

Answer 5

String [] result = s.split("\",\"|\",|,\""); //这个好一点，先","分

Answer 6

这个字符串是随机产生的，可能会是这样1,123,12345,"123,654","sdf"。
不一定会有",或,"或","。

Answer 7

恩，又忽略了，采用循环分割吧，8L给了段sample
看了一下，5L的方法也挺好的

Answer 8

String str = "2,1,\"22\",\"333,22\",\"32,22,22,23\",4,\"6\",5";
StringBuffer newStr= new StringBuffer("");
List <String>rslt = new ArrayList<String>();
boolean flg = true;
for(char c : str.toCharArray()){
if(c !=',' || !flg){
newStr.append(c);
}else if((c=='"' && flg )|| c==','){
rslt.add(newStr.toString());
newStr.delete(0, newStr.length());
}
if(c=='"') {
flg = !flg;
}
}
System.out.println(Arrays.toString(rslt.toArray()));

Answer 9

妈的，csdn升级了还是不能编辑啊。用这个 public static void main(String[] args) {
String str = "2,1,\"22\",\"333,22\",\"32,22,22,23\",4,\"6\",5";
StringBuffer newStr= new StringBuffer("");
List <String>rslt = new ArrayList<String>();
boolean flg = true;
for(char c : str.toCharArray()){
if(c !=',' || !flg){
newStr.append(c);
}else {
rslt.add(newStr.toString());
newStr.delete(0, newStr.length());
}
if(c=='"') {
flg = !flg;
}
}
System.out.println(Arrays.toString(rslt.toArray()));
}

Answer 10

楼主自己写过解析器去解析xml吗，把字符串转成数组，然后封装方法去解析，我认为这种方法比较好

Answer 11

String s = "1,\"123\",\"12,33\",7a,\"s1,c4,t7s\",ccc,\"ss\"";
List<String> ls=new LinkedList<String>();
for(String ss:s.split("\"")){
if(ss.startsWith(",") || ss.endsWith(",")){
for(String sss:ss.split(",")){
if(sss.trim().length()!=0){
ls.add(sss);
}
}
}else{
ls.add("\""+ss+"\"");
}
}
for(String ssss:ls){
System.out.println(ssss);
}

Answer 12

String s = "1,\"123\",\"12,33\",7a,\"s1,c4,t7s\",ccc,\"ss\"";
List<String> ls=new LinkedList<String>();
for(String ss:s.split("\"")){
if(ss.startsWith(",") || ss.endsWith(",")){
for(String sss:ss.split(",")){
if(sss.trim().length()!=0){
ls.add(sss);
}
}
}else{
ls.add("\""+ss+"\"");
}
}
for(String ssss:ls){
System.out.println(ssss);
}

Answer 13

优化越来越多，很给力啊。
用正则也不是不行，只是正则其实效率低，而且不好维护，用循环便利扩展性比较好。
给段用正则的sample，让需要正则的人去思考理解。import java.util.*;
import java.util.regex.*;
public class Test {
    public static void main(String[] args) {
        String s = "1,2\"33,22\",4,5,6,\"3,22\"";
        Pattern p = Pattern.compile("(\".*?(,.*?)*\")|(.*?([^,]|[\"])*)");
        Matcher m = p.matcher(s);
        List<String> result = new ArrayList<String>();
        while(m.find()) {
            if (m.group(0).length() > 0) {
                result.add(m.group(0));
            }
        }
        for (String ss : result) {
            System.out.println(ss);
        }        
    }
}

Answer 14

不好意思，笔误了
import java.util*;
import java.util.regex.*;
public class Test {
    public static void main(String[] args) {
        String s = "1,2\"33,22\",4,5,6,\"3,22\"";
        Pattern p = Pattern.compile("(\".*?(,.*?)*\")|(.*?([^,\"])*)");
        Matcher m = p.matcher(s);
        List<String> result = new ArrayList<String>();
        while(m.find()) {
            if (m.group(0).length() > 0) {
                result.add(m.group(0));
            }
        }
        for (String ss : result) {
            System.out.println(ss);
        }        
    }
}

Answer 15

我最后代码是这样子的....大家帮看看有没有BUG
public static void splitStr (String str){
List params = new ArrayList();
int beginIndex = 0;
boolean canSplit = true;
for(int i = 0;i<str.length();i++){
char curChar = str.charAt(i);
if (i == str.length()-1){
params.add(str.substring(beginIndex,i+1).replaceAll("\"", ""));
}else if(curChar == ',' && canSplit){
params.add(str.substring(beginIndex,i).replaceAll("\"", ""));
beginIndex = i+1;
}else if(curChar == '"'){
canSplit = !canSplit;
}
}
}

Answer 16

这个思路是可行的，具体没跑。
如果要保留空串，split的时候需要加上判断。

Answer 17

程序上应该没什么问题，不过可以再优化一下，没必要每次在循环中判断i==str.length()-1，只需要在循环结束后，判断一下
if (str.length()>0 && beginIndex<=str.length()) {
    params.add(str.substring(beginIndex).replaceAll("\"", ""));
}
就好了

Answer 18

还是我前面个帖子的回复，就是CSV解析
    String[] tests = new String[] {
        "1,2,\"22\",\"333,22\",\"32,22,22,23\",4,\"6\",5",
        "\"1\",\"2,3,4\",5,6",
        "\"1,2,3,4,5,6\"",
        "1,3,5",
        "1,\"1,2,3,4,5,6\"",
        "1,\"1,2,3,4,5,6\",1,\"1,2,3,4,5,6\""
    };
    String regex =
          "\\G(?:^|,)                            \n"
        + " (?:                                  \n"
        + "   # 要么是双引号字段...              \n"
        + "   \"             # 字段起始双引号    \n"
        + "   (  [^\"]*+ )                       \n"
        + "   \"             # 字段结束双引号    \n"
        + " |# ... 要么是 ...                    \n"
        + "            # 非引号非逗号文本 ...    \n"
        + "    ( [^\",]*+)                       \n"
        + " )                                    \n";
    Pattern pattern = Pattern.compile(regex, Pattern.COMMENTS);
    for (String test : tests) {
      Matcher matcher = pattern.matcher(test);
      System.out.println(test);
      while (matcher.find()) {
        String group1 = matcher.group(1);
        String group2 = matcher.group(2);
        String field = group1 == null ? group2 : group1;
        System.out.println(field);
      }
      System.out.println("==========================");
    }

Answer 19

public static void main(String[] args) {
String str = "1,\"123\",\"12,33\",7a,\"s1,c4,t7s\",ccc,\"ss\",2"; List<String> result = new ArrayList<String>();
StringBuffer sb = new StringBuffer();
boolean flag = false; char[] ca = str.toCharArray();
for (int i = 0; i < ca.length; i++) {
if (ca[i] == '"' && !flag) {
flag = true;
} else if (ca[i] == '"' && flag) {
flag = false;
} else if (ca[i] == ',' && !flag) {
result.add(sb.toString());
sb.delete(0, sb.length());
continue;
}
sb.append(ca[i]);
}
result.add(sb.toString()); System.out.println(result);
}

Answer 20

结果[1, "123", "12,33", 7a, "s1,c4,t7s", ccc, "ss", 2]

Answer 21

用正则其实效率不一定高，而且不好维护，自己循环扩展性比较好。
修改了一下正则的方法，追加了，，，等连续，的判断import java.util.*;
import java.util.regex.*;
public class SCT {
    public static void main(String[] args) {
        //测试数据[1][2]["33,22"][4][5][6][][][]["33,22][""][]
        String s = "1,2\"33,22\",4,5,6,,,,\"3,22\",\"\",";
        Pattern p = Pattern.compile("(\".*?(,.*?)*\")|(.*?([^,\"])*)");
        Matcher m = p.matcher(s);
        List<String> result = new ArrayList<String>();
        int end=0;
        while(m.find()) {
            if (m.end(0)-end > 0) { //判断捕获组的结束位置和上次位置是否有变化
                result.add(m.group(0));
                end = m.end(0);
            }
        }
        System.out.println(result.size());
        System.out.println("----------");
        for (String ss : result) {
            System.out.printf("[%s]\n", ss);
        }
    }
}

Answer 22

漏了一种情况，就是[]在最前的情况，再次修改import java.util.regex.*;
public class SCT {
    public static void main(String[] args) {
        //测试数据[][1][2]["33,22"][4][5][6][][][]["33,22][""][]
        String s = ",1,2\"33,22\",4,5,6,,,,\"3,22\",\"\",";
        Pattern p = Pattern.compile("(\".*?(,.*?)*\")|(.*?([^,\"])*)");
        Matcher m = p.matcher(s);
        List<String> result = new ArrayList<String>();
        int end=0;
        while(m.find()) {
            if (end==0 || m.end(0)-end > 0) { //仅修改此处
                result.add(m.group(0));
                end = m.end(0);
            }
        }
        System.out.println(result.size());
        System.out.println("----------");
        for (String ss : result) {
            System.out.printf("[%s]\n", ss);
        }
    }
}