【18】IO OutputStream 一次写入多个字节 续写和换行 InputStream 自已读取多个字节 字符流 close和flush区别 换行和续写

IO的概述

OutputStream

/*
 * java.io.OutputStream：字节输出流
 * 		此抽象类是表示输出字节流的所有类的超类
 * 
 * 定义了一些子类共性的成员方法：
 * 	public void close():关闭此输出流并释放与此相关联的任何系统资源
 *  public void flush():刷新此输出流并强制任何缓冲的输出字节被写出
 *  public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
 *  public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
 *  public abstract void write(int b) ：将指定的字节输出流。
 *   
 *
 * java.io.FileOutputStream extends OutputStream 
 * FileOutputStream:文件字节输出流
 * 作用：把内存中的数据写入到硬盘的文件中
 * 
 *   构造方法：
 *    FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流。
      FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
 *      参数：写入数据的目的
 *      	String name：目的地是一个文件的路径
 *      	File file： 目的地是一个文件
 * 构造方法的作用：
 * 		1.会创建一个FileOutputStream对象
 * 		2.会把根据构造方法中的传递的文件/文件路径，创建一个空的文件
 * 		3.会把FileOutputStream对象指向创建好的文件
 *    
 * 写入数据的原理(内存--->硬盘)     
 * 		java程序--->JVM(java虚拟机)--->OS(操作系统)--->os调用写数据的方法--->把数据写入到文件中
 * 
 * 字节输出流的使用步骤(重点):
 * 		1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
 * 		2.调用一个FileOUtputStream对象中的方法writer，把数据写入到文件中
 * 		3.释放资源(流使用会占用一个的内存，使用完毕要把内存清空，提高程序的效率 )
 * */
public class Test4 {
	public static void main(String[] args) throws IOException {
		//创建一个FileOutputStream对象
		FileOutputStream fos = new FileOutputStream("D:\\wps\\b.txt");
		//使用writer方法，将字节写入到文件中
		fos.write(97);
		//释放资源
		fos.close();
	}
}

 

写入原理概述

一次写入多个字节

/*
 * 一次写多个字节的方法
 * public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
 * public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
 * */
public class Test5 {
	public static void main(String[] args) throws IOException {
		//创建一个OutputStream对象中的方法writer，把数据写入到文件中
		FileOutputStream fos = new FileOutputStream("D:\\wps\\c.txt");
		
		/*
		 * public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
		 * 一次写入多个字节：
		 * 		如果写的第一个字节的正数（0-127），那么显示的时候会查询ASCII表
		 * 		如果写的第一个字节是负数，那么第一个字节会和第二个字节，两个字节组成一个中文显示，查询系统默认码表(GBk)
		 * */
		//创建byte数组
		byte[] a ={65,66,67,68};//ABCD
		byte[] b={-65,-66,67,68};//烤CD
		//将数组的字节写入到文件中
		fos.write(b);
		
		
		/*
		 * public void write(byte[] b, int off, int len):把字节数组的一部分写入到文件中
		 * 		int off：数组的开始索引
		 * 		int len：写几个字节
		 * */
		fos.write(a, 1, 2);//BC
		
		/*
		 * 写入字符的方法：可以使用String类中的方法把字符串，转换成为字节数组
		 * 		byte[] getBytes() 把字符串转换为字节数组
		 * */
		byte[] bytes = "你好".getBytes();
		System.out.println(Arrays.toString(bytes));//[-60, -29, -70, -61]
		fos.write(bytes);
	}
}

往后面追加东西，换行写

/*
 * 追加写/续写：使用两个参数的构造方法
 * 		FileOutputStream(String name, boolean append)创建一个向具有指定 name 的文件中写入数据的输出文件流。
 * 		FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
 * 	参数：
 * 		String name,File file:写入数据的目的地
 * 		boolean append：追加写快关
 * 			true：创建对象不会覆盖原文件，继续在文件的末尾追加数据
 * 			false:创建一个新文件，覆盖原文件
 * 写换行：写换行符号
 * Windows：\r\n
 * linus:/n
 * mac:/r
 * */
public class Test6 {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos = new FileOutputStream("D:\\wps\\d.txt", true);
		fos.write("你好".getBytes());
		fos.write("\r\n".getBytes());//进行换行
		fos.close();
	
	}
}

InputStream

/*
 * java.io.InputStream
 * 此抽象类是表示字节输入流的所有类的超类
 * 
 * 定义了所有子类共性的方法：
 * 	  int read()从输入流中读取数据的下一个字节。
 *    int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
 *    void close() 关闭此输入流并释放与该流关联的所有系统资源。
 *    
 * java.io.FileInputStream extends InputStream
 * FileInputStream：文件字节输入流
 * 作用：把硬盘文件中的数据，读取到内存中 使用
 * 
 * 构造方法：
 * 		FileInputStream(String name)
 *      FileInputStream(File file)
 *      参数：读取文件的数据源
 *           String name：文件的路径
 *           File file：文件
 *      构造方法的作用：
 *      	1.会创建一个FileInputStream对象
 *      	2.会把InputStream对象指定构造方法中要要读取的文件   
 * 	
 * 读取数据的原理（硬盘-->内存）
 * 		java程序-->JVM-->OS-->os读取数据的方法-->读取文件
 * 
 * 字节输入流的使用步骤(重点)：
 * 		1.创建FileInputStream对象
 * 		2.使用FileInputStream对象中的方法read，读取文件
 * 		3.释放资源
 * */
public class Test7 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("D:\\wps\\c.txt");
		//read()方法：读取文件中的一个字节并返回。读取到文件的末尾返回-1
		/*int read = fis.read();
		System.out.println(read);
		
		int read2 = fis.read();
		System.out.println(read2);
		
		int read3 = fis.read();
		System.out.println(read3);
		
		int read4 = fis.read();
		System.out.println(read4);
		fis.close();*/
		
		//可以使用while循环进行读取，不知道次数的时候用while循环
		//注意：必须使用变量len复制进行循环判断
		int len = 0;
		while((len=fis.read())!=-1){
			System.out.print((char)len);
		}
		//下面这种写法是错误的，输出的结果是98 -1,指针会执行下一个
		while(fis.read()!=-1){
			System.out.println(fis.read());
		}
		
		fis.close();
  	}
}

字节输入流一次读取多个字节的方法

/*
 * 字节输入流一次读取多个字节的方法：
 * 	int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
 *明确两件事：
 * 	1.方法的参数byte[]的作用？
 * 		起到缓冲的作用，存储每次读取到的多个字节
 * 		数组的长度一般定义1024(1kb)或者1024的整数倍
 * 	2.方法的返回值int是什么
 * 		每次读取的有效字节数
 * String类的构造方法：
 * 	String(byte[] bytes) :把字节数组转换为字符串
 * 	String(byte[] bytes, int offset, int length) 把字节数组的一部分转换为字符串 offset:数组的开始索引 length:转换的字节个数
 * */
public class Test8 {
	public static void main(String[] args) throws IOException {
		//创建一个FileInputStream对象
		FileInputStream fis = new FileInputStream("D:\\wps\\d.txt");
		//创建一个byte字节数组
		/*byte[] bytes = new byte[2];//每次读取2个字节
		int len = fis.read(bytes);//返回读取成功的数量
		System.out.println(len);//2
		System.out.println(new String(bytes));//AB
		
		 len = fis.read(bytes);
		 System.out.println(len);//2
		 System.out.println(new String(bytes));//AB
		 
		 len = fis.read(bytes);
		 System.out.println(len);//1
		 System.out.println(new String(bytes));//ED
		 
		 len = fis.read(bytes);
		 System.out.println(len);//-1
		 System.out.println(new String(bytes));//ED
*/	
		/*
		 * 发现以上读取时一个重复的过程，可以使用循环优化
		 * 不知道文件中有多少字节，所以使用while循环
		 * while循环结束的条件，读取到-1结束
		 * */
		byte[] bytess = new byte[1024];
		int len = 0;//记录每次读取的有效个数
		while((len=fis.read(bytess))!=-1){
			System.out.println(new String(bytess,0,len));
		}
		fis.close();
	}
}

字符输入流Reader

/*
 * 使用字节流读取文件
 * 1个中文
 * 		GBK：占用2个字节
 * 		UTF-8：占用3个字节    所以用字节流读取容易出现乱码的情况 
 * 
 * java.io.Reader:字符输入流，是字符输入流最顶层的父类，定义了一些共性的成员方法，是一个抽象类
 * 
 * 共性成员方法：
 * 	int read() 读取单个字符并返回。
 * 	int read(char[] cbuf)一次读取多个字符,将字符读入数组。
 * 	void close() 关闭该流并释放与之关联的所有资源。
 * 
 * java.io.FileReader extens InputStream extends Reader
 * FileReader:文件字符输入流
 * 作用：把硬盘文件中的数据以字符的方式读取到内存中
 * 
 * 构造方法：
 * 	FileReader(String fileName)
 *  FileReader(File file)
 * 	参数：读取文件的数据源
 * 		String fileName：文件的路径
 * 		File file：一个文件
 *  FileReader构造方法的作用：
 *  		1.创建一个FileReader对象
 *  		2.会把FileReader对象指向要读取的文件
 * 字符输入流的使用步骤：
 * 	1.创建FileReader对象，构造方法中绑定要读取的数据源
 * 	2.使用FileReader对象中的方法read读取文件
 * 	3.释放资源 
 * */
public class Test10 {
	public static void main(String[] args) throws IOException {
		//创建FileReader对象
		FileReader fr = new FileReader("D:\\wps\\d.txt");
		/*//一个一个字符读取
		int len =0;
		while((len=fr.read())!=-1){
			System.out.println(len);
		}
		fr.close();*/
		
		//数组读取
		char[] chars = new char[1024];
		int len=0;
		while((len=fr.read(chars))!=-1){
			System.out.println(new String(chars,0,len));
		}
		
		fr.close();
	}
}

字符输出流———Writer

/*
 * java.io.Writer:字符输出流，是所有字符输出流的最顶层的父类，是一个抽象方法
 * 
 * 共性的成员方法:
 *      - void write(int c) 写入单个字符。
 *      - void write(char[] cbuf)写入字符数组。
 *      - abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
 *      - void write(String str)写入字符串。
 *      - void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
 *      - void flush()刷新该流的缓冲。
 *      - void close() 关闭此流，但要先刷新它。
 * 
 * java.io.FileWriter extends  OutputStreaam extends Writer
 * FileWriter:文件字符输出流
 * 作用：把内存中字符数据写入到文件中
 * 
 * 构造方法：
 * 		FileWriter(File file)根据给定的 File 对象构造一个 FileWriter 对象。
 *  	FileWriter(String fileName) 根据给定的文件名构造一个 FileWriter 对象。
 *  	参数：String name:文件的路径
 *  		File file:是一个文件
 *  	构造方法的作用：
 *  		1.创建一个FileWriter对象
 *  		2.会根据构造方法中传递的文件/文件路径，创建文件
 *  		3.会把FileWriter对象指向创建好的文件
 *  
 *  字符输入流的使用步骤(重点):
 *  	1.创建FileWriter对象，构造方法中绑定要写入数据的目的地
 *  	2.使用FileWriter对象中的方法writer，把数据写入到内存缓冲区中(字符转换为字节的过程)
 *  	3.使用FIleWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
 *  	4.释放资源(会先把内存缓冲区中的数据刷新到文件中
 *  )
 * */
public class Test11 {
	public static void main(String[] args) throws IOException {
		//创建字符输出流对象
		FileWriter fw = new FileWriter("D:\\wps\\e.txt");
		//将字符写入到缓冲区中
		fw.write(97);
		//将缓冲区中的内容写入到文件中
		//fw.flush();
		
		//将字符数组写入到文件中
		char[] c ={'1','1','3'};
		fw.write(c);
		
		//将字符数组的一部分写入到文件中
		char[] chars = {'q','w','e','r'};
		fw.write(chars, 1, 2);
		
		//将字符串写入文件中
		fw.write("世界");
		
		//将字符串的一部分写入到文件中
		String s="世界你好";
		fw.write(s, 2, 2);
		fw.close();
		
	}
}

close和flush的区别

flush方法和close方法的区别
        - flush ：刷新缓冲区，流对象可以继续使用。
        - close:  先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

字符输出流的续写和换行

/*
 * 续写和换行
 * 续写，追加写：使用两个参数的构造方法
 * 		FileWriter(String fileName, boolean append)
 * 		FileWriter(File file, boolean append)
 * 		参数：
 * 			String filename，File file：写入数据的目的地
 * 			boolean append：续写开关，true：不会创建新的文件覆盖源文件，false：创建新的文件覆盖源文件
 * 换行：
 * 		Windows：\r\n
 * 		linux:\n	
 * 		mac:\r
 * */
public class Test12 {
	public static void main(String[] args) throws IOException {
		FileWriter fw = new FileWriter("D:\\wps\\f.txt",true);
		for (int i = 0; i < 21; i++) {
			fw.write("hello world"+i+"\r\n");
		}
		fw.close();
	}
}