33,027
社区成员
发帖
与我相关
我的任务
分享我想知道我错哪里了（CSDN英雄会——一份“奇妙”的银行流水）
http://hero.csdn.net/Question/Details?ID=633&ExamID=628&from=4
题目详情:
一份银行流水数据，因打印模糊导致部分金额不清楚。
收入、支出、余额满足以下3条规则：
1、收入、支出、余额三列都是数字
2、同一行收入和支出的值不能同时为非零值
3、第N-1行余额(+第N行收入或-第N行支出)=第N行余额
程序语言： java
请按照规则编写算法，修复不清楚的值
输入描述：
输入数据最多25行，每行都包含四个数据，分别是：数据编号，收入、支出、余额，模糊的数据以?表示，它们之间以;隔开。
以文件结尾。第一组数据为初始数据值，收入、支出、余额数据保留2位小数。
输出描述：
以输入的数据顺序输出修复后的数据。
答题说明:
输入样例:
流水记录ID;收入;支出;余额
1;0.00;51.90;1945.45
2;0.00;1000.00;?
输出样例：
流水记录ID;收入;支出;余额
1;0.00;51.90;1945.45
2;0.00;1000.00;945.45
题目详情:
一份银行流水数据，因打印模糊导致部分金额不清楚。
收入、支出、余额满足以下3条规则：
1、收入、支出、余额三列都是数字
2、同一行收入和支出的值不能同时为非零值
3、第N-1行余额(+第N行收入或-第N行支出)=第N行余额
程序语言： java
请按照规则编写算法，修复不清楚的值
输入描述：
输入数据最多25行，每行都包含四个数据，分别是：数据编号，收入、支出、余额，模糊的数据以?表示，它们之间以;隔开。
以文件结尾。第一组数据为初始数据值，收入、支出、余额数据保留2位小数。
输出描述：
以输入的数据顺序输出修复后的数据。
答题说明:
输入样例:
流水记录ID;收入;支出;余额
1;0.00;51.90;1945.45
2;0.00;1000.00;?
输出样例：
流水记录ID;收入;支出;余额
1;0.00;51.90;1945.45
2;0.00;1000.00;945.45
import java.util.Scanner;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
FinalItem[] list = new FinalItem[25];
Boolean hasUnknown;
Integer id;
Double a, b, d;
Boolean[] known = new Boolean[25];
int size = 0;
while (sc.hasNextLine()) {
String line = sc.nextLine();
String[] record = line.split(";");
hasUnknown = false;
id = Integer.parseInt(record[0]);
if (!record[1].equals("?")) {
a = Double.parseDouble(record[1]);
} else {
a = null;
}
if (!record[2].equals("?")) {
b = Double.parseDouble(record[2]);
} else {
b = null;
}
if (!record[3].equals("?")) {
d = Double.parseDouble(record[3]);
} else {
d = null;
}
if (a != null && a != 0d && b == null) {
b = 0d;
} else if (b != null && b != 0d && a == null) {
a = 0d;
}
hasUnknown = a == null || b == null || d == null;
known[size] = !hasUnknown;
list[size] = new FinalItem(hasUnknown, id, a, b ,d);
++size;
}
Boolean allDone = false;
while (!allDone) {
allDone = true;
if (size > 1 && known[0] && !known[1]) {
if (!list[1].fixFromAbove(list[0])) {
allDone = false;
} else {
known[1] = true;
}
}
if (size > 1 && known[size - 1] && !known[size - 2]) {
if (!list[size - 2].fixFromBellow(list[size - 1])) {
allDone = false;
} else {
known[size - 2] = true;
}
}
for (int i = 1; i < size - 1; ++i) {
if (known[i] && (!known[i - 1] || !known[i + 1])) {
if (known[i] && !known[i + 1]) {
for (int j = i; j < size - 1; ++j) {
if (known[j + 1])
continue;
if (!list[j + 1].fixFromAbove(list[j])) {
allDone = false;
break;
} else {
known[j + 1] = true;
}
}
}
if (known[i] && !known[i - 1]) {
for (int j = i; j > 0; --j) {
if (known[j - 1])
continue;
if (!list[j - 1].fixFromBellow(list[j])) {
allDone = false;
break;
} else {
known[j - 1] = true;
}
}
}
}
}
}
for (int i = 0; i < size; ++i) {
System.out.printf("%d;%.2f;%.2f;%.2f\n", list[i].id, list[i].a, list[i].b, list[i].d);
}
sc.close();
return;
}
}
class FinalItem {
Boolean hasUnknown = false;
Integer id = 0;
Double a = null;
Double b = null;
Double c = null;
Double d = null;
FinalItem(Boolean hasUnknown, Integer id, Double a, Double b, Double d) {
this.hasUnknown = hasUnknown;
this.id = id;
this.a = a;
this.b = b;
this.d = d;
if (!this.hasUnknown)
this.c = this.b + this.d - this.a;
}
Boolean fixFromAbove(FinalItem ft) {
Double c = ft.d;
if (c == null)
return false;
this.c = c;
if (this.hasUnknown) {
if (this.a == null && this.b != null && this.d != null) {
this.a = this.b + this.d - this.c;
this.hasUnknown = false;
} else if (this.b == null && this.a != null && this.d != null) {
this.b = this.c + this.a - this.d;
this.hasUnknown = false;
} else if (this.d == null && this.a != null && this.b != null) {
this.d = this.c + this.a - this.b;
this.hasUnknown = false;
}
if (this.d != null) {
Double diff = this.c - this.d;
if (diff > 0) {
this.b = diff;
this.a = 0d;
} else {
this.a = -diff;
this.b = 0d;
}
this.hasUnknown = false;
}
return !this.hasUnknown;
} else
return !this.hasUnknown;
}
Boolean fixFromBellow(FinalItem ft) {
Double d = ft.c;
if (d == null)
return false;
if (this.hasUnknown) {
this.d = d;
if (this.a != null && this.b != null) {
if (this.c == null) {
this.c = this.b + this.d - this.a;
}
this.hasUnknown = false;
}
if (this.c != null) {
Double diff = this.c - this.d;
if (diff > 0) {
this.b = diff;
this.a = 0d;
} else {
this.a = -diff;
this.b = 0d;
}
this.hasUnknown = false;
}
return !this.hasUnknown;
} else
return !this.hasUnknown;
}
}
...全文
请发表友善的回复…
发表回复
lightbaby35 2014-09-25
- 打赏
- 举报
看了wylyf3030的code,发现一个小问题，当执行doNext方法时：
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+"");
下一条记录是不是有可能是无法修复的，无法修复isKnow == true, 所以当income & pay 为null的时候应该会出错。
kennypku 2014-09-10
- 打赏
- 举报
楼上的可以通过poj么？
wylyf3030 2014-09-04
- 打赏
- 举报
/**
* 封装每条明细为一个对象
* @author
*
*/
class Data{
int id=0;
String income =null;
String pay =null;
String balance =null;
boolean isKnow = true;
//是否还可以再修复
boolean hasDeal = true;
String desc="";
//是否需要向上查询来修复本行数据
int version = 0;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public boolean isKnow() {
return isKnow;
}
public void setKnow(boolean isKnow) {
this.isKnow = isKnow;
}
public String getIncome() {
return income;
}
public void setIncome(String income) {
this.income = income;
}
public String getPay() {
return pay;
}
public void setPay(String pay) {
this.pay = pay;
}
public String getBalance() {
return balance;
}
public void setBalance(String balance) {
this.balance = balance;
}
public int getVersion() {
return version;
}
public void setVersion(int version) {
this.version = version;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public boolean isHasDeal() {
return hasDeal;
}
public void setHasDeal(boolean hasDeal) {
this.hasDeal = hasDeal;
}
}wylyf3030 2014-09-04
- 打赏
- 举报
楼主的具体没怎么看，这是我写的一个，把数据分为几种情况，每种情况对应那些修复的方式，希望有帮助
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;
}
}
kennypku 2014-09-03
- 打赏
- 举报
这题目我也怎么都提交不过去, 感觉题目还行, 就是输入输出的CASE说明有点模糊
nice_cxf 2014-09-01
- 打赏
- 举报
大概都没考虑第一行有未知数据的问题
先要找到第一个数据全的行，然后先反向向上递推所有未知数据，在向下递推所有数据
dadadidixh 2014-09-01
- 打赏
- 举报
看不出来哪错了，下面这些是我写的，也错了~~
package csnd.challenge;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
public class Main {
final static List<String[]> data_list = new ArrayList<String[]>();
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String data = "";
System.out.println("请输入数据：\n编号;收入;支出;余额");
final BufferedReader br = new BufferedReader(new InputStreamReader(
System.in));
try {
while (!(data = br.readLine()).equals("go")) {
System.out.println(showMessage(data));
}
br.close();
} catch (final Exception e) {
e.getMessage();
}
Main.list();
}
public static String showMessage(String data){
int flag = Main.checkData(data);
String message = "ok，下一条！";
switch (flag) {
case 0:
String a[] = data.split(";");
data_list.add(a);
break;
case 1:
message = "编号不合法，必须为整数！";
break;
case 2:
message = "收入数据不合法，确保是数字并且留有两位小数！";
break;
case 3:
message = "支出数据不合法，确保是数字并且留有两位小数！";
break;
case 4:
message = "余额数据不合法，确保是数字并且留有两位小数！";
break;
case 5:
message = "收入和支出中必须有一个为0.00！";
break;
case 6:
message = "收入、支出、余额中不能同时存在两个未知数！";
break;
case 7:
message = "第一条数据必须为完整数据，不能有未知数！";
break;
case 8:
message = "最多输入25条！";
break;
case 9:
message = "请输入正确的格式！如1;12.36;25.22;96.36";
break;
default:
break;
}
return message;
}
public static int checkData(String data){
int error = 0;
try{
String temp[] = data.split(";");
if(temp.length != 4 ){
error = 9;
}else
if(!Main.checkInt(temp[0])){
error = 1;
}else
if(!Main.checkDouble(temp[1])){
error = 2;
}else
if(!Main.checkDouble(temp[2])){
error = 3;
}else
if(!Main.checkDouble(temp[3])){
error = 4;
}else
if(Main.checkDouble(temp[1]) && Main.checkDouble(temp[2]) && Main.checkDouble(temp[3])){
if(!Main.checkIsZero(temp[1], temp[2])){
error = 5;
}else
if(!Main.checkIsUnknow(temp[1], temp[2], temp[3])){
error = 6;
}
}
if(data_list.size() == 0){
if(data.contains("?")){
error = 7;
}
}else if(data_list.size() == 25){
error = 8;
}
}catch(Exception e){
error = 9;
}
return error;
}
public static boolean checkInt(String no){
try{
Integer temp = Integer.parseInt(no);
if(temp instanceof Integer){
return true;
}
return false;
}catch(Exception e){
return false;
}
}
public static boolean checkDouble(String no){
try{
if(no.equals("?")){
return true;
}
if(!no.contains(".")){
return false;
}
int isDouble = no.substring(no.indexOf(".") + 1).length();
if(isDouble != 2){
return false;
}
DecimalFormat df = new DecimalFormat("0.00");
df.format(Double.parseDouble(no));
return true;
}catch(Exception e){
return false;
}
}
public static boolean checkIsZero(String in,String out){
double in_ = 0.00 ;
double out_ = 0.00 ;
try{
if(!in.equals("?")){
in_ = Double.parseDouble(in);
}
if(!out.equals("?")){
out_ = Double.parseDouble(out);
}
if(in_ != 0.00 && out_ != 0.00){
return false;
}
}catch(Exception e){
return false;
}
return true;
}
public static boolean checkIsUnknow(String in,String out,String balance){
try{
if(in.equals("?") && out.equals("?")){
return false;
}else if(in.equals("?") && balance.equals("?")){
return false;
}else if(balance.equals("?") && out.equals("?")){
return false;
}
}catch(Exception e){
return false;
}
return true;
}
public static void list(){
String a[];
String b[];
String c = "";
DecimalFormat df = new DecimalFormat("0.00");
for(int i = 0;i<data_list.size();i++){
if((i+1) == data_list.size()){
break;
}
a = data_list.get(i);
b = data_list.get(i+1);
if(b[1].equals("?")){
c = Double.parseDouble(b[3]) - Double.parseDouble(a[3]) + "";
String c_ = df.format(Double.parseDouble(c));
b = new String[]{b[0],c_,b[2],b[3]};
}else if(b[2].equals("?")){
c = Double.parseDouble(a[3]) - Double.parseDouble(b[3]) + "";
String c_ = df.format(Double.parseDouble(c));
b = new String[]{b[0],b[1],c_,b[3]};
}else if(b[3].equals("?")){
c = Double.parseDouble(a[3]) + Double.parseDouble(b[1]) + Double.parseDouble(b[2]) + "";
String c_ = df.format(Double.parseDouble(c));
b = new String[]{b[0],b[1],b[2],c_};
}
data_list.set(i+1, b);
}
Main.result();
}
public static void result(){
StringBuffer sb = new StringBuffer();
for(int i = 0;i<data_list.size();i++){
String data[] = data_list.get(i);
sb.append(data[0] +";"+ data[1] +";"+ data[2] +";"+ data[3] + "\n");
}
System.out.println("编号;收入;支出;余额\n" + sb.toString());
}
}
会飞的猪猪萌萌哒 2014-09-01
- 打赏
- 举报
我想是不是id列也有？的，这样就会Integer.parse抛异常了。
会飞的猪猪萌萌哒 2014-09-01
- 打赏
- 举报
我的考虑过了，从已知行上下扫描的。这个代码没写表头，提交的代码表头也写了，还是运行时错误，估计访问了null，但我代码看不出哪里会访问null
