楼主的具体没怎么看，这是我写的一个，把数据分为几种情况，每种情况对应那些修复的方式，希望有帮助
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class Test3 {
private List<Integer> noKnow = new ArrayList<Integer>();
public static void main(String[] args) {
List<Data> list = new Test3().getFileData();
new Test3().doWork(list);
}
/**
* 一个未知数的："?;0;double"(1)、"0;?;double"(2)、"0;double;?"(3)、"double;0;?"(4)、"0;0;?"(5)（定义常量分别对应模糊信息）
* 两个未知数的："0;?;?"(6)、"?;0;?"(7)、"?;?;double(8)(由于收入和支出不能同时为非零值，因此可以转换成一个未知数的形式)"
* 三个未知数的："?;?;?"(9)(由于收入和支出不能同时为非零值，因此可以转换成两个个未知数的形式)
* 1.其中（1、2、8）必须通过上行记录才能确认
* 2.其中（3、4、5）既可以通过上行记录，也可以通过下行记录进行修复
* 3.其中（6、7、9）需先通过下行记录修复余额，在通过上行记录修复剩余的问题
* 4.若出现互斥需要，则该数据不能修复，例如上行数据需要通过本行数据修复余额，而本行数据需要上行修复支出或者收入
* @param sourceData
* @param index
* @param next
* @param last
* @param disData
*/
void doWork(List<Data> sourceData){
if(sourceData!=null && sourceData.size()>0){
for(int i=0;i<sourceData.size();i++){
Data data = sourceData.get(i);
if(data.isKnow()){
//doNothing 若是数据是正常的、没有模糊，则不修复
}else{
int version = data.getVersion();
boolean flag = false;
switch (version) {
case 1:
toLastWork(data, i, sourceData);
break;
case 2:
toLastWork(data, i, sourceData);
break;
case 8:
toLastWork(data, i, sourceData);
break;
case 3:
//先进行下行记录修复，若下行记录不是完整的或者没有下行记录，则通过上行记录修复
if(i+1<sourceData.size() && sourceData.get(i+1).isKnow()){
flag = doNext(data, i, sourceData);
}
if(!flag){//若没有通过下行记录修复，则通过上行记录进行修复
toLastWork(data, i, sourceData);
}
break;
case 4:
//先进行下行记录修复，若下行记录不是完整的或者没有下行记录，则通过上行记录修复
if(i+1<sourceData.size() && sourceData.get(i+1).isKnow()){
flag = doNext(data, i, sourceData);
}
if(!flag){//若没有通过下行记录修复，则通过上行记录进行修复
toLastWork(data, i, sourceData);
}
break;
case 5:
//先进行下行记录修复，若下行记录不是完整的或者没有下行记录，则通过上行记录修复
if(i+1<sourceData.size() && sourceData.get(i+1).isKnow()){
flag = doNext(data, i, sourceData);
}
if(!flag){//若没有通过下行记录修复，则通过上行记录进行修复
toLastWork(data, i, sourceData);
}
break;
case 6:
flag = doNext(data, i, sourceData);
if(flag){//若果先通过下行修复了本行的余额了，则再通过上行修复本行的支出或者收入
toLastWork(data, i, sourceData);
}
break;
case 7:
flag = doNext(data, i, sourceData);
if(flag){//若果先通过下行修复了本行的余额了，则再通过上行修复本行的支出或者收入
toLastWork(data, i, sourceData);
}
break;
case 9:
flag = doNext(data, i, sourceData);
if(flag){//若果先通过下行修复了本行的余额了，则再通过上行修复本行的支出或者收入
toLastWork(data, i, sourceData);
}
break;
default:
break;
}
}
}
//对修复过的数据进行检查，看是否对整个账单都已完成修复，否则继续迭代修复
boolean isKnow = true;
for(Data data : sourceData){
if(!data.isKnow()){
isKnow = false;
break;
}
}
//如果没有完全修复，则进行下一轮的修复，知道完全修复
if(!isKnow){
doWork(sourceData);
}else{
for(Data data : sourceData){
System.out.println(data.getId()+";\t"+data.getIncome()+";\t"+data.getPay()+";\t"+data.getBalance()+"\t"+data.getDesc());
}
}
}
}
/**
* 根据上一行修复本行数据
* @param data
* @param index
* @param sourceData
* @return
*/
boolean toLastWork(Data data, int index,List<Data> sourceData ){
//是否已修复
boolean isRepair = false;
//上行数据
if(index-1<0){
data.setDesc("\t 没有上行记录，不能修复该行数据");
data.setKnow(true);//标记为已修复
data.setHasDeal(false);
sourceData.set(index, data);
isRepair = true;
}else{Data lastData = sourceData.get(index-1);
int lastVersion = lastData.getVersion();
int version = data.getVersion();
if(lastData.isKnow() && data.isHasDeal()){
if(lastData.getBalance()!=null){
if(version == 3||version == 4||version == 5){
double balance = Double.parseDouble(lastData.getBalance()) + Double.parseDouble(data.getIncome())-Double.parseDouble(data.getPay());
data.setBalance(balance+"");
}else{//上行的余额 - 本次余额
double num = Double.parseDouble(lastData.getBalance())-Double.parseDouble(data.getBalance());
if(num < 0){//表示本次记录是收入，则支出为0，应对version为8的情况，分不清收入和支付那个为零
data.setIncome(Math.abs(num)+"");
data.setPay("0.00");
}else{
data.setIncome(0+".00");
data.setPay(num+"");
}
}data.setKnow(true);
isRepair = true;
}else{//若果上行的余额是模糊的，且上行是不能再进行修复处理的
if(!lastData.isHasDeal()){
data.setDesc("\t 由于上行记录需要本行记录进行数据修复，出现互斥需求，因此本行数据不能修复");
data.setKnow(true);
data.setVersion(0);
data.setHasDeal(false);
sourceData.set(index, data);
}
}
}else{
if(lastVersion==6||lastVersion==7||lastVersion==9){
data.setDesc("\t 由于上行记录需要本行记录进行数据修复，出现互斥需求，因此本行数据不能修复");
data.setKnow(true);
data.setVersion(0);
data.setHasDeal(false);
sourceData.set(index, data);
}
}
}
sourceData.set(index, data);
return isRepair;
}
/**
* 通过下行修复,只修复余额
*/
boolean doNext(Data data, int index,List<Data> sourceData ){
//是否已修复
boolean isRepair = false;
if(index+1>sourceData.size()){
data.setDesc("\t 没有下行记录，不能修复该行数据");
data.setKnow(true);//标记为已修复
//标记为不可再修复
data.setHasDeal(false);
sourceData.set(index, data);
isRepair = true;
}else{
Data nextData = sourceData.get(index+1);
int version = data.getVersion();
int nextVersion = nextData.getVersion();
if(nextData.isKnow() && data.isHasDeal()){
if(nextData.getBalance()!=null){
double balance = Double.parseDouble(nextData.getBalance())-Double.parseDouble(nextData.getIncome())+Double.parseDouble(nextData.getPay());
data.setBalance(balance+"");
if(version == 3 || version == 4 || version == 5 ){//只有余额这个数据模糊，则修复完成
data.setKnow(true);
sourceData.set(index, data);
isRepair = true;
}else{//否则进队data进行信息补录，并修改对应的version
if(version == 6){//0;?;? 修复余额后对应情况为0;?;double
data.setVersion(2);
isRepair = true;
}else if(version == 7){
isRepair = true;
data.setVersion(1);
}else{
isRepair = true;
data.setVersion(8);
}
}
}else{//若下行的余额模糊，且下行不能进行修复，则本行不能进行修复
data.setDesc("\t 由于下行记录需要本行记录进行数据修复，出现互斥需求，因此本行数据不能修复");
data.setKnow(true);
data.setHasDeal(false);
data.setVersion(0);
sourceData.set(index, data);
}
}else{
//若出现互斥需要，则不修复，并将该数据设置为永不可修复，以免迭代死循环
if(nextVersion == 1||nextVersion == 2||nextVersion == 8){
data.setDesc("\t 由于下行记录需要本行记录进行数据修复，出现互斥需求，因此本行数据不能修复");
data.setKnow(true);
data.setHasDeal(false);
data.setVersion(0);
sourceData.set(index, data);
}
}
}
return isRepair;
}
public List<Data> getFileData(){
File file = new File("c:/test.txt");
List<Data> list = new ArrayList<Data>();
FileInputStream fis;
try {
fis = new FileInputStream(file);
BufferedReader br = new BufferedReader(new InputStreamReader(fis,"utf-8"));
String temp;
int i=0;
while ((temp=br.readLine())!=null){
String[] array = temp.split(";");
if(array.length==4){
Data data = new Data();
int id = Integer.parseInt(array[0]);
String income =array[1].equals("?")?null : array[1];
String pay =array[2].equals("?")?null : array[2];
String balance =array[3].equals("?")?null : array[3];
data.setId(id);
//根据收入和支出不能同时为非零值，对数据进行处理，消除double;?;x和?;double;x(double代表非零值，x代表不需要考虑的是否是模糊值)
if(income!=null && Double.parseDouble(income)!=0){
pay ="0.00";
}else if(pay!=null && Double.parseDouble(pay)!=0 ){
income = "0.00";
}
//对数据进行预处理，处理后模糊的只会是9种形式
//一个未知数的："?;0;double"(1)、"0;?;double"(2)、"0;double;?"(3)、"double;0;?"(4)、"0;0;?"(5)（定义常量分别对应模糊信息）
//两个未知数的："0;?;?"(6)、"?;0;?"(7)、"?;?;double(8)(由于收入和支出不能同时为非零值，因此可以转换成一个未知数的形式)"
//三个未知数的："?;?;?"(9)(由于收入和支出不能同时为非零值，因此可以转换成两个个未知数的形式)
if(income==null && "0.00".equals(pay) && balance!=null){
data.setVersion(1);
data.setKnow(false);
}else if(pay==null && "0.00".equals(income) && balance!=null){
data.setVersion(2);
data.setKnow(false);
}else if(pay!=null && !"0.00".equals(pay) && "0.00".equals(income) && balance==null){
data.setVersion(3);
data.setKnow(false);
}else if(income!=null && !"0.00".equals(income)&& "0.00".equals(pay) && balance==null){
data.setVersion(4);
data.setKnow(false);
}else if("0.00".equals(income)&& "0.00".equals(pay) && balance==null){
data.setVersion(5);
data.setKnow(false);
}else if("0.00".equals(income)&& pay==null && balance==null){
data.setVersion(6);
data.setKnow(false);
}else if("0.00".equals(pay)&& income==null && balance==null){
data.setVersion(7);
data.setKnow(false);
}else if(pay==null && income==null && balance!=null){
data.setVersion(8);
data.setKnow(false);
}else if(pay==null && income==null && balance==null){
data.setVersion(9);
data.setKnow(false);
}
data.setIncome(income);
data.setPay(pay);
data.setBalance(balance);
list.add(data);
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return list;
}
}
