莫名其妙的For input string: ““异常以及\r\n和\n\r的区别

小鱼儿 2023-01-04 14:34 124阅读 0赞

## 问题描述 ##

今天在学习数据算法与结构的过程中，遇到了如下bug（主要是从磁盘读取稀疏数组文件时发生的）：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ3OTUzODU1_size_16_color_FFFFFF_t_70]

**代码如下：**

package com.fufu.sparsearray;
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.OutputStream;
    
    public class SparseArray { 
    	public static void main(String[] args) { 
    		//创建一个原始的二维数组(11*11)
    		//0表示没有棋子，1表示黑子，2表示白子
    		int chessArr1[][] = new int[11][11];
    		chessArr1[1][2] = 1;
    		chessArr1[2][3] = 2;
    		chessArr1[4][5] = 1;
    		chessArr1[7][8] = 2;
    		//输出原始的二维数组
    		System.out.println("原二维数组：");
    		for(int[] row:chessArr1) { 
    			for(int data:row) { 
    				System.out.printf("%d\t",data);
    			}
    			System.out.println();
    		}
    		
    		//将二维数组转为稀疏数组
    		//1.先遍历二维数组得到非0数据的个数
    		int sum = 0;
    		for(int i=0;i<chessArr1.length;i++) { 
    			for(int j=0;j<chessArr1[i].length;j++) { 
    				if(chessArr1[i][j]!=0) { 
    					sum++;
    				}
    			}
    		}
    		
    		//2.根据得到的非0个数创建稀疏数组
    		int sparseArr[][] = new int[sum+1][3];
    		//给稀疏数组赋值
    		sparseArr[0][0] = chessArr1.length;
    		sparseArr[0][1] = chessArr1[0].length;
    		sparseArr[0][2] = sum;
    		
    		//遍历二维数组,将非0的数据存放到sparseArr中
    		int count = 0;
    		for(int i=0;i<chessArr1.length;i++) { 
    			for(int j=0;j<chessArr1[i].length;j++) { 
    				if(chessArr1[i][j]!=0) { 
    					count++;//稀疏数组第一行已经赋值，所以需要从第二行开始
    					sparseArr[count][0] = i;
    					sparseArr[count][1] = j;
    					sparseArr[count][2] = chessArr1[i][j];
    				}
    			}
    		}
    		
    		//遍历稀疏数组
    		System.out.println();
    		System.out.println("稀疏数组:");
    		for(int[] row:sparseArr) { 
    			for(int data:row) { 
    				System.out.printf("%d\t",data);
    			}
    			System.out.println();
    		}
    		
    	//将稀疏数组保存到磁盘上
    		FileWriter fileWriter = null;//创建文件输出流用于写出数据
    		try { 
    			//初始化流，并制定输出路径
    			fileWriter = new FileWriter(new File("C:\\Users\\asus\\Desktop\\fufu.data"));
    			//遍历稀疏数组将其数据写出
    			for(int [] array:sparseArr) { 
    				fileWriter.write(array[0]+"\t"+array[1]+"\t"+array[2]);
    				fileWriter.write("\n\r");
    			}
    		}catch (IOException e) { 
    			e.printStackTrace();
    		}catch(Exception e) { 
    			e.printStackTrace();
    		}finally { 
    			try { 
    				fileWriter.close();
    			} catch (IOException e) { 
    				e.printStackTrace();
    			}
    		}
    		
    	//从磁盘上读取稀疏数组
    		int[][] sparseArr1 = null;
    		BufferedReader bufferedReader = null;
    		boolean isNotRead = false;
    		int cou = 0;
    		try { 
    			bufferedReader = new BufferedReader(new FileReader(new File("C:/Users/asus/Desktop/fufu.data")));
    			String lineStr = null;
    			int len = 0;
    			while((lineStr=bufferedReader.readLine())!=null) { 
    				String [] tempStr = lineStr.split("\t");//读取一行的数据，分割制表符获取数据的数组
    				System.out.println("数组长度"+tempStr.length);
    				if(!isNotRead) { 
    					sparseArr1 = new int[Integer.parseInt(tempStr[2])+1][3];
    					sparseArr1[cou][0] = Integer.parseInt(tempStr[0]); 
    					sparseArr1[cou][1] = Integer.parseInt(tempStr[1]);
    					sparseArr1[cou][2] = Integer.parseInt(tempStr[2]);
    					cou++;
    					isNotRead = true;
    				}else { 
    					System.out.println("数组长度"+tempStr.length);
    					sparseArr1[cou][0] = Integer.parseInt(tempStr[0]); 
    					sparseArr1[cou][1] = Integer.parseInt(tempStr[1]);
    					sparseArr1[cou][2] = Integer.parseInt(tempStr[2]);
    					cou++;
    				}
    			}
    		} catch (FileNotFoundException e) { 
    			e.printStackTrace();
    		} catch (IOException e) { 
    			e.printStackTrace();
    		}
    		System.out.println();
    		System.out.println("从磁盘读取的稀疏数组：");
    		for(int[] rows:sparseArr1) { 
    			for(int data:rows) { 
    				System.out.printf("%d\t",data);
    			}
    			System.out.println();
    		}
    		
    		
    	//将稀疏数组转换为二维数组
    		//1.根据稀疏数组第一行元素创建二维数组
    		int row = sparseArr[0][0];
    		int cos = sparseArr[0][1];
    		int chessArr2[][] = new int[row][cos];
    		//读取稀疏数组的后几行数据赋值给二维数组
    // chessArr2[sparseArr[1][0]][sparseArr[1][1]] = sparseArr[1][2];
    // chessArr2[sparseArr[2][0]][sparseArr[2][1]] = sparseArr[2][2];
    		//因为在变化的只有行，列永远是固定的写法，及第一列为横坐标，第二列为纵坐标，第三列为值
    		//且第一行存的是列和行，所以读取数据需要从第二行开始，也就是下标1
    		for(int i=1;i<sparseArr.length;i++) { 
    				chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2]; 
    		}
    		
    		System.out.println("恢复后的二维数组：");
    		for(int[] rows:chessArr2) { 
    			for(int data:rows) { 
    				System.out.printf("%d\t",data);
    			}
    			System.out.println();
    		}
    		
    	}
    }

错误显示在114行，下面的部分的代码片段（异常位置用注释在代码中标识了）：

//从磁盘上读取稀疏数组
    		int[][] sparseArr1 = null;
    		BufferedReader bufferedReader = null;
    		boolean isNotRead = false;
    		int cou = 0;
    		try { 
    			bufferedReader = new BufferedReader(new FileReader(new File("C:/Users/asus/Desktop/fufu.data")));
    			String lineStr = null;
    			int len = 0;
    			while((lineStr=bufferedReader.readLine())!=null) { 
    				String [] tempStr = lineStr.split("\t");//读取一行的数据，分割制表符获取数据的数组
    				System.out.println("数组长度"+tempStr.length);
    				if(!isNotRead) { 
    					sparseArr1 = new int[Integer.parseInt(tempStr[2])+1][3];
    					sparseArr1[cou][0] = Integer.parseInt(tempStr[0]); 
    					sparseArr1[cou][1] = Integer.parseInt(tempStr[1]);
    					sparseArr1[cou][2] = Integer.parseInt(tempStr[2]);
    					cou++;
    					isNotRead = true;
    				}else { 
    					System.out.println("数组长度"+tempStr.length);
    					//异常出现的位置
    					sparseArr1[cou][0] = Integer.parseInt(tempStr[0]); 
    					sparseArr1[cou][1] = Integer.parseInt(tempStr[1]);
    					sparseArr1[cou][2] = Integer.parseInt(tempStr[2]);
    					cou++;
    				}
    			}
    		} catch (FileNotFoundException e) { 
    			e.printStackTrace();
    		} catch (IOException e) { 
    			e.printStackTrace();
    		}

开始，我很奇怪，为什么这里会转换失败了，按道理来说，输入流每读取一行数据，都有三个数（稀疏数组默认为3列），转换应该没有问题，于是，我仔细看了异常信息，发现在异常处的Integer.parseInt(tempStr\[0\])，该句代码为空字符串，这就没道理了呀，于是，我在各个分支打印了读取的每一行数据分割之后得到的数组的长度，发现他们竟然不同，打印如下：  
![在这里插入图片描述][20210110171329653.png]  
啊，这？？？？，这是什么情况呢，好，就下来，就是问题的关键了，我打开了我磁盘上的存储稀疏数组的文件，如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ3OTUzODU1_size_16_color_FFFFFF_t_70 1]  
这下，我就明白了，我只分割了\\t,也就是中间的空格，但当我读取到下一行的时候，时空的，没有数据，所以，while在读取下一行的时候，tempStr\[\]只有一个元素，为空字符串，所以这时候会转换失败。

## 问题分析 ##

一般来说，我们在存储数组数据的时候，应该是不需要下面的空字符串的，为什么它会自己存入一个空字符串呢，带着新的疑问，我们来看存储稀疏数组的部分代码：

FileWriter fileWriter = null;//创建文件输出流用于写出数据
    		try { 
    			//初始化流，并制定输出路径
    			fileWriter = new FileWriter(new File("C:\\Users\\asus\\Desktop\\fufu.data"));
    			//遍历稀疏数组将其数据写出
    			for(int [] array:sparseArr) { 
    				fileWriter.write(array[0]+"\t"+array[1]+"\t"+array[2]);
    				fileWriter.write("\n\r");
    			}
    		}catch (IOException e) { 
    			e.printStackTrace();
    		}catch(Exception e) { 
    			e.printStackTrace();
    		}finally { 
    			try { 
    				fileWriter.close();
    			} catch (IOException e) { 
    				e.printStackTrace();
    			}
    		}

看到这，机智如你，相信你已经发现了问题的所在，没错**fileWriter.write("\\n\\r")**，就是这一句代码，在这里，我想说明一下的是，我本意是想用\*\*\\r\\n**来进行回车换行的，当误写成了**\\n\\r\*\*,二者虽然只是简单的换了个顺序，但区别是非常大的，**\\n**表示换行，**\\r**表示回车，**如果是\\n\\r**，那么就是先换行，再回车,换行，会将光标移动到下一行的左边部分，这时候在回车，就会产生一个空格；而**如果是\\r\\n**，在window中\*\*\\r\\n\*\*表示回车换行，具体的效果也就是一个Enter键，如果这里还不清晰的可以参考[\\n\\r\\和r\\n的本质区别][n_r_r_n]；

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ3OTUzODU1_size_16_color_FFFFFF_t_70]: /images/20221119/a8532c4e04a343da885f352b02bbd647.png
[20210110171329653.png]: /images/20221119/61b5214b56b945fda5c3f9de935f83bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ3OTUzODU1_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210110171641219.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ3OTUzODU1,size_16,color_FFFFFF,t_70
[n_r_r_n]: https://blog.csdn.net/amqvje/article/details/38370681