IO的简单认识

最新推荐文章于 2024-10-30 10:20:22 发布

我一直在学习

最新推荐文章于 2024-10-30 10:20:22 发布

阅读量179

点赞数 2

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/CG123820/article/details/108052742

版权

Java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

IO流:借助于流技术在不同的设备之间进行数据传输
流的划分:

	按方向划分:
		输入流:读数据
		输出流:写数据

	按类型划分然后流的方向划分:
		字节流:
				字节输入流:InputStream
				字节输出流:OutputStream
		字符流
				字符输入流:Reader
				字符输出流:Writer
		操作"文本文件"---->优先采用字符流,但是字符流是字节流之后出现,先使用字节流!

字节流:

字节输入输出流

	字节输入流:InputStream:抽象类,不能实例化
			xxxInputStream:都是上面的子类
			举例:FileInputStream :文件字节输入流
	字节输出流:OutputStream:抽象类,不能实例化
			xxxOutputStream:都上面的子类
			举例:FileOutputStream:文件字节输出流

字节输出流的使用步骤:

1)创建字节输出流对象
	FileOutputStream(File file)  :将指定File对象作为参数传递构造出文件字节输出流对象
	FileOutputStream(String pathname) :将指定的文件的路径作为参数传递创建文件字节输出流对象

2)写数据	
		write()给输出的文件中写数据
3)释放资源
		close()

FileOutputStream:操作文件的字节输出流中有:

public abstract  void write(int b) :写入一个字节数据
public void write(byte[] b) :写一个字节数组
public void write(byte[] b, int off, int len):写一个字节数组的一部分

文件字节输出流中的构造方法:

public FileOutputStream(File file,boolean append)throws FileNotFoundException
public FileOutputStream(String pathname)
   参数1:File对象表示的路径抽象形式
   参数2:如果true,在文件的字节末尾追加数据

文件字节输入流的使用步骤:

 1)创建文件字节输入流对象 
 	public FileInputStream(File file) throws FileNotFoundException
 	public FileInputStream(String pathname) throws FileNotFoundException(推荐)
 
 2)读数据
 	abstract  int read() :一次读取一个字节
 3)释放资源
   	close()
   	
 		
 public int read()   一次读取一个字节
 int read(byte[] b) :一次读取一个字节数组,这个的执行效率远远高于第一种读的方式!
 
	InputStream:抽象类------>FileInputStream子类

字节缓冲输入流

BufferedInputStream(InputStream in) :构造一个字符缓冲输入流对象,默认的缓冲区大小(足够大)
BufferedInputStream(InputStream in, int size) :指定一个缓冲区大小,构造一个缓冲输入流对象!

成员方法:
读取数据:

		一次读取一个字节:public int read()
		一次读取一个字节数组:public int read(bytes[] bytes)

字节缓冲输出流:

作用:仅仅是提供一个缓冲区而已,不能直接操作文件

public BufferedOutputStream(OutputStream out):构造一个缓冲区流对象,默认的缓冲区大小(足够大了)

					byte[] buf = new byte[8192];足够大
					

public BufferedOutputStream(OutputStream out,int size):构造一个缓冲区流对象,指定缓冲区大小

成员方法

void write(byte[] b, int off, int len) :写字节数组的一部分
void write(byte[] b)  :写一个字节数组
 void write(int b) :写一个字节
 
 该类流针对文件的操作,还是需要去使用最基本的字节输出流操作
 
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("xxx.xxx"))
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"))

字符流:

OutputStreamWriter/InputStreamReader

字符流通向字节流的桥梁

OutputStreamWriter(OutputStream out) :使用平台默认编码集进行编码同时构造出字符转换输出流对象(推荐)
OutputStreamWriter(OutputStream out, Charset cs) 使用指定的字符集进行编码同时构造出字符转换输出流对象

成员方法:继承父类的Writer的方法

void write(int c) :写单个字符
void write(char[] cbuf)  :写一个字符数组
abstract  void write(char[] cbuf, int off, int len) :写字符数组的一部分
void write(String str):写字符串
void write(String str, int off, int len) :写字符串的一部分
public void flush():刷新流对象 ,在关闭字符流之前,先刷新流
     刷新之后还可以在写数据,建议在关闭之前,先刷新(防止出现数据没有写入到流中)
 close():关闭该流对象相关的资源,回收这些系统资源,关闭了就不能再给流中在数据了
提供转换流子类(具体的便捷类) FileReader(String pathname)  FileWrier(String pathname)

这里只对字节流进行举例,字节缓冲流的用法一样

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test {

	public static void main(String[] args) throws IOException {
		//创建FileOutputStream对象
		FileOutputStream fos = new FileOutputStream("hello.txt");
		//写入数据,三中类型
		/*
		 *  public abstract  void write(int b) :写入一个字节数据
    		public void write(byte[] b) :写一个字节数组
			public void write(byte[] b, int off, int len):写一个字节数组的一部分
		 * */
		fos.write("hello word\r\n".getBytes());
		//字节
		fos.write('A');
		//换行
		fos.write("\r\n".getBytes());
		byte[]  bytes = {99,100,101,102,103,104};
		fos.write(bytes, 1, 4);
		//释放资源,关闭流
		fos.close();
		FileInputStream fis = new FileInputStream("hello.txt");
		//读取数据,一次一个字节
		int by = 0;
		while((by=fis.read())!=-1) {
			System.out.print((char)by);
		}
		//一次读取一个字节数组
		byte [] byt = new byte [1024];
		int len = 0;
		while((len=fis.read(byt))!=-1) {
			System.out.println(new String(byt,0,len));
			//释放资源,关闭流
			fis.close();
			
		}
	}

}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
//复制"hello.txt"文件的内容到"Javaee.txt"文件中
public class Test2 {

	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("hello.txt");
		FileOutputStream fos = new FileOutputStream("Javaee.txt");
		//一次复制一个字节
		int by = 0;
		while((by=fis.read())!=-1) {
			fos.write(by);
		}
		//一次复制一个字节数组
		byte[] bytes = new byte[1024];
		int len = 0;
		while((len = fis.read(bytes))!=-1) {
			fos.write(bytes,0,len);
		}
		//释放资源
		fis.close();
		fos.close();
	}

}

字符缓冲流(字符高效流)

BufferedWriter
BufferedReader
BufferedXXX都只是提供缓冲区,对文件读写操作还要依赖于对应的基本字符流...

BufferedReader:字符缓冲输入流

构造方法:

BufferedReader(Reader in) :默认的字符缓冲区输入流对象
BufferedReader(Reader in, int sz)  :指定的大小的字符缓冲输入流对象

成员方法:

public int read():读取单个字符
public int read(char[] chs):读取一个字符数组

特有功能:

public String readLine():一次读取一行内容

键盘录入数据

	1)main:早期的方式
	2)JDK5提供了Scanner类:键盘录入
		Sacnner(InputStream in)
		InputStream in = System.in;
		Scanner sc = new Scanner(System.in) ;
	3)BufferedReader(Reader r)

字符缓冲输出流

BufferedWriter(Writer out) :创建一个字符缓冲输出流对象 默认的缓冲区大小(默认值足够大了)
BufferedWriter(Writer out, int sz):创建一个字符缓冲输出流对象,指定的缓冲区大小

成员方法:

public void flush() 
write(int ch):写单个字符
write(char[] chs):写字符数组
write(char[] chs,int offerset,int length) :写字符数组的一部分
write(String str) 写字符串

特有功能:

public void newLine()throws IOException :写入行的分隔符

这里正对字符缓冲流进行举例(一次读取一行属于字符缓冲输出流的特有功能)
字符流读写复制的三种方法

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;


public class CopyTest {
	
	public static void main(String[] args) throws IOException {
		
		copyFile();
		copyFile2();
		copyFile3();
	}
	
	//利用BufferedReader/BufferedWriter的特有功能
	private static void copyFile3()  throws IOException{
		
		//封装源文件
		BufferedReader br = new BufferedReader(
				new FileReader("Hello.java"));
		//封装目的
		BufferedWriter bw = new BufferedWriter(
				new FileWriter("Copy.java"));
		
		//读写复制:
//		BufferedReader readLine()一次读取一行
		String line = null ;
		while((line=br.readLine())!=null) {
			//读一行,写一行
			bw.write(line);
			bw.newLine(); //写行分隔符
			bw.flush();
		}
		//释放资源
		bw.close();
		br.close();
	}

	//一次读取一个字符数组
	private static void copyFile2()  throws IOException{
		//封装源文件
		BufferedReader br = new BufferedReader(
				new FileReader("Hello.java"));
		//封装目的
		BufferedWriter bw = new BufferedWriter(
				new FileWriter("Copy.java"));
		
		char[] chs = new char[1024] ;
		int len = 0 ;
		while((len=br.read(chs))!=-1) {
			bw.write(chs, 0, len);
			bw.flush();
		}
		
		bw.close();
		br.close();
	}

	private static void copyFile() throws IOException {
		//封装源文件
		BufferedReader br = new BufferedReader(
				new FileReader("Hello.java"));
		//封装目的
		BufferedWriter bw = new BufferedWriter(
				new FileWriter("Copy.java"));
		
		//一次读一个字符
		int ch = 0 ;
		while((ch=br.read())!=-1) {
			bw.write(ch);
			bw.flush();
		}
		bw.close();
		br.close();
	}
}