Java基础之IO操作（一）

今天药忘吃喽~ 2022-04-22 11:34 229阅读 0赞

# Java基础之IO操作（一） #

## 一、FileInputStream ##

1.  第一个程序，理解操作步骤

public static void main(String[] args) {
    //1、创建源
    File src = new File("abc.txt");
    //2、选择流
    try {
    	InputStream  is =new FileInputStream(src);
    	//3、操作 (读取)
    	int data1  = is.read(); //第一个数据x
    	int data2  = is.read(); //第二个数据y
    	int data3  = is.read(); //第三个数据z
    	int data4  = is.read(); //文件的末尾返回-1
    	System.out.println((char)data1);
    	System.out.println((char)data2);
    	System.out.println((char)data3);
    	System.out.println(data4);
    	//4、释放资源
    	is.close();
    } catch (FileNotFoundException e) {
    	e.printStackTrace();
    } catch (IOException e) {
    	e.printStackTrace();
    	}
    }

1.  标准操作步骤

//1、创建源
    File src = new File("abc.txt");
    //2、选择流
    InputStream  is =null;
    try {
    	is =new FileInputStream(src);
    	//3、操作 (读取)
    	int temp ;
    	while((temp=is.read())!=-1) {
    		System.out.println((char)temp);
    	}		
    		
    } catch (FileNotFoundException e) {
    	e.printStackTrace();
    } catch (IOException e) {
    	e.printStackTrace();
    }finally {
    	//4、释放资源
    	try {
    		if(null!=is) {
    			is.close();
    		}
    	} catch (IOException e) {
    		e.printStackTrace();
    	}
    }
    }

1.  分段读取

public static void main(String[] args) {
    //1、创建源
    File src = new File("abc.txt");
    //2、选择流
    InputStream  is =null;
    try {
    	is =new FileInputStream(src);
    	//3、操作 (分段读取)
    	byte[] flush = new byte[1024*10]; //缓冲容器
    	int len = -1; //接收长度
    	while((len=is.read(flush))!=-1) {
    		//字节数组-->字符串 (解码)
    		String str = new String(flush,0,len);
    		System.out.println(str);
    	}		
    		
    } catch (FileNotFoundException e) {
    	e.printStackTrace();
    } catch (IOException e) {
    	e.printStackTrace();
    }finally {
    	//4、释放资源
    	try {
    		if(null!=is) {
    			is.close();
    		}
    	} catch (IOException e) {
    		e.printStackTrace();
    	}
    }
    }

## 二、FileOutputStream ##

1.  基础操作

public static void main(String[] args) {
    //1、创建源
    File dest = new File("dest.txt");
    //2、选择流
    OutputStream os =null;
    try {
    	os = new FileOutputStream(dest,true);
    	//3、操作(一次写出)
    	String msg ="IO is so easy\r\n";
    	byte[] datas =msg.getBytes(); // 字符串-->字节数组(编码)
    	os.write(datas,0,datas.length);
    	os.flush();
    }catch(FileNotFoundException e) {		
    	e.printStackTrace();
    }catch (IOException e) {
    	e.printStackTrace();
    }finally{
    	//4、释放资源
    	try {
    		if (null != os) {
    			os.close();
    		} 
    	} catch (Exception e) {
    	}
    }
    }

## 三、FileReader ##

1.  分段读取

public static void main(String[] args) {
    //1、创建源
    File src = new File("abc.txt");
    //2、选择流
    Reader  reader =null;
    	try {
    		reader =new FileReader(src);
    		//3、操作 (分段读取)
    		char[] flush = new char[1024]; //缓冲容器
    		int len = -1; //接收长度
    		while((len=reader.read(flush))!=-1) {
    			//字符数组-->字符串
    			String str = new String(flush,0,len);
    			System.out.println(str);
    		}		
    		
    	} catch (FileNotFoundException e) {
    		e.printStackTrace();
    	} catch (IOException e) {
    		e.printStackTrace();
    	}finally {
    		//4、释放资源
    		try {
    			if(null!=reader) {
    				reader.close();
    			}
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    }

## 四、FileWriter ##

1.  基础操作

public static void main(String[] args) {
    //1、创建源
    File dest = new File("dest.txt");
    //2、选择流
    Writer writer =null;
    try {
    	writer = new FileWriter(dest);
    	//3、操作(写出)
    	//写法一
    //	String msg ="IO is so easy\r\n锄禾日当午";
    //	char[] datas =msg.toCharArray(); // 字符串-->字符数组
    //	writer.write(datas,0,datas.length);
    	//写法二
    	/*String msg ="IO is so easy\r\n锄禾日当午";
    	writer.write(msg);	
    	writer.write("add");		
    	writer.flush();*/
    			
    	//写法三
    	writer.append("IO is so easy\r\n").append("锄禾日当午");
    	writer.flush();
    }catch(FileNotFoundException e) {		
    	e.printStackTrace();
    }catch (IOException e) {
    	e.printStackTrace();
    }finally{
    	//4、释放资源
    	try {
    		if (null != writer) {
    			writer.close();
    		} 
    	} catch (Exception e) {
    	}
    }
    }

## 五、ByteArrayInputStream ##

1.  字节数组输入流（字节数组 不要太大）

public static void main(String[] args) {
    //1、创建源
    byte[] src = "talk is cheap show me the code".getBytes();
    //2、选择流
    InputStream  is =null;
    try {
    	is =new ByteArrayInputStream(src);
    	//3、操作 (分段读取)
    	byte[] flush = new byte[5]; //缓冲容器
    	int len = -1; //接收长度
    	while((len=is.read(flush))!=-1) {
    		//字节数组-->字符串 (解码)
    		String str = new String(flush,0,len);
    		System.out.println(str);
    	}		
    		
    } catch (IOException e) {
    	e.printStackTrace();
    }finally {
    	//4、释放资源
    	try {
    		if(null!=is) {
    			is.close();
    		}
    	} catch (IOException e) {
    		e.printStackTrace();
    	}
    }
    }

## 六、ByteArrayOutputStream ##

1.  基本操作

public static void main(String[] args) {
    //1、创建源
    byte[] dest =null;
    //2、选择流 （新增方法）
    ByteArrayOutputStream baos =null;
    try {
    	baos = new ByteArrayOutputStream();
    	//3、操作(写出)
    	String msg ="show me the code";
    	byte[] datas =msg.getBytes(); // 字符串-->字节数组(编码)
    	baos.write(datas,0,datas.length);
    	baos.flush();
    	//获取数据
    	dest = baos.toByteArray();
    	System.out.println(dest.length +"-->"+new String(dest,0,baos.size()));
    }catch(FileNotFoundException e) {		
    	e.printStackTrace();
    }catch (IOException e) {
    	e.printStackTrace();
    }finally{
    	//4、释放资源
    	try {
    		if (null != baos) {
    			baos.close();
    		} 
    	} catch (Exception e) {
    	}
    }
    }

## 七、字节数组应用 ##

1.  图片读取到字节数组、字节数组写出到文件

public static void main(String[] args) {
    //图片转成字节数组
    	byte[] datas = fileToByteArray("p.png");
    	System.out.println(datas.length);
    	byteArrayToFile(datas,"p-byte.png");		
    }
    	/**
    	 * 1、图片读取到字节数组
    	 * 1)、图片到程序  FileInputStream
    	 * 2)、程序到字节数组	ByteArrayOutputStream
    	 */
    public static byte[] fileToByteArray(String filePath) {
    		//1、创建源与目的地
    		File src = new File(filePath);
    		byte[] dest =null;
    		//2、选择流
    		InputStream  is =null;
    		ByteArrayOutputStream baos =null;
    		try {
    			is =new FileInputStream(src);
    			baos = new ByteArrayOutputStream();
    			//3、操作 (分段读取)
    			byte[] flush = new byte[1024*10]; //缓冲容器
    			int len = -1; //接收长度
    			while((len=is.read(flush))!=-1) {
    				baos.write(flush,0,len);		 //写出到字节数组中			
    			}		
    			baos.flush();
    			return baos.toByteArray();
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}finally {
    			//4、释放资源
    			try {
    				if(null!=is) {
    					is.close();
    				}
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    		return null;		
    	}
    	/**
    	 * 2、字节数组写出到图片
    	 * 1)、字节数组到程序 ByteArrayInputStream
    	 * 2)、程序到文件 FileOutputStream
    	 */
    	public static void byteArrayToFile(byte[] src,String filePath) {
    		//1、创建源
    		File dest = new File(filePath);
    		//2、选择流
    		InputStream  is =null;
    		OutputStream os =null;
    		try {
    			is =new ByteArrayInputStream(src);
    			os = new FileOutputStream(dest);
    			//3、操作 (分段读取)
    			byte[] flush = new byte[5]; //缓冲容器
    			int len = -1; //接收长度
    			while((len=is.read(flush))!=-1) {
    				os.write(flush,0,len);			//写出到文件	
    			}		
    			os.flush();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}finally {
    			//4、释放资源
    			try {
    				if (null != os) {
    					os.close();
    				} 
    			} catch (Exception e) {
    			}
    		}
    	}