【IT168技术文档】 
    输入输出流 
    在Java中，我们把能够读取一个字节序列的对象称作一个输入流;而我们把够写一个字节序列称作一个输出流。它们分别由抽象类InputStream和OutputStream类表示。因为面向字节的流不方便用来处理存储为Unicode（每个字符使用两个字节)的信息。所以Java 引入了用来处理Unicode字符的类层次，这些类派生自抽象类Reader和Writer，它们用于读写双字节的Unicode字符，而不是单字节字符。 

    Java.io包简介 
    JDK标准帮助文档是这样解释Java.io包的，通过数据流、序列和文件系统为系统提供输入输出。 
    InputStream类和OutputStream类 
    InputStream类是所有输入数据流的父类，它是一个抽象类，定义了所有输入数据流都具有的共通特性。 
    java.io.InputStream的方法如下： 
    public abstract read()throws IOException 
    读取一个字节并返回该字节，如果到输入源的末则返回-1。一个具体的输入流类需要重载此方法，以提供 有用的功能。例如：在FileInputStream类中，该方法从一个文件读取一个字节。 
    public int read(byte[] b)throws IOException 
    把数据读入到一个字节数据中，并返回实际读取的字节数目。如果遇到流末 则返回-1，该方法最多读取b.length个字节。 
    public abstract int read(byte[] b,int off,int len)throws IOException 
    把数据读入到一个字节数组中并返回实际读取的字节数目。如果遇到流的末尾则的返回-1。 其中参数off表示第一个字节在b中的位置，len表示读取的最大字节数。 
    public long skip(long n)throws IOException 
    略过N个字节不读取，会返回实际略过的字节数目。因为数据流中剩下的数据可能不到N 个字节那么多，所以此时返回值会小于N。 
    public int available()throws IOException 
    read方法(包括后面要讲的OutputStream类的Write方法)都能够阴塞一个线程，直到字节被 实际读取或写入。这意味着如果一个流不能立即被读或被写

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/**//**
 *
 */

/**//**
 * @author Perkin.Yang
 *
 */
public class Files ...{
    public static void main(String[] args) throws IOException ...{
        Files f = new Files();

        f.fileIsNull("D:\\java\\", "TestFile.txt");
        f.readFile("D:\\java\\","TestFile.txt");
        // f.readLineFile("D:\\java\\","TestFile.txt");
        // System.out.println(f.fileIsNull("f:\\","122.txt"));
        // f.readFolderByFile("F:\\Login"); //不区分大小写
        // System.out.println(f.createAndDeleteFolder("ss","f:\\"));
        // System.out.println(f.createAndDeleteFile("f:\\ss\\","TestFile.dat"));
        // f.createAndDeleteFolder("1","D:\\java\\");
        String ss = new String(); // 定义对象数组
        // for(int i=0;i<ss.length;i++)
        // {
        ss = "信息技术和互联网(计算机软硬件,通讯)";
        // }
        f.writeFile("D:\\java\\", "TestFile.txt", ss);

    }

    /**//**
     * 文件的写入
     *
     * @param filePath(文件路径)
     * @param fileName(文件名)
     * @param args[]
     * @throws IOException
     */
    public void writeFile(String filePath, String fileName, String args)
            throws IOException ...{
        FileWriter fw = new FileWriter(filePath + fileName);
        PrintWriter out = new PrintWriter(fw);
        out.write("aa");
        out.write(args);
        out.println();
        // out.flush();

        System.out.println("写入成功！");
        fw.close();
        out.close();
    }

    /**//**
     * 文件的写入
     *
     * @param filePath(文件路径)
     * @param fileName(文件名)
     * @param args
     * @throws IOException
     */
    public void writeFile1(String filePath, String fileName, String args)
            throws IOException ...{
        FileWriter fw = new FileWriter(filePath + fileName);
        fw.write(args);
        fw.close();
    }

    /**//**
     * 创建与删除文件
     *
     * @param filePath
     * @param fileName
     * @return 创建成功返回true
     * @throws IOException
     */
    public boolean createAndDeleteFile(String filePath, String fileName)
            throws IOException ...{
        boolean result = false;
        File file = new File(filePath, fileName);
        if (file.exists()) ...{
            if (file.isFile()) ...{
                file.delete();
                result = true;
                System.out.println("文件已经删除！");
            } else ...{
                System.out.println("对不起,该路径为目录！");

            }
        } else ...{
            file.createNewFile(); // jdk5.0的新方法
            result = true;
            System.out.println("文件已经创建！");
        }
        return result;
    }

    /**//**
     * 创建和删除目录
     *
     * @param folderName
     * @param filePath
     * @return 删除成功返回true
     */
    public boolean createAndDeleteFolder(String folderName, String filePath) ...{
        boolean result = false;
        try ...{
            File file = new File(filePath + folderName);
            if (file.exists()) ...{
                if (file.isDirectory()) ...{
                    file.delete();
                    System.out.println("目录已经存在，已删除!");
                    result = true;
                } else ...{
                    System.out.println("对不起,该路径为文件！");
                }
            } else ...{
                file.mkdir();
                System.out.println("目录不存在，已经建立!");
                result = true;
            }
        } catch (Exception ex) ...{
            result = false;
            System.out.println("CreateAndDeleteFolder is error:" + ex);
        }
        return result;
    }

    /**//**
     * 输出目录中的所有文件及目录名字
     *
     * @param filePath
     */
    public void readFolderByFile(String filePath) ...{
        File file = new File(filePath);
        File[] tempFile = file.listFiles();
        for (int i = 0; i < tempFile.length; i++) ...{
            if (tempFile[i].isFile()) ...{
                System.out.println("File : " + tempFile[i].getName());
            }
            if (tempFile[i].isDirectory()) ...{
                System.out.println("Directory : " + tempFile[i].getName());
                this.readFolderByFile(tempFile[i].toString());
            }
        }
    }

    /**//**
     * 检查文件中是否为一个空
     *
     * @param filePath
     * @param fileName
     * @return 为空返回true
     * @throws IOException
     */
    public boolean fileIsNull(String filePath, String fileName)
            throws IOException ...{
        boolean result = false;
        FileReader fr = new FileReader(filePath + fileName);
        if (fr.read() == -1) ...{
            result = true;
            System.out.println(fileName + " 文件中没有数据!");
        } else ...{
            System.out.println(fileName + " 文件中有数据!");
        }
        fr.close();
        return result;
    }

    /**//**
     * 读取文件中的所有内容
     *
     * @param filePath
     * @param fileName
     * @throws IOException
     */
    public void readAllFile(String filePath, String fileName)
            throws IOException ...{
        FileReader fr = new FileReader(filePath + fileName);
        // PrintWriter pr=new PrintWriter(fr);
        // pr.print
        int count = fr.read();
        while (count != -1) ...{
            System.out.print((char) count);
            count = fr.read();
            // System.out.println();
            if (count == 13) ...{
                fr.skip(1);
                System.out.print("跳过!");
            }
        }
        System.out.println();
        fr.close();
    }

    /**//**
     * 一行一行的读取文件中的数据
     *
     * @param filePath
     * @param fileName
     * @throws IOException
     */
    public void readLineFile(String filePath, String fileName)
            throws IOException ...{
        FileReader fr = new FileReader(filePath + fileName);
        BufferedReader br = new BufferedReader(fr);
        String line = br.readLine();
        while (line != null) ...{
            System.out.println(line);
            line = br.readLine();
        }
        br.close();
        fr.close();
    }
    public void readFile(String filePath, String fileName) ...{
        try ...{
            FileReader reader = new FileReader(filePath + fileName);
            int count= reader.read();
            while (count != -1) ...{
                System.out.print((char) count);
                count = reader.read();
                if (count == 13) ...{
                    reader.skip(1);
                    System.out.print("跳过!");
                }
            }
            System.out.println();
            reader.close();
        } catch (Exception e) ...{
            e.printStackTrace();
        }

    }
}