IO流的基本认识和字节输入流和字节输入流

IO流的基本认识

IO:在设备和设备之间的一种数据传输!

IO流的分类:

按流的方向分:

输入流: 读取文件   (e:\\a.txt):从硬盘上文件读取出来后输出这个文件的内容
输出流: 写文件:将e:\\a.txt 内容读出来--->写到f盘下

按数据的类型划分:

字节流
字节输入流:InputStream :读取字节
字节输出流:OutputStream :写字节
字符流
字符输入流:Reader :读字符

字符输出流:Writer :写字符

public class FileOutputStreamDemo {

	public static void main(String[] args) throws IOException {
		
		//创建字节输出流对象
		//创建对象做了几件事情
				/**
				 * 1)构造了输出流对象 (系统创建对象)
				 * 2)指向了当前项目下输出fos.txt
				 */
          FileOutputStream fos = new  FileOutputStream("fos.txt");
        //写数据
  		// 使用流对象给文件中写入数据
          //void write(byte[] b) 
         // 将 b.length 个字节从指定 byte 数组写入此文件输出流中。 
  		fos.write("hello".getBytes());
  		byte[] bytes = new String().getBytes();
  		// byte[] getBytes(String charsetName) 
        //使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 
  	//关闭资源
  			/**
  			 * 1)将文件和流对象不建立关系了 (fos对象不指向fos.txt)
  			 * 2)及时释放掉流对象所占用的内存空间
  			 */
  			fos.close(); 
  			/**
  			 * 如果关闭流对象了,那么就不能对流对象进行操作了
  			 */
//  			fos.write("java".getBytes());//java.io.IOException: Stream Closed :流已经关闭了
  			
  		}
          
		
	}

 需求:在当项目下输出一个文件,fos.txt文件(文本文件)

只要文本文件,优先采用字符流,字符流在字节流之后出现的
使用字节流进行操作
无法创建字节输出流对象:OutputSteam :抽象类,不能实例化
又学习过File类,并且当前是对文件进行操作,子类:FileOutputSteam进行实例化

File+InputStream
File+OutputStream
FileXXX  (FileReader)
FileXXX  (FileWriter)

开发步骤:

1)创建字节输出流对象
2)写数据

3)关闭资源

输出流:

                void write(byte[] b) 
                                         将 b.length 个字节从指定 byte 数组写入此文件输出流中。 
                void write(byte[] b, int off, int len) 
                                          将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。 
                void write(int b) 
                                           将指定字节写入此文件输出流。 
                           输入流的write方法没有返回值
                          参数是int b 一次写入自定义b个字节
                          参数是byte[] b 一次写入b.lenth个字节
                          参数是 byte[] b, int off, int len  一次写入b.lenth个字节  从off到len

 需求:输出文本文件,给文本文件中添加一些数据 
 问题:
写一些数据,这些数据并没有换行,如何实现换行的效果...
针对不同的操作系统,里面的换行符合不一样的
windows: \r\n
Linx:\n
mac:\r
 一些高级记事本针对任意的换行会有换行的效果
 问题:如何末尾追加数据呢
 public FileOutputStream(File file, boolean append):指定为true,末尾追加数据

public class FileOutputStreamDemo {

	public static void main(String[] args) throws InterruptedException, IOException {
		
		//创建输出流对象
		FileOutputStream  fos = new FileOutputStream ("yb.txt",true);
		//写入
		for(int i= 0 ; i < 10 ; i++) {
			fos.write(("java"+i).getBytes());
			fos.write("\r\n".getBytes());	
		}
		//释放资源
		fos.close();
		
	}
}

 IO流中加入异常处理(try...catch...)

public class FileOutputStreamDemo2 {

	public static void main(String[] args) {
		

		// 方式1) 分别进行异常处理
		// 创建字节文件输出流对象
		/*
		 * FileOutputStream fos = null ; try { fos = new FileOutputStream("fos.txt") ; }
		 * catch (FileNotFoundException e) { e.printStackTrace(); }
		 * 
		 * //写数据 try { fos.write("hello".getBytes()); } catch (IOException e) {
		 * e.printStackTrace(); }
		 * 
		 * //释放资源 try { fos.close(); } catch (IOException e) { e.printStackTrace(); }
		 */

		// 方式2: 一起处理 (针对整个资源没有释放,不好)
		// try {
		// FileOutputStream fos = new FileOutputStream("fos2.txt") ;
		// fos.write("java".getBytes());
		// fos.close();
		// } catch (IOException e) {
		// e.printStackTrace();
		// }

		// 方式3:经常这样使用:try...catch...finally...
		// finally中访问这个对象,需要将对象放到try语句外面
		FileOutputStream fos = null;
		//写数据
		try {
			fos= new FileOutputStream("yb1.txt");
			fos.write("javase".getBytes());
		}catch(IOException e){
			e.printStackTrace();
		}
		//释放资源
		finally {
			if(fos!=null)
		try {
			fos.close();
		}catch(IOException e2){
			e2.printStackTrace();
		}
	}
}
}

输入流:

读数据,一个一个读,自己理解by是已经读取的字节数
输入流的read(),返回值是一个int类型
无参类型代表读取一个字节的数据
read(byte[]b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
read(byte[] b, int off, int len) 
                从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
输出语句的new String(bys,0,lenth)是因为bys对象没有重写tostring(),不能直接输出,
创建一个String对象就可以在控制面板上看到
需求:去读取当前项目下的fis.txt这个文件内容,将文件的内容输出在控制台上
InputStream抽象类:字节输入流
FileInputStream
构造方法:
public FileInputStream(String name)
 开发步骤:
1)创建字节文件输入流对象
2)读数据
3)释放资源 
 读数据方式:
public abstract int read():一次读取一个字节
public int read(byte[] b):一次读取一个字节数组 (读取实际的字节数)

public class FileInputStreamDemo {

	public static void main(String[] args) throws IOException {
		
		//创建输入流对象
		FileInputStream fis = new FileInputStream("yb.txt");
		//	
		//创建一个字节文件输入流对象
		//方式1:一次读取一个字节
		//FileInputStream fis  = new FileInputStream("fis.txt") ;
//		FileInputStream fis  = new FileInputStream("FileOutputStreamDemo.java") ;
		//开始读取:第一次读取
	/*	int by = fis.read() ;
		System.out.println(by);
		System.out.println((char)by);
		
		//第二次读取
		by = fis.read() ;
		System.out.println(by);
		System.out.println((char)by);
		
		//第三次读取
		by = fis.read() ;
		System.out.println(by);
		System.out.println((char)by);
		
		//第四次读取
		by = fis.read() ;
		System.out.println(by);
		System.out.println((char)by);
		
		//第五次读取
		by = fis.read() ;
		System.out.println(by);
		System.out.println((char)by);
		
		
		//上述代码重读高,使用循环改进,循环的结束条件是什么呀?
		//第六次读取
		by = fis.read() ;
		System.out.println(by);*/
		//结束条件就是:如果文件读到末尾了,没有字节数了,所以是一个-1
		/*int by = fis.read() ;
		while(by!=-1) {
			System.out.print((char)by);
			//继续获取字节
			by = fis.read() ;
		}*/
		
		//最终版代码:可不可以将 赋值,判断写在一块呢?
		int by = 0 ;
		while((by=fis.read())!=-1) {
			System.out.print((char)by);
		}
		
		//释放资源
		fis.close();
	}
}

输入流和输出流结合运用:

这个案例是一个字节一个字节的读写

 复制文本文件。
将当前项目下的a.txt文件的内容读取出来,复制到b.txt文件中
 源文件: a.txt --->  读取文件的内容---->FileInputStream
 目的地文件: b.txt----> 输出文件 --->FileOutputStream

public class CopyFileDemo {

	public static void main(String[] args) throws IOException {
		
		//创建输出流对象
		FileOutputStream fos = new FileOutputStream("yb2.txt");
		//创建输入流对象
		FileInputStream fis = new FileInputStream("yb.txt");
		//读数据,一个一个读,自己理解by是已经读取的字节数
		//输入流的read(),返回值是一个int类型
		//无参类型代表读取一个字节的数据
		//read(byte[]b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
		//read(byte[] b, int off, int len) 
        //从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
		//输出语句的new String(bys,0,lenth)是因为bys对象没有重写tostring(),不能直接输出,
		//创建一个String对象就可以在控制面板上看到
		int by = 0 ;
		while ((by = fis.read())!=-1) {
			//写数据,一个一个写
			/*
			 *  void write(byte[] b) 
                                         将 b.length 个字节从指定 byte 数组写入此文件输出流中。 
                void write(byte[] b, int off, int len) 
                                          将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。 
                void write(int b) 
                                           将指定字节写入此文件输出流。 
                           输入流的write方法没有返回值
                          参数是int b 一次写入自定义b个字节
                          参数是byte[] b 一次写入b.lenth个字节
                          参数是 byte[] b, int off, int len  一次写入b.lenth个字节  从off到len
			 */
			fos.write(by);
			
		}
		//释放资源
		fis.close();
		fos.close();
	}
}

这个案例读写都是以byte [] bys数组形式

 源文件: yb.txt
  目的地文件: fos.txt
 源文件: FileInputStream --->读取

public class CopyFileDemo1 {

	public static void main(String[] args) throws IOException {
		
		//创建输入流对象
		FileInputStream fis = new FileInputStream("yb.txt");
		//创建输出流对象
		FileOutputStream fos = new FileOutputStream ("fos.txt");
		//读数据
		int len = 0 ;
		byte [] bys = new byte [1024];
		while((len = fis.read(bys))!=-1) {
			//写数据
			fos.write(bys, 0, len);
		}
		//释放资源
		fis.close();
		fos.close();
	}
}

  目的地文件: FileOutputStream--->写入