本文深入讲解Java中的IO流概念及应用，包括字符流与字节流的区别、缓冲区的使用方法、流的操作规律等核心知识点，并介绍了文件类、Properties类等实用工具。
一：IO(Input Output)流
1.作用：
1.1.IO流用来处理设备之间的数据传输。
1.2.Java对数据的操作是通过流的方式。
1.3.Java用于操作流的对象都在IO包中。
1.4.流按操作数据分为两种：字节流与字符流。
1.5.流按流向分为：输入流，输出流。
2.什么是字符流？
其实就是L字节流流读取文字字节数据后不直接操作而是先查指定的编码表（Unicode，gbk等）获取对应的文字，在对这个文字进行操作。
简单说：字符流=字节流+编码表。
3.字符流的两个顶层父类：
3.1.Reader
3.2.Writer
注意：如果要操作文字数据建议先考虑字符流，而且要将数据从内容写到硬盘上，要使用字符流中的输出流：Writer硬盘的数据基本体现是文件，因此需要一个可以操作文件的Writer：FileWriter。
将数据从硬盘读到内存中一样。
3.3.close()和flush()的区别：
f lush()：将缓冲区的数据刷到目的地中后，流可以使用。
close()：将缓冲区的数据刷到目的地中后，流就关闭了，该方法主要用于结束调用的底层资源。这个动作一定做。
代码实例：
/**
* 需求：在硬盘上写入文件在读出
*/
public class WriterAndReaderTest {
public static void main(String[] args) throws IOException {
//1.向硬盘里写数据
FileWriter fw = new FileWriter("demo.txt",true);//向该工程目录下创建demo.txt文件，true表示并且可追加内容
fw.write("abc"+/*System.getProperty("line.separator")*/"de");//写到缓冲区里,写的时候对应操作系统的换行符
fw.flush();//将缓冲区里的数据清除，清除前将数据写到硬盘对应的位置
//2.向硬盘里读数据
char[] buf = new char[2];//缓冲区
int len = 0;
FileReader fr = new FileReader("demo.txt");
while((len = fr.read(buf)) != -1){//read(char[])方法是将读取相应的字符数放入字符数组中，返回读取到的长度，读完返回-1；
System.out.println(new String(buf,0,len));//打印
}
fw.close();
fr.close();
}
}4.缓冲区的出现提高了对数据的读写操作。
4.1.对应类：
4.1.1.BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
4.1.2.BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。
4.2.缓冲区要结合流才可以使用。
4.3在流的基础上对流的功能进行了增强。
/**
* 字符流缓冲区BufferedWriter和BufferedReader，
*/
public class BufferWriterTest {
public static void main(String[] args) throws IOException {
//1.用BufferedWriter写数据
FileWriter fw = new FileWriter("BufferWriterTest.txt",true);//定义一个写字符流
BufferedWriter bufw = new BufferedWriter(fw);//定义一个写字符流缓冲区
bufw.write("abcde");
bufw.newLine();//根据操作系统对特殊字符串的不同而不同，这里是换行字符串
bufw.write("ABDCE");
//bufw.flush();//使用缓冲区的刷新方法将数据刷到目的地
bufw.close();//关闭，其实底层调用就是fw.close(),并且关之前也会刷新;
//2.用BufferedReader读数据
FileReader fr = new FileReader("BufferWriterTest.txt");
BufferedReader bufr = new BufferedReader(fr);
String str = null;
while((str = bufr.readLine()) != null){
System.out.println(str);
bufr.readLine();
}
bufr.close();
}
}缓存原理图如下：
5.字节流的两个顶层父类：
5.1.InputStream：文件输入流：FileInputStream：没有flush()方法但有close()方法，缓存BufferedInputStream
5.2.OutputStream：文件输出流：FileInputStream：没有flush()方法但有close()方法,缓存BufferedOutputStream
6.字节流与字符流之间的转换：
6.1：InputStreamReader(InputStream)：字节流通向字符流的桥梁，解码。
6.2：OutputStreamWriter(OutputStream)：是字符流通向字节流的桥梁，编码。
6.3.io异常的处理方式：io一定要写finally
6.3.1.window中的换行符：\r\n两个符号组成。 linux：\n。
6.3.2.续写数据，只要在构造函数中传入新的参数true。
6.3.3.目录分割符：window \\ /
6.3.4.FileWriter写入数据的细节：
<span style="font-weight: normal;">public static void main(String[] args) {
FileWriter fw = null;
try {
fw = new FileWriter("demo.txt",true);
fw.write("abcde");
}
catch (IOException e ){
System.out.println(e.toString()+"....");
}
finally{
if(fw!=null)
try{
fw.close();
}
catch (IOException e){
System.out.println("close:"+e.toString());
}
}
}</span>6.3.5.FileReader写入数据的细节：使用Reader体系，读取一个文本文件中的数据。返回 -1 ，标志读到结尾。
class FileReaderDemo {
publicstatic void main(String[] args) throws IOException {
/*
创建可以读取文本文件的流对象，FileReader让创建好的流对象和指定的文件相关联。
*/
FileReader fr = new FileReader("demo.txt");
intch = 0;
while((ch = fr.read())!= -1){//条件是没有读到结尾
System.out.println((char)ch); //调用读取流的read方法，读取一个字符。
}
fr.close();
}
}
7.流的操作规律：因为流对象太多，开发时不知道用哪个对象合适。
7.1：明确源和目的:
源：InputStream和Reader目的：OutputStream和Writer
7.2：明确数据是否是纯文本数据：
源：是纯文本：Reader不是纯文本：InputStream
目的：是纯文本：Writer
不是纯文本：OutputStream
到这里可以明确需求中具体要用哪个体系。
7.3：明确具体的设备。
源设备：硬盘：File键盘：System.in
内存：数组（缓冲区）
网络：Socket流
目的设备：
硬盘：File
控制台：System.in
内存：数组
网络：Socket流
7.4.是否需要其它额外功能：
7.4.1.是否需要高效(缓冲区)：是的话+Buffered
7.4.2.是否需要指定编码方式和解码方式：如FileWriter是字节流+本地编码表，而OutputStreamWriter可以根据构造函数指定编码表
8.IO包中的其它类：
8.1.打印流：
PrintWriter：字符打印流，可以直接打印到文件或控制台
构造函数接收字符串路径，File对象，字节输出流，字节输入流。
PrintStream：提供了打印方法可以对多种数据类型值进行打印。并保持数据的表现形式，不抛出IOException异常
构造函数接受三种类型的值：字符串路径，File对象，字节输出流。
8.2.序列流：SequenceInputStream对多个流进行合并
8.3.操作对象：ObjectInputStream和ObjectOutputStream，被操作的对象需要实现Serializable(标记接口)
二：文件类
1.File类：
1.1特点：
1.1.1.用来将文件或者文件夹封装成对象。
1.1.2.方便对文件与文件夹的属性信息进行操作。
1.1.3.File对象可以作为参数
1.2.常见方法：
1.2.1.创建
boolean createNewFile()：在指定目录下创建文件，如果该文件已存在，则不创建。而对操作文件的输出流而言，输出流对象已建立，就会创建 文件，如果文件已存在，会覆盖。除非续写。
boolean mkdir()：创建此抽象路径名指定的目录。
booleanmkdirs()：创建多级目录。1.2.2.删除
boolean delete()：删除此抽象路径名表示的文件或目录。
void deleteOnExit()：在虚拟机退出时删除。
注意：在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。
window的删除动作，是从里往外删。注意：java删除文件不走回收站。要慎用。
1.2.3.获取
long length()：获取文件大小。
String getName()：返回由此抽象路径名表示的文件或目录的名称。
String getPath()：将此抽象路径名转换为一个路径名字符串。
String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。
String getParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回null。
long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。
File.pathSeparator：返回当前系统默认的路径分隔符，windows默认为 “；”。
File.Separator：返回当前系统默认的目录分隔符，windows默认为 “\”。
1.2.4.判断
boolean exists()：判断文件或者文件夹是否存在。
boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。
boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。
boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。
boolean isAbsolute()：测试此抽象路径名是否为绝对路径名。
1.2.5.重命名
boolean renameTo(Filedest)：可以实现移动的效果。剪切+重命名。
String[] list()：列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。
如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。如果封装的对象不存在也会返回null。只有封装的对象存在并且是 文件夹时，这个方法才有效。
2.Properties类：是Map-Hashtable的子类，一个可以将键值进行持久化存储的对象
2.1.特点：
2.1.1.该集合中的键值都是字符串类型。
2.1.2.集合中的数据可以保存到流中，或者从流读取。
2.1.3.通常该集合用于操作以键值形式存在的配置文件。
2.2.常见方法：
load()：将流中的数据加载进集合。
原理：其实就是将读取流和指定文件相关联，并读取一行数据，因为数据是规则的key=value，所以获取一行后，通过 = 对该行数据进行切割，左边就是键，右边就是 值，将键、值存储到properties集合中。
store()：写入各个项后，刷新输出流。
list()：将集合的键值数据列出到指定的目的地。
3.RandomAccessFile:
特点：
3.1随机访问文件，自身具备读写的方法。
3.2.通过skipBytes(int x),seek(int x)。来达到随机访问。
3.3.既能读文件也能写文件，该对象内部维护一个byte数组，并且通过指针可以操作数组中的元素。
3.4.可以通过getFilePointer获取指针的位置
3.5.其实该对象就是将字节输入流和输出流进行了封装
3.6.该对象的源或者目的只能是文件，通过构造函数就可以看出
4.管道流：PipedInputStream和PipedOutputStream
4.1 输入输出可以直接进行连接，通过结合线程使用。
5.SequenceInputStream：序列流，作用就是将多个读取流合并成一个读取流。实现数据合并。
5.1.概述：表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个 输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。
这样做，可以更方便的操作多个读取流，其实这个序列流内部会有一个有序的集合容器，用于存储多个读取流对象。
该对象的构造函数参数是枚举，想要获取枚举，需要有Vector集合，但不高效。需用ArrayList，但ArrayList中没有枚举，只有自己去创建枚举对 象。 但是方法怎么实现呢？因为枚举操作的是具体集合中的元素，所以无法具体实现，但是枚举和迭代器是功能一样的，所以，可以用迭代替代 枚举。
5.2.原理：
合并原理：多个读取流对应一个输出流。
切割原理：一个读取流对应多个输出流。
代码如下：
class SplitFileDemo{
private static final String CFG = ".properties";
private static final String SP = ".part";
public static void main(String[] args) throws IOException{
File file = new File("c:\\0.bmp");
File dir = new File("c:\\partfiles");
meger(dir);
}
//数据的合并。
public static void meger(File dir)throws IOException{
if(!(dir.exists() && dir.isDirectory()))
throw new RuntimeException("指定的目录不存在，或者不是正确的目录"); File[] files = dir.listFiles(new SuffixFilter(CFG));
if(files.length==0)
throw new RuntimeException("扩展名.proerpties的文件不存在");
//获取到配置文件
File config = files[0];
//获取配置文件的信息。
Properties prop = new Properties(); FileInputStream fis = new FileInputStream(config);
prop.load(fis);
String fileName = prop.getProperty("filename");
int partcount = Integer.parseInt(prop.getProperty("partcount"));
//--------------------------
File[] partFiles = dir.listFiles(new SuffixFilter(SP));
if(partFiles.length!=partcount)
throw new RuntimeException("缺少碎片文件");
//---------------------
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for(int x=0; x<partcount; x++){
al.add(new FileInputStream(new File(dir,x+SP)));
}
Enumeration<FileInputStream> en = Collections.enumeration(al);
SequenceInputStream sis = new SequenceInputStream(en);
File file = new File(dir,fileName);
FileOutputStream fos = new FileOutputStream(file);
byte[] buf = new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
//带有配置信息的数据切割。
public static void splitFile(File file)throws IOException{
//用一个读取流和文件关联。
FileInputStream fis = new FileInputStream(file);
//创建目的地。因为有多个。所以先创建引用。
FileOutputStream fos = null;
//指定碎片的位置。
File dir = new File("c:\\partfiles");
if(!dir.exists())
dir.mkdir();
//碎片文件大小引用。
File f = null;
byte[] buf = new byte[1024*1024];
//因为切割完的文件通常都有规律的。为了简单标记规律使用计数器。
int count = 0;
int len = 0;
while((len=fis.read(buf))!=-1){
f = new File(dir,(count++)+".part");
fos = new FileOutputStream(f);
fos.write(buf,0,len);
fos.close();
}
//碎片文件生成后，还需要定义配置文件记录生成的碎片文件个数。以及被切割文件的名称。
//定义简单的键值信息，可是用Properties。
String filename = file.getName();
Properties prop = new Properties();
prop.setProperty("filename",filename);
prop.setProperty("partcount",count+"");
File config = new File(dir,count+".properties");
fos = new FileOutputStream(config);
prop.store(fos,"");
fos.close();
fis.close();
}
}//文件过滤器：根据文件名过滤
class SuffixFilter implements FileFilter{
private String suffix;
SuffixFilter(String suffix){
this.suffix = suffix;
}
public boolean accept(File file){
return file.getName().endsWith(suffix);
}
}
三：编码表的由来：
1.概述：计算机只能识别二进制数据，早起由来是电信号，
为了方便应用计算机，让它可以识别各个国家的文字，就将各个国家的文字用数据来表示，并一一对应，形成一张表，这就是编码表。
常见编码表如下图：
总结：
IO流是一切输入输出设备与内存打交道，根据输入输出对象的不同进而对应的类也不同，根据输入输出的数据不同也不同，但其实只有InputStream和OutputStream,它的继承机制就是对这两个类的包装而已，理清楚输入输出设备和流的方式便很容易掌握IO流。
扫一扫
3175
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
