java里io流的结构_剖析Java的IO流

一、概述

(1)Java语言定义了许多类专门负责各种方式的输入或者输出，这些类都被放在http://java.io包中。其中，

所有输入流类都是抽象类InputStream(字节输入流)，或者抽象类Reader(字符输入流)的子类；

而所有输出流都是抽象类OutputStream(字节输出流)或者Writer(字符输出流)的子类。

(2)流是用来(为了永久性的保存数据)

根据数据流向的不同分为输入流和输出流；

根据处理数据类型的不同分为字符流和字节流；

(3)输入模式和输出模式是谁流向谁：

InputStream(字节输入流)和Reader(字符输入流)通俗的理解都是读(read)的。

OutputStream(字节输出流)和Writer(字符输出流)通俗的理解都是写(writer)的。

流的流向分为输入流和输出流，输入流也就是从硬盘等外存或者网络流向内存，输出流是通过内存流向网络或者外存。

二、各种流的分类以及其结构图

1. InputStream类是字节输入流的抽象类，是所有字节输入流的父类，InputStream类具有层次结构如下图所示；

2. java中的字符是Unicode编码的，是双字节的。InputStream是用来处理字节的，在处理字符文本时很不方便。Java为字符文本的输入提供了专门的一套类Reader。Reader类是字符输入流的抽象类，所有字符输入流的实现都是它的子类。

3.输出流OutputStream类是字节输入流的抽象类，此抽象类表示输出字节流的所有类的超类。

4.Writer类是字符输出流的抽象类，所有字符输出类的实现都是它的子类

三、File类

1. File类是IO包中唯一代表磁盘文件本身的对象。通过File来创建，删除，重命名文件。File类象的主要作用就是用来获取文本本身的一些信息。如文本的所在的目录，文件的长度，读写权限等等。(有的需要记忆，比如isFile(),isDirectory(),exits();有的了解即可。使用的时候查看API)

2. 详细如下：

File类(File类的概述和构造方法)

A:File类的概述

File更应该叫做一个路径

文件路径或者文件夹路径

路径分为绝对路径和相对路径

绝对路径是一个固定的路径,从盘符开始

相对路径相对于某个位置,在eclipse下是指当前项目下,在dos下

查看API指的是当前路径

文件和目录路径名的抽象表示形式

B:构造方法

File(String pathname)：根据一个路径得到File对象

File(String parent, String child):根据一个目录和一个子文件/目录得到File对象

File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象

File类(File类的创建功能)

A:创建功能

public boolean createNewFile():创建文件 如果存在这样的文件，就不创建了

public boolean mkdir():创建文件夹 如果存在这样的文件夹，就不创建了

public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来

(使用createNewFile()文件创建的时候不加.txt或者其他后缀也是文件，不是文件夹；使用mkdir()创建文件夹的时候，如果起的名字是比如aaa.txt也是文件夹不是文件；也就是说用createNewFile()创建的一定是文件，而用mkdir()创建的一定是文件夹，而与所给的后缀名没有任何关系)

注意事项：

如果你创建文件或者文件夹忘了写盘符路径，那么，默认在项目路径下，这个很好理解。

File类(File类的重命名和删除功能)

A:重命名和删除功能

public boolean renameTo(File dest):把文件重命名为指定的文件路径

public boolean delete():删除文件或者文件夹

B:重命名注意事项

如果路径名相同，就是改名。

如果路径名不同，就是改名并剪切。

C:删除注意事项：

Java中的删除不走回收站。

要删除一个文件夹，请注意该文件夹内不能包含文件或者文件夹

File类(File类的判断功能)

A:判断功能

public boolean isDirectory():判断是否是目录

public boolean isFile():判断是否是文件

public boolean exists():判断是否存在

public boolean canRead():判断是否可读

public boolean canWrite():判断是否可写

public boolean isHidden():判断是否隐藏

File类(File类的获取功能)

A:获取功能

public String getAbsolutePath()：获取绝对路径

public String getPath():获取路径

public String getName():获取名称

public long length():获取长度。字节数

public long lastModified():获取最后一次的修改时间，毫秒值

public String[] list():获取指定目录下的所有文件或者文件夹的名称数组

public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组

File类(文件名称过滤器的概述及使用)

A:文件名称过滤器的概述

public String[] list(FilenameFilter filter)

public File[] listFiles(FileFilter filter)

public String[] list():获取指定目录下的所有文件或者文件夹的名称数组。

public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组。

public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组。

四、测试上面功能代码

@Test

public voidtestFileRename(){

/**

* 测试文件的命名是否成立，

* 当源文件与目标文件路径名相同，就是改名

* 当源文件与目标文件不同，就是改名并且剪切

*/

String dir = "E:/first";

File file = newFile(dir);

if(file.mkdir()){

System.out.println("目录"+dir+"创建成功");

}else{

System.out.println("目录"+dir+"创建失败");

}

// dir = "E:/second/java/src/name";

// file = new File(dir);

// if(file.mkdirs()){

// System.out.println("目录"+dir+"创建成功");

// }else{

// System.out.println("目录"+dir+"创建失败");

// }

File file2 = newFile("E:/four","ddd");

if(!file2.exists()){

file2.mkdir();

System.out.println("file2创建成功");

}

if(file2.mkdirs()){

System.out.println("file2创建成功");

}else{

System.out.println("file2创建失败");

}

File file3 = newFile(file2,"mmm");

if(!file3.exists()){

file3.mkdir();

System.out.println("file3创建成功");

}

File file4 = newFile("E:/four","kkk.txt");

if(!file4.exists()){

try{

file4.createNewFile();

} catch(IOException e) {

e.printStackTrace();

}

}

if(file.delete()){

System.out.println("目录"+dir+"删除成功");

}else{

System.out.println("目录"+dir+"删除失败");

}

}

//用file文件遍历一个文件下的所有文件

@Test

public voidgetFiles(){

File file = newFile("D:/金融方面的数据");

File[] listFiles = file.listFiles();

for(File file1:listFiles) {

System.out.println("***************");

System.out.println(file1.getName());

System.out.println(file1);

System.out.println(file1.toString());

System.out.println(file1.getAbsoluteFile());

System.out.println(file1.getAbsolutePath());

System.out.println(file1.getPath());

}

}

//用file文件遍历一个文件下的所有文件(包括子文件夹下的文件),采用递归调用

@Test

public voidgetAllFiles(){

//创建需要统计文件个数下的文件

File file = newFile("D:/金融方面的数据");

Map map = listFilesNew(file);

List list = (List) map.get("list");

for(Object str:list) {

System.out.println(str);

}

System.out.println("个数为"+map.get("count"));

System.out.println("总大小为"+map.get("size"));

}

//递归调用函数

publicMap listFiles(File file){

//判断该文件是否存在

Map map = newHashMap();

if(file.exists()){

//获取所有文件，判断是否是目录，如果是目录，遍历目录，也就是调用函数本身，进行递归调用

File[] file2 = file.listFiles(newFileterByFile());

for(File fileNum:file2) {

//如果是目录,调用本身函数

if(fileNum.isDirectory()){

listFiles(fileNum);

}else{

System.out.println(fileNum.getName()+","+fileNum.length()/(1024)+"KB");

count++;

size+=fileNum.length()/1024;

}

}

map.put("count",count);

map.put("size",size);

}

returnmap;

}

//改进递归调用函数

publicMap listFilesNew(File file){

//判断该文件是否存在

Map map = newHashMap();

if(file.exists()){

//获取所有文件，判断是否是目录，如果是目录，遍历目录，也就是调用函数本身，进行递归调用

File[] file2 = file.listFiles(newFileterByFile());

for(File fileNum:file2) {

//如果是目录,调用本身函数

if(fileNum.isDirectory()){

listFilesNew(fileNum);

}else{

System.out.println(fileNum.getName()+","+fileNum.length()/(1024)+"KB");

list.add(fileNum.getName()+","+fileNum.length()/(1024)+"KB");

count++;

size+=fileNum.length()/1024;

}

}

map.put("list",list);

map.put("count",count);

map.put("size",size);

}

returnmap;

}

@Test

public voidtestFilenameFilter(){

File file = newFile("D:/金融方面的数据");

listFilesNew2(file);

}

//改进递归调用函数

public voidlistFilesNew2(File file){

//判断该文件是否存在

if(file.exists()){

//获取所有文件，判断是否是目录，如果是目录，遍历目录，也就是调用函数本身，进行递归调用

String[] files = file.list(newFilenameFilter() {

@Override

public booleanaccept(File dir, String name) {

returnname.endsWith(".pdf");

}

});

for(String fileNum:files) {

//如果是目录,调用本身函数

System.out.println(fileNum);

}

}

}

五、流的操作，有常见的FileInputStream，FileOutputStream,Reader,Writer,

//1.字节输入流和输出流，读入一个数据，输出一个数据

@Test

public voidtestInputOutput(){

try{

FileInputStream fis=newFileInputStream("E:/aaa.txt");

FileOutputStream fos = newFileOutputStream("E:/bbb.txt",true);

inta = fis.read(); //read()代表一次读一个字节

System.out.println(a);

fos.write(101);//write()一次写一个字节

fos.write(102);

fis.close();

fos.close();

} catch(IOException e) {

e.printStackTrace();

}

}

//文件的拷贝，将文件aaa.txt输出到bbb.txt，FileInputStream和FileOutputStream进行拷贝文本或者图片或者歌曲：

@Test

public voidtestInputOutput2(){

try{

FileInputStream fis=newFileInputStream("E:/aaa.txt");

FileOutputStream fos = newFileOutputStream("E:/ddd.txt");

//如果没有bbb.txt,会创建出一个

intb;

while((b=fis.read())!=-1){

fos.write(b);

}

fis.close();

fos.close();

} catch(IOException e) {

e.printStackTrace();

}

}

//采用byte数组进行读入，FileInputStream和FileOutputStream定义小数组进行读写操作：

@Test

public voidtestInputOutput3(){

try{

FileInputStream fis = newFileInputStream("E:/aaa.txt");

FileOutputStream fos = newFileOutputStream("E:/kkk.txt");

intlen;

byte[] arr = new byte[1024*8]; //自定义数组

while((len=fis.read(arr))!=-1){

System.out.println(len);

fos.write(arr,0,len);

}

fis.close();

fos.close();

} catch(IOException e) {

e.printStackTrace();

}

}

//使用BufferedInputStream，BufferOutputStream来拷贝数据

@Test

public voidtestBufferInputOutput(){

try{

FileInputStream fis = newFileInputStream("E:/aaa.txt");

FileOutputStream fos = newFileOutputStream("E:/ggg.txt");

//采用缓冲流将其包裹起来

BufferedInputStream bis = newBufferedInputStream(fis);

BufferedOutputStream bos = newBufferedOutputStream(fos);

intlen;

//读入操作，写入操作

while((len=bis.read())!=-1){

bos.write(len);

}

//关闭流

bis.close();

bos.close();

} catch(IOException e) {

e.printStackTrace();

}

}

//FileReader,FileWriter,BufferedReader,BufferedWriter的用法

@Test

public voidtestFileReaderWriter(){

//FileReader类的read()方法可以按照字符大小读取

FileReader fr= null;

try{

fr = newFileReader("aaa.txt");

intb;

while((b=fr.read())!=-1){

System.out.println((char)b);//int类型转为字符型

}

fr.close();

} catch(IOException e) {

e.printStackTrace();

}

//FileWriter类的write()方法可以自动把字符转为字节写出

FileWriter fw = null;

try{

fw = newFileWriter("aaa.txt",true);

fw.write("aaa");

fw.close();

} catch(IOException e) {

e.printStackTrace();

}

try{

FileReader reader = newFileReader("E:/aaa.txt");

FileWriter writer = newFileWriter("E:/ppp.txt");

intb;

while((b=reader.read())!=-1){

writer.write(b);

}

reader.close();

writer.close();

} catch(IOException e) {

e.printStackTrace();

}

}

@Test

public voidtestBufferReaderWriter(){

try{

BufferedReader br = newBufferedReader(newFileReader("aaa.txt"));

BufferedWriter bw=newBufferedWriter(newFileWriter("bbb.txt"));

intb;

while((b=br.read())!=-1){

bw.write((char)b);

}

br.close();

bw.close();

} catch(IOException e) {

e.printStackTrace();

}

}

小提示：什么时候采用字符流

* 字符流也可以拷贝文本文件, 但不推荐使用. 因为读取时会把字节转为字符, 写出时还要把字符转回字节.

* 程序需要读取一段文本, 或者需要写出一段文本的时候可以使用字符流

* 读取的时候是按照字符的大小读取的,不会出现半个中文

* 写出的时候可以直接将字符串写出,不用转换为字节数组