IO分类
- BIO:同步阻塞IO
- NIO：同步非阻塞IO
- AIO:异步非阻塞IO
IO方式
- 本地I文件IO
- 网络IO
流的概念
- 流是一组有顺序的有起点和终点的集合,是对数据传输的总称或抽象
- 流的本质就是数据传输
- 流向分:输入流,输出流
- 按处理数据的单位分:字节流和字符流
输入流和输出流
- 输入流:将数据从各种输入设备(硬盘等)中读取到内存中
- 输出流:将数据写入到输出设备(显示器硬盘等)
字节流和字符流
- 字节流：表示以字节（8位）为单位从流（stream）读取数据或者往流（stream）中写入数据，通常用来处理二进制文件，如图像和声音。字节流的两个基类为InputStream和OutputStream，分别代表字节输入流和字节输出流，其他具体的字节流类都是从这两个类派生而来的。
- 字符流：示以字符（16位）为单位从流（stream）中读取数据或者往流（stream）中写入数据，同来用来处理字符或字符串数据。这里的字符是Unicode为标准的字符，Unicode字符是16位的。字符流的两个基本类为Reader和Writer，分别代表字符输出流和字符输入流，其他具体的字符流都是从这两个类派生而来的。
- 字节字符转换流：可以将字节流转换为字符流，java中提供两个适配器（adapter），分别是InputStreamReader和OutputStreamWriter，前者负责将InputStream转换为Reader，而后者负责将OutputStream转换为Writer。
文件字节流
- FileInputStream:从文件系统的某个文件获得输入字节
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInput {
public static void main(String[] args) throws IOException {
File file=new File("E:\\DW\\zpf.txt");
FileInputStream is=new FileInputStream(file);
byte[] bytes=new byte[1024];
int len=0;
while((len=is.read(bytes))!=-1){
String str=new String(bytes,0,len);
System.out.println(str);
}
is.close();
}
}
- FileOutputStream:将数据一个字节一个子集的写入到文件或者网络中
import java.io.*;
public class FileOut {
public static void main(String[] args) throws IOException {
File file=new File("E:\\DW\\zpf.txt");
FileOutputStream os=new FileOutputStream(file);
String str="嗨嗨嗨";
byte[] bytes=str.getBytes();
os.write(bytes);
os.close();
}
}
- FileInputStream和FileOutputStream结合边读边写-图片拷贝
import java.io.*;
public class FileIn_Out {
public static void main(String[] args) throws IOException {
File fin=new File("E:\\TuPian\\BiZhi.jpg");
File fout=new File("E:\\TuPian\\out.jpg");
FileInputStream in=new FileInputStream(fin);
FileOutputStream out=new FileOutputStream(fout);
byte[] bytes=new byte[1024];
int len=0;
while((len=in.read(bytes))!=-1){
out.write(bytes,0,len);
}
in.close();
out.close();
}
}
字节缓冲流
- 为什么需要缓冲流
当我们用read()读取文件时，每读一个字节，访问一次硬盘，效率很低 。文件过大时，操作起来也不是很方便。因此我们需要用到buffer缓存流，当创建buffer对象时，会创建一个缓冲区数组。当我们读一个文件时，先从硬盘中读到缓冲区，然后直接从缓冲区输出即可，效率会更高。
- BufferedInputStream
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInput {
public static void main(String[] args) throws IOException {
File file=new File("E:\\DW\\zpf.txt");
FileInputStream is=new FileInputStream(file);
BufferedInputStream bis=new BufferedInputStream(is);
byte[] bytes=new byte[1024];
int len=0;
while((len=bis.read(bytes))!=-1){
String str=new String(bytes,0,len);
System.out.println(str);
}
//反向释放
bis.close();
is.close();
}
}
- BufferedOutputStream
import java.io.*;
public class FileOut {
public static void main(String[] args) throws IOException {
File file=new File("E:\\DW\\zpf.txt");
FileOutputStream os=new FileOutputStream(file);
BufferedOutputStream bout=new BufferedOutputStream(os);
String str="嗨嗨嗨";
byte[] bytes=str.getBytes();
//必须强制刷新
bout.flush();
bout.write(bytes);
bout.close();
}
}
文件字符流
- FileReader
import java.io.*;
public class FileInput {
public static void main(String[] args) throws IOException {
File file=new File("E:\\DW\\zpf.txt");
FileReader is=new FileReader(file);
char[] chars=new char[1024];
int len=0;
while((len=is.read(chars))!=-1){
String str=new String(chars,0,len);
System.out.println(str);
}
is.close();
}
}
- FileWriter
import java.io.*;
public class FileOut {
public static void main(String[] args) throws IOException {
File file=new File("E:\\DW\\zpf.txt");
FileWriter os=new FileWriter(file);
String str="嗨嗨嗨";
char[] chars=str.toCharArray();
os.write(chars);
os.close();
}
}
字符缓冲流
- BufferedReader
import java.io.*;
public class FileInput {
public static void main(String[] args) throws IOException {
File file=new File("E:\\DW\\zpf.txt");
FileReader is=new FileReader(file);
BufferedReader bis=new BufferedReader(is);
char[] chars=new char[1024];
int len=0;
while((len=bis.read(chars))!=-1){
String str=new String(chars,0,len);
System.out.println(str);
}
is.close();
}
}
- BufferedWriter
import java.io.*;
public class FileOut {
public static void main(String[] args) throws IOException {
File file=new File("E:\\DW\\zpf.txt");
FileWriter os=new FileWriter(file);
BufferedWriter bos=new BufferedWriter(os);
String str="嗨嗨嗨";
char[] chars=str.toCharArray();
bos.flush();
bos.write(chars);
bos.close();
}
}
字节流与字符流对比
- 字节流操作的基本单元是字节,字符流操作的基本单元是Unicode码元
- 字节流默认不使用缓冲区,字符流使用缓冲区
- 使用字节流操作中,即使没有关闭资源(close方法)也能输出;而字符流不使用close方法
注意：
- 字符流默认有缓冲区会自动刷新,字节流没有缓冲区必须强制刷新
- 缓冲输入没有flush缓冲输出流有flush,BufferedReader没有flush方法，BufferedWriter有flush方法；这是因为flush方法的作用和功能是向外做输出，将内存中的数据提交输出到外部文件当中，在BufferedWriter中，因为是对外做写操作，因此是有提交输出的flush方法的；而在BufferedReader对象中，因为它的作用是用来从外部读取文件内容到内存中，因此不存在向外做提交输出的操作，因此没有flush方法。(总结就是flush就是把内存(内存在虚拟机上)中的数据强制写出去,BufferedReader就只是将数据从文件读入到内存不会再从内存向外写的操作所以不需要flush，而BufferedWriter是先将数据从读入到内存，再从内存写入到文件必须强制flush)
flush():
flush()意思是把缓冲区的内容强制的写出。 因为操作系统的某些机制，为了防止一直不停地磁盘读写，所以有了延迟写入的概念主要用在IO中，即清空缓冲区数据，一般在读写流(stream)的时候，数据是先被读到了内存中，再把数据写到文件中，当你数据读完的时候不代表你的数据已经写完了，因为还有一部分有可能会留在内存这个缓冲区中。这时候如果你调用了close()方法关闭了读写流，那么这部分数据就会丢失，所以应该在关闭读写流之前先flush()。
输出流到文件是覆盖原文件内容
字节字符转换流
- InputStreamReader
import java.io.*;
public class FileInput {
public static void main(String[] args) throws IOException {
File file=new File("E:\\DW\\zpf.txt");
FileInputStream fis=new FileInputStream(file);
InputStreamReader isr=new InputStreamReader(fis);
BufferedReader br=new BufferedReader(isr);
char[] chars=new char[1024];
int len=0;
while((len=br.read(chars))!=-1){
String str=new String(chars,0,len);
System.out.println(str);
}
br.close();
isr.close();
fis.close();
}
}
- OutputStreamWriter
import java.io.*;
public class FileOut {
public static void main(String[] args) throws IOException {
File file=new File("E:\\DW\\zpf.txt");
FileOutputStream fos=new FileOutputStream(file);
OutputStreamWriter osw=new OutputStreamWriter(fos);
BufferedWriter bos=new BufferedWriter(osw);
String str="hhh";
char[] chars=str.toCharArray();
bos.flush();
bos.write(chars);
bos.close();
}
}
3473
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
