求救：字符串分割问题，头疼

Question

我有一个数据文件要处理，文件的数据是逗号分割，但是数据内容本身可能有逗号（当然数据中的逗号有双引号包围的），数据也可能换行，比如：
11,23,34,"df,sd
sdsfsdsd,sdsd
sdsd",23
这个数据有五个字段，处理起来很头痛呀哪位大侠有高招？

Answer 1

replace "," to another signthen split(",")

Answer 2

先检查第一个字符是否为双引号, 设置标志flag.
然后用一个双引号(")进行分割字符串, 这样就得到了
s1=11,23,34,
s2=df,sd
sdsfsdsd,sdsd
sdsd
s3=,23然后再根据得到的标志flag, 判断哪些逗号应该去除.
比如, 如果flag为假, 也就是第一个符号不是双引号, 那么就要删除奇数位的字符串中的逗号(实际程序中下标从0开始, 就是0,2,..,2n), 也就是再对这些字符串使用逗号(,)进行分割, 得到:
s11=11, s12=23,s13=34
....

Answer 3

如果你的数据文件中没有引号存在的话，可以考虑先用split()方法分隔开，然后遍历每一个元素，如果元素中存在引号，则将当前元素与下一个有引号的元素合并。

Answer 4

public static void main(String args[]){
        String str = "11,23,34,\"df,sd";
str+="sdsfsdsd,sdsd";
str+="sdsd\",23";
System.out.println(str);

StringBuffer sb= new StringBuffer();
        java.util.regex.Pattern p=java.util.regex.Pattern.compile("(\"[^\"]+\")",java.util.regex.Pattern.DOTALL) ;
        java.util.regex.Matcher m=p.matcher(str);
        while(m.find()){ 
             m.appendReplacement(sb,m.group(1).replace(',','¤'));
        }
        m.appendTail(sb);
        System.out.println();
        String arr[]=sb.toString().split(",");
for(int i=0;i<arr.length;i++){
    arr[i]=arr[i].replace('¤',',');
}
System.out.println(java.util.Arrays.toString(arr));
    }

Answer 5

这样的做法貌似不符合LZ的要求吧？你这个是把所有的数据组合在一起了，而LZ是读文件的，应该是readLine();他不可能把所有数据都读出来然后再组合在一起来处理吧。

Answer 6

先把引号里的逗号用一个不可能出现的字符串替换，然后再split，然后再把那个特殊字符换回正常的。很简单啊。

Answer 7

如果数据量不大，就读出来处理呗。
如果数据量大，就每次读n个字节，去掉尾端与后续串相连的部分进行处理（或者保存起来）。
然后下次再从上次处理过的最后一条后面开始读n个字节。
RandomAccessFile的seek可以做到。

Answer 8

如果用替换引号中的逗号的话有可能存在bug，如果字符串本身存在替换的字符那么结果将会会先问题/**
我有一个数据文件要处理，文件的数据是逗号分割，但是数据内容本身可能有逗号（当然数据中的逗号有双引号包围的），数据也可能换行，比如：
11,23,34,"df,sd
sdsfsdsd,sdsd
sdsd",23
这个数据有五个字段，处理起来很头痛呀哪位大侠有高招？
*///package com.ricky.www;import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;public class Test{
public static void main(String[] args){
String content = "11,23,34,\"df,sd\nsdsfsdsd,sdsd\nsdsd\",23";
int i = 1;
for(Object str : getArray(content).toArray()){
System.out.println(i ++ + " : " + str);
}
} public static ArrayList<String> getArray(String content){
ArrayList<String> list = new ArrayList<String>();

//分两种情况来分析，一种是"fdfdf,dfdf"的，一种是不包含引号dfjdfd,dfkdf的（当然这里可能存在更加复杂的比如：dlfjd"dfd,fdf"
//     ,这里暂不做讨论，如果有需要可以直接联系我）
String regex = "((\"[^\"]*\")|([^\",]+)),?";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(content);
while(matcher.find()){
list.add(matcher.group(1));
} return list;
}
}

Answer 9

我说下我的处理方式，我们项目中也实际做过这种文件的处理首先把你读到的一行数据转换成字符数组 eg： char[] a = tmpLine.toCharArray();
这时候从头开始读，当读到一个逗号的时候，将逗号之前的内容作为一列的值，
当读到引号的时候就一直读到下一个引号出现位置，之间的内容作为列的值，之后在找逗号以此类推

Answer 10

public static void main(String[] args) {
                //假设这是readline得到的一行
String str="11,23,34,\"df,sdsdsfsdsd,sdsdsdsd\",23";
String[] array=str.split("(?<!\"),");
System.out.println(Arrays.toString(array));
}

Answer 11

package houlei.csdn.java.io;
import java.io.IOException;
import java.io.Reader;/**
 * @author 侯磊
 */
public class StringDataReader extends java.io.Reader{    private static final char separatorChar = ',';
    private static final char escapeChar = '"';    private Reader in;    private boolean hasEscapeChar = false;
    
    public StringDataReader(Reader in) {
        this.in = in;
    }    @Override
    public int read(char[] cbuf, int off, int len) throws IOException {
        return in.read(cbuf, off, len);
    }    @Override
    public void close() throws IOException {
        in.close();
    }    public synchronized String readData() throws IOException{
        StringBuilder buff = new StringBuilder();
        char [] oneChar = new char[1];
        hasEscapeChar = false;
        int count = 0;
        while(true){
            count = in.read(oneChar);
            if(count!=1)return null;
             if(oneChar[0]==escapeChar){
                hasEscapeChar = !hasEscapeChar;
                continue;
             }
             if(!hasEscapeChar){
                 if(oneChar[0]==separatorChar){
                     break;
                 }
             }
            buff.append(oneChar);
        }
        return buff.toString();
    }    public static void main(String args []){
        String str = "11,23,34,\"df,sd\nsdsfsdsd,sdsd\nsdsd\",23";
        java.io.StringReader reader = new java.io.StringReader(str);
        StringDataReader sdr = new StringDataReader(reader);
        String data = null;
        try {
            while ((data = sdr.readData()) != null) {
                System.out.println("["+data+"]");
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

Answer 12

public static void main(String args[]){
    BufferedReader br = new BufferedReader(new FileReader("file+dir"));
    String titleLine = br.readLine();
    String titles [] = titleLine.split("\t|\,");
    StringDataReader  reader = new StringDataReader(br);
    String datas [] = null;
    int index = 0;
    try{
        for(String data = null;(data=reader.readData())!=null;){
            if(datas==null){datas = new String[titles.length];index=0;}
            datas[index++]=data;
            if(index>=titles.length){dealRecord(datas);datas=null;}
        }
    }catch(Exception e){e.printStackTrace();}
}
private static void dealRecord(String datas[]){
    for(int i=0;i<datas.length;){
        System.out.print(datas[i++]+"\t");
        if(i>=datas.length)System.out.println();
    }
}

Answer 13

只是用java代码去判断太麻烦，而且代码不简介。可以选择用正则