文件操作和IO总结

File类详解：

所在包：java.io

       用处：可以通过File对象的方法创建文件对象、删除文件、查找文件，判断文件是目录还是正式文件。

 

文件系统的命名规则：

1.     文件的全名包含文件的路径名和扩展名，单独讲一个文件名是，为只带扩展名的文件名，不含路径。

2.     同一目录下不可能存在同名的目录和真实文件，系统主要有目录类型的文件和真是文件两种，真是文件可以没有扩展名，还有第三种我们不需要就是的虚拟内存文件。

3.     相对目录：指不一路径分隔符开头的文件路径

绝对目录：指以根目录开头的路径，以盘符开头的目录都是绝对目录

当前目录：指相对于程序运行时的目录算起的相对路径

4.     目录分隔符和路径分隔符在liunx和win平台上是不同的，前者为“/”和“：”，后者为“\”和“;”，所以应该使用File类提供的相应属性值。

（注意：能用相对路径的就不要用绝对路径以增强可移植性。）

 

 

File类构造方法：

File(File parent, String child)
          根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。

File(String pathname)
          通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

File(String parent, String child)
          根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

File(URI uri)
          通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。

 

 

File类常用的方法：

boolean	delete()           删除此抽象路径名表示的文件或目录
boolean	equals(Object obj)           测试此抽象路径名与给定对象是否相等。
boolean	exists()           测试此抽象路径名表示的文件或目录是否存在。

 

File	getAbsoluteFile()           返回此抽象路径名的绝对路径名形式。
String	getAbsolutePath()           返回此抽象路径名的绝对路径名字符串。
long	getFreeSpace()           返回此抽象路径名指定的分区中未分配的字节数。
String	getName()           返回由此抽象路径名表示的文件或目录的名称。
String	getPath()           将此抽象路径名转换为一个路径名字符串。
boolean	isDirectory()           测试此抽象路径名表示的文件是否是一个目录。
boolean	isFile()           测试此抽象路径名表示的文件是否是一个标准文件。
long	length()           返回由此抽象路径名表示的文件的长度。
static File[]	listRoots()           列出可用的文件系统根。
boolean	mkdir()           创建此抽象路径名指定的目录。

 

代码示例：

实现功能：文件创建和删除，打印目录和文件

package lesson11;

 

import java.io.File;

public class FileTest{

 

/**

 * @param args

 */

public static void main(String[] args) {

    FileTest ft = new FileTest();

    ft.listRoots();

ft.testCreateAndDelete("D:/Java/Java程序/StudyJava/ NetJava/src/lesson11/Text.txt"); // 路径可变

    ft.printDir("src");

// 列出计算机上的根目录

public void listRoots() {

    // 直接调用File类

    File[] lf = File.listRoots();

    System.out.println("磁盘上目录的个数是：" + lf.length);

    for (int i = 0; i < lf.length; i++) {

    System.out.println("第" + i + "个目录是" + lf[i].getAbsolutePath());

    }

}

 

// 测试文件创建与删除

public void testCreateAndDelete(String fileName) {

    // 通过传入的名字构造File对象

    File temFile = new File(fileName);

    // 判断文件是否存在

    if (temFile.exists()) {

        if (temFile.isDirectory()) {

System.out.println("这是一个目录：" + temFile.getAbsolutePath());

       }

       if (temFile.isFile()) {

           prinFileAttr(temFile);

           // 删除文件

           temFile.delete();

           String theName = temFile.getName();

           String absPath = temFile.getAbsolutePath();

           System.out .println("文件已删除，名字是：" + theName + " 绝对路径是：" + absPath);

           }

       } else {

           try {

           temFile.createNewFile();

            System.out.println("文件已创建！" + temFile.getAbsolutePath());

              // 打印出文件的长度

              prinFileAttr(temFile);

           } catch (Exception ef) {

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

           }

       }

    }

// 打印出文件的相关属性：长度，文件名，父目录名，是否隐藏文件

public void prinFileAttr(File temf) {

    System.out.println("文件长度是：" + temf.length());

    }

    public int printDir(String dirName){

       //文件计数器

       int count = 0;

       File dirFile = new File(dirName);

       File[] subFile = dirFile.listFiles();

       if(null == subFile||subFile.length==0){

           return 0;

       }

       for(int i=0;i<subFile.length;i++){

           if(subFile[i].isDirectory()){

              String subDir=subFile[i].getAbsolutePath();

              System.out.println("目录："+subDir);

              count +=printDir(subDir);

           }

           if(subFile[i].isFile()){

              count++;

              String fileName = subFile[i].getAbsolutePath();

              System.out.println("文件："+fileName);

           }

       }

       return count;

    }

}

 

 

 

 

异常：

Try catch处理机制：

格式：  

     try{

可能抛出异常的代码……

//如果没有问题出现，指向如下代码

（A）        其他计算代码

}catch（Exception ef）{

//如果出现异常后执行的代码；

（B）出现异常情况的执行代码

}

 

异常信息的分析与程序调试：

1.     try  catch 机制

2.     throws:在方法上抛出异常

例：public void Test() throws Exception(){ 方法体 }

注意：当另外一个方法调用了一个声明为可能抛出异常的方法时，要么将调用这个方法的代码放入try catch块中；要么将调用方法也声明为抛出异常。

3.     如果不想再代码中编写try块，就必须对调用方法做如下声明：  public void Test(){ 

throw new Exception(“”);

}

如果方法体中使用throw关键字抛出了Exception类型（或其子类）的对象，在方法的声明中就必须使用throws关键字声明，throws后面异常类名字必须是throw抛出异常对象的类型或其父类类型---因为永远是自动的。

 

IO流：

在计算机编程中，流就是一个类的对象，很多文件的输入输出操作都以类的成员函数的方式来提供。

计算机中的流其实是一种信息的转换。它是一种有序流，因此相对于某一对象，通常我们把对象接收外界的信息输入（Input）称为输入流，相应地从对象向外输出（Output）信息为输出流，合称为输入/输出流（I/O Streams）。对象间进行信息或者数据的交换时总是先将对象或数据转换为某种形式的流，再通过流的传输，到达目的对象后再将流转换为对象数据。所以，可以把流看作是一种数据的载体，通过它可以实现数据交换和传输。

在JAVA中，流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。

      Java中的流分为两种，一种是字节流，另一种是字符流，分别由四个抽象类来表示:InputStream，OutputStream，Reader，Writer。Java中其他多种多样变化的流均是由它们派生出来的。

 

流的分类：

1.     字节流

2.     过滤流

3.     数据类型流

4.     对象流

 

InputStream：

常用方法：

int	available()           返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。
void	close()           关闭此文件输入流并释放与此流有关的所有系统资源。
int	read()           从输入流中读取数据的下一个字节。
int	read(byte[] b)           从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。

FileInputStream类：

构造方法：

FileInputStream(File file)
          通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。

FileInputStream(FileDescriptor fdObj)
          通过使用文件描述符 fdObj 创建一个 FileInputStream，该文件描述符表示到文件系统中某个实际文件的现有连接。

FileInputStream(String name)
          通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

 

常用方法和InputStream差不多。

 

OutputStream：

常用方法：

方法摘要

void	close()           关闭此输出流并释放与此流有关的所有系统资源。
void	flush()           刷新此输出流并强制写出所有缓冲的输出字节。
void	write(byte[] b)           将 b.length 个字节从指定的 byte 数组写入此输出流。
void	write(byte[] b, int off, int len)           将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
abstract  void	write(int b)           将指定的字节写入此输出流。

 

FileOutputStream类：

构造方法摘要
FileOutputStream(File file)           创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(File file, boolean append)           创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(FileDescriptor fdObj)           创建一个向指定文件描述符处写入数据的输出文件流，该文件描述符表示一个到文件系统中的某个实际文件的现有连接。
FileOutputStream(String name)           创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(String name, boolean append)           创建一个向具有指定 name 的文件中写入数据的输出文件流。

 

方法摘要
void	close()           关闭此文件输出流并释放与此流有关的所有系统资源。
protected  void	finalize()           清理到文件的连接，并确保在不再引用此文件输出流时调用此流的 close 方法。
FileChannel	getChannel()           返回与此文件输出流有关的唯一 FileChannel 对象。
FileDescriptor	getFD()           返回与此流有关的文件描述符。
void	write(byte[] b)           将 b.length 个字节从指定 byte 数组写入此文件输出流中。
void	write(byte[] b, int off, int len)           将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
void	write(int b)           将指定字节写入此文件输出流。

 

缓冲流：

功能：提高读写效率

构造方法摘要
BufferedInputStream(InputStream in)           创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
BufferedInputStream(InputStream in, int size)           创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
BufferedOutputStream(OutputStream out)           创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
BufferedOutputStream(OutputStream out, int size)           创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。

注：对于BufferedOutputStream要么用flush（）方法强制想缓冲区的数据读出来，要么要及时close（），否则数据留在缓冲区，会导致数据没有读到输出文件中。

综合实例：

package lesson12;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

 

public class FileIO {

       /**定义一个类，实现文件复制功能

        * @param args

        */

       public static void main(String[] args) {

              //注意两个路径的文件的后缀名一定要相同，否则可以复制，但打开会有乱码

              String inputFile = "D:/soft/jdk1.6.CHM";

              String outputFile = "D:\\Java\\src\\lesson12\\输出文件.CHM";

                     FileIO file = new FileIO();

                     file.copy(inputFile,outputFile);

       }

       //方法

       public  void copy(String InputFile,String OutputFile) {

                     try {

                            //定义输入流

                            InputStream ips = new FileInputStream(InputFile);

                            //定义缓冲输入流

                            BufferedInputStream bis = new BufferedInputStream(ips);

                            //计算输入文件的长度

                            int len = ips.available();

                            //定义一个字节数组，长度为文件大小

                            byte[] array = new byte[len];

                            //读取数据

                            ips.read(array);

                            //定义文件输出流

                            OutputStream ops= new FileOutputStream(OutputFile);

                            //定义缓冲流

                            BufferedOutputStream bos = new BufferedOutputStream(ops);

                            //将数组的内容输出到指定文件里

                            bos.write(array);

                            //一定要记得关闭流

                            bos.flush();

                            ops.close();

                            ips.close();

                            bos.close();

                            bis.close();

                            System.out.println("文件输出成功！！");

                     } catch (FileNotFoundException e) {

                            e.printStackTrace();

                     } catch (IOException e) {

                            e.printStackTrace();

                     }

       }

}