Java IO流

一、IO简介 1、四大IO抽象类（1）InputStream

此抽象类是表示字节输入流的所有类的父类。

常用方法：

int read()：读取一个字节的数据，并将字节的值作为 int 类型返回(0-255 之间的一个值)。如果未读出字节则返回-1（返回值为-1 表示读取结束）。
void close()：关闭输入流对象，释放相关系统资源。

（2）OutputStream

此抽象类是表示字节输出流的所有类的父类。

常用方法：

void write(int n)：向目的地中写入一个字节。
void close()：关闭输出流对象，释放相关系统资源。

（3）Reader

Reader 用于读取的字符流抽象类，数据单位为字符。

常用方法：

int read(): 读取一个字符的数据，并将字符的值作为 int 类型返回(0-65535 之间的一个值，即 Unicode 值)。如果未读出字符则返回-1（返回值为-1 表示读取结束）。
void close() ：关闭流对象，释放相关系统资源。

（4）Writer

Writer 用于输出的字符流抽象类，数据单位为字符。

常用方法：

void write(int n)：向输出流中写入一个字符。
void close() ：关闭输出流对象，释放相关系统资源。

2、Java 中 IO 流类的体系

InputStream/OutputStream

字节流的抽象类。

Reader/Writer

字符流的抽象类。

FileInputStream/FileOutputStream

节点流：以字节为单位直接操作“文件”。

ByteArrayInputStream/ByteArrayOutputStream

节点流：以字节为单位直接操作“字节数组对象”。

ObjectInputStream/ObjectOutputStream

处理流：以字节为单位直接操作“对象”。

DataInputStream/DataOutputStream

处理流：以字节为单位直接操作“基本数据类型与字符串类型”。

FileReader/FileWriter

节点流：以字符为单位直接操作“文本文件”（注意：只能读写文本文件）。

BufferedReader/BufferedWriter

处理流：将 Reader/Writer 对象进行包装，增加缓存功能，提高读写效率。

BufferedInputStream/BufferedOutputStream

处理流：将 InputStream/OutputStream 对象进行包装，增加缓存功能，提高读写效率。

InputStreamReader/OutputStreamWriter

处理流：将字节流对象转化成字符流对象。

PrintStream

处理流：将 OutputStream 进行包装，可以方便地输出字符，更加灵活。

二、IO流入门案例当程序需要读取数据源的数据时，就会通过 IO 流对象开启一个通向数据源的流，通过这个 IO 流对象的相关方法可以顺序读取数据源中的数据。

public class Demo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            //创建字节输入流对象
            fis = new FileInputStream("d:/a.txt");
            StringBuilder sb = new StringBuilder();
            int temp = 0;
            while((temp = fis.read()) != -1) {
                System.out.println(temp);
                sb.append((char) temp);
            }
            System.out.println(sb.toString());
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(fis != null){
                    fis.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

三、File类 1、针对文件操作的方法

createNewFile()//创建新文件。
delete()//直接从磁盘上删除
exists()//查询磁盘中的文件是否存在
getAbsolutePath()//获取绝对路径
getPath()//获取相对路径
getName()//获取文件名相当于调用了一个 toString 方法。
isFile()//判断是否是文件
length()//查看文件中的字节数
isHidden()//测试文件是否被这个抽象路径名是一个隐藏文件。

public class FileDemo {
    public static void main(String[] args) throws Exception {
        //创建 File 对象
        File file = new File("d:/aa.txt");
        System.out.println(file.createNewFile());
        //System.out.println(file.delete());
        System.out.println(file.exists());
        System.out.println(file.getName());
        System.out.println(file.isFile());
        System.out.println(file.isHidden());
    }
}

2、针对目录操作的方法

exists()//查询目录是否存在
isDirectory()//判断当前路径是否为目录
mkdir()//创建目录
getParentFile()//获取当前目录的父级目录。
list()//返回一个字符串数组，包含目录中的文件和目录的路径名。
listFiles//返回一个 File 数组，表示用此抽象路径名表示的目录中的文件。

public class DirectoryDemo {
    public static void main(String[] args) {
        //创建 File 对象 
        File file = new File("d:/b/c");
        // System.out.println(file.mkdir());
        // System.out.println(file.mkdirs());
        // System.out.println(file.exists());
        // System.out.println(file.isDirectory());
        // System.out.println(file.getParent());
        // System.out.println(file.getParentFile().getName());
        File file2 = new File("d:/");
        String[] arr = file2.list();
        for(String temp:arr){
            System.out.println(temp);
        }
        System.out.println("-----------------------");
        File[] arr2 = file2.listFiles();
        for(File temp :arr2){
            System.out.println(temp);
        }
    }
}

四、常用IO流对象 1、文件字节流（1）文件字节输入流

public class FileStreamDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try{
            //创建文件字节输入流对象
            fis = new FileInputStream("d:/sxt.jpg");
            int temp = 0;
            while((temp = fis.read()) != -1){
                System.out.println(temp);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(fis != null){
                    fis.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

（2）文件字节输出流

public class FileStreamDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
            //创建文件字节输入流对象
            fis = new FileInputStream("d:/itbz.jpg");
            //创建文件字节输出流对象
            fos = new FileOutputStream("d:/dd.jpg");
            int temp = 0;
            while((temp = fis.read()) != -1){
                fos.write(temp);
            }
            //将数据从内存中写入到磁盘中。
            fos.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(fis != null){
                    fis.close();
                }
                if(fos != null){
                    fos.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

（3）通过缓冲区提高读写效率

方法一：

public class FileStreamBuffedDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
            //创建文件字节输入流对象
            fis = new FileInputStream("d:/itbz.jpg");
            //创建文件字节输出流对象
            fos = new FileOutputStream("d:/cc.jpg");
            //创建一个缓冲区，提高读写效率
            byte[] buff = new byte[1024];
            int temp = 0;
            while((temp = fis.read(buff)) != -1){
                fos.write(buff,0,temp);
            }
            //将数据从内存中写入到磁盘中。
            fos.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(fis != null){
                    fis.close();
                }
                if(fos != null){
                    fos.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

方法二：

public class FileStreamBuffedDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
            //创建文件字节输入流对象
            fis = new FileInputStream("d:/itbz.jpg");
            //创建文件字节输出流对象
            fos = new FileOutputStream("d:/cc.jpg");
            //创建一个缓冲区，提高读写效率
            byte[] buff = new byte[fis.available()];
            fis.read(buff);
            //将数据从内存中写入到磁盘中。
            fos.write(buff);
            fos.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(fis != null){
                    fis.close();
                }
                if(fos != null){
                    fos.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

（4）通过字节缓冲流提高读写效率

public class FileStreamBuffedDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try{
            fis = new FileInputStream("d:/itbz.jpg");
            bis = new BufferedInputStream(fis);
            fos = new FileOutputStream("d:/ff.jpg");
            bos = new BufferedOutputStream(fos);
            //缓冲流中的byte数组长度默认是8192
            int temp = 0;
            while((temp = bis.read()) != -1){
                bos.write(temp);
            }
            bos.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
            //注意：关闭流顺序："后开的先关闭"
            if(bis != null){
                bis.close();
            }
            if(fis != null){
                fis.close();
            }
            if(bos != null){
                bos.close();
            }
            if(fos !=null){
                fos.close();
            }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

（5）定义文件拷贝工具类

public class FileCopyTools {
    public static void main(String[] args) {
            copyFile("d:/itbz.jpg","d:/abc.jpg");
    }
    
    public static void copyFile(String src,String des){
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        FileOutputStream fos = null;
        BufferedOutputStream bos = null;

        try{
            bis = new BufferedInputStream(new FileInputStream(src));
            bos = new BufferedOutputStream(new FileOutputStream(des));
            int temp = 0;
            while((temp = bis.read()) != -1){
                bos.write(temp);
            }
            bos.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(bis != null){
                    bis.close();
                }
                if(fis != null){
                    fis.close();
                }
                if(bos != null){
                    bos.close();
                }
                if(fos != null){
                    fos.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

2、文件字符流（1）文件字符输入流

public class FileReaderDemo {
    public static void main(String[] args) {
        FileReader frd = null;
        try{
            //创建文件字符输入流对象
            frd = new FileReader("d:/a.txt");
            int temp = 0;
            while((temp = frd.read()) != -1){
                System.out.println((char) temp);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(frd != null){
                    frd.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

（2）文件字符输出流

public class FileWriterDemo {
    public static void main(String[] args) {
        FileWriter fw = null;
        FileWriter fw2 = null;
        try{
            //创建字符输出流对象
            fw = new FileWriter("d:/sxt.txt");
            fw.write("aaaarn");
            fw.write("bbbbrn");
            fw.flush();

            fw2 = new FileWriter("d:/sxt.txt",true);
            fw2.write("ccccrndddd");
            fw2.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(fw != null){
                    fw.close();
                }
                if(fw2 != null){
                    fw2.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

（3）使用字符流实现文本文件的拷贝处理

public class FileCopyTools {
    public static void main(String[] args) {
        FileReader fr = null;
        FileWriter fw = null;
        try{
            fr = new FileReader("d:/2.txt");
            fw = new FileWriter("d:/3.txt");
            char[] buffer = new char[1024];
            int temp = 0;
            while((temp = fr.read(buffer)) != -1){
                fw.write(buffer,0,temp);
            }
            fw.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(fr != null){
                    fr.close();
                }
                if(fw != null){
                    fw.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

3、字符缓冲流（1）字符输入缓冲流

readLine()：以行为单位进行读取。

public class BufferedReaderDemo {
    public static void main(String[] args) {
        FileReader fr = null;
        BufferedReader br = null;
        try{
            fr = new FileReader("d:/sxt.txt");
            br = new BufferedReader(fr);
            String temp = "";
            while((temp = br.readLine()) != null){
                System.out.println(temp);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(br != null){
                    br.close();
                }
                if(fr != null){
                    fr.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

（2）字符输出缓冲流

newLine()：方法实现换行处理。

public class BufferedWriterDemo {
    public static void main(String[] args) {
        FileWriter fw = null;
        BufferedWriter bw = null;
        try{
            fw = new FileWriter("d:/sxt2.txt");
            bw = new BufferedWriter(fw);
            bw.write("aaaa");
            bw.write("bbbb");
            bw.newLine();
            bw.write("cccc");
            bw.newLine();
            bw.write("dddd");
            bw.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(bw != null){
                    bw.close();
                }
                if(fw != null){
                    fw.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

（3）通过字符缓冲流实现文本文件的拷贝

public class FileCopyTools {
    public static void main(String[] args) {
            copyFile("d:/2.txt","d:/22.txt");
    }
    
    public static void copyFile(String src,String des){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try{
                br = new BufferedReader(new FileReader(src));
                bw = new BufferedWriter(new FileWriter(des));
                String temp = "";
                while((temp = br.readLine()) != null){
                    bw.write(temp);
                    bw.newLine();
                }
                bw.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(br != null){
                    br.close();
                }
                if(bw != null){
                    bw.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }

    }
}

4、转换流（1）通过转换流实现键盘输入屏幕输出

public class ConvertStream {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
      try{
          br = new BufferedReader(new InputStreamReader(System.in));
          bw = new BufferedWriter(new OutputStreamWriter(System.out));
         while(true){
             bw.write("请输入：");
             bw.flush();
             String input = br.readLine();
             if("exit".equals(input)){
                 break;
             }
             bw.write("你输入的是："+input);
             bw.newLine();
             bw.flush();
         }
      }catch(Exception e){
          e.printStackTrace();
      }finally{
          try{
              if(bw != null){
                  bw.close();
              }
              if(br != null){
                  br.close();
              }

          }catch(Exception e){
              e.printStackTrace();
          }
      }
    }
}

（2）通过字节流读取文本文件并添加行号

public class Demo {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try{
            br = new BufferedReader(new InputStreamReader(new FileInputStream("d:/sxt.txt")));
            bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d:/sxt3.txt")));
            String temp = "";
            int i = 1;
            while((temp = br.readLine()) != null){
                bw.write(i+","+temp);
                bw.newLine();
                i++;
            }
            bw.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(br != null){
                    br.close();
                }
                if(bw != null ){
                    bw.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

5、字符输出流

可以按行写出字符串
println()：自动换行。

public class Demo {
    public static void main(String[] args) {
        BufferedReader br = null;
        PrintWriter pw = null;
        try{
            br = new BufferedReader(new InputStreamReader(new FileInputStream("d:/sxt.txt")));
            pw = new PrintWriter("d:/sxt4.txt");
            String temp ="";
            int i = 1;
            while((temp = br.readLine()) != null){
                pw.println(i+","+temp);
                i++;
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(br != null){
                    br.close();
                }
                if(pw != null){
                    pw.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

6、字节数组流（1）字节数组输入流

public class ByteArrayInputDemo {
    public static void main(String[] args) {
        byte[] arr = "abcdefg".getBytes();
        ByteArrayInputStream bis = null;
        StringBuilder sb = new StringBuilder();
        try{
            //该构造方法的参数是一个字节数组，这个字节数组就是数据源
            bis = new ByteArrayInputStream(arr);
            int temp = 0;
            while ((temp = bis.read()) != -1){
                sb.append((char)temp);
            }
            System.out.println(sb.toString());
        }finally{
            try{
                bis.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

（2）字节数组输出流

public class ByteArrayOutputDemo {
    public static void main(String[] args) {
        ByteArrayOutputStream bos = null;
        try{
            StringBuilder sb = new StringBuilder();
                bos = new ByteArrayOutputStream();
                bos.write('a');
                bos.write('b');
                bos.write('c');
                byte[] arr = bos.toByteArray();
                for(int i=0;i

7、数据流（1）数据输出流

public class DataOutputDemo {
    public static void main(String[] args) {
        DataOutputStream dos = null;
        try{
           dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("d:/data.txt")));
            dos.writeChar('a');
            dos.writeInt(10);
            dos.writeDouble(Math.random());
            dos.writeBoolean(true);
            dos.writeUTF("你好尚学堂");
            dos.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(dos != null){
                    dos.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

（2）数据输入流

public class DataInputDemo {
    public static void main(String[] args) {
        DataInputStream dis = null;
        try{
            dis = new DataInputStream(new BufferedInputStream(new FileInputStream("d:/data.txt")));
            //直接读取数据，注意：读取的顺序要与写入的顺序一致，否则不能正确读取数据。
            System.out.println("char: "+dis.readChar());
            System.out.println("int: "+dis.readInt());
            System.out.println("double: "+dis.readDouble());
            System.out.println("boolean: "+dis.readBoolean());
            System.out.println("String: "+dis.readUTF());
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(dis != null ){
                    dis.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

8、对象流（1）序列化和反序列化

ObjectOutputStream 代表对象输出流，它的 writeObject(Object obj)方法可对参数指定的obj 对象进行序列化，把得到的字节序列写到一个目标输出流中。
ObjectInputStream 代表对象输入流，它的 readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。
只有实现了 Serializable 接口的类的对象才能被序列化。Serializable 接口是一个空接口，只起到标记作用。

（2）操作基本数据类型

读取基本数据类型数据：

public class ObjectInputStreamBasicTypeDemo {
    public static void main(String[] args) {
        ObjectInputStream ois = null;
        try{
            ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("d:/sxt5.txt")));
            //必须要按照写入的顺序读取数据
            System.out.println("int: "+ois.readInt());
            System.out.println("double: "+ois.readDouble());
            System.out.println("char: "+ois.readChar());
            System.out.println("boolean: "+ois.readBoolean());
            System.out.println("String: "+ois.readUTF());
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(ois != null){
                    ois.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

（3）操作对象

创建对象：

public class Users implements Serializable {
    private int userid;
    private String username;
    private String userage;

    public Users(int userid, String username, String userage) {
        this.userid = userid;
        this.username = username;
        this.userage = userage;
    }

    public Users() {
    }

    public int getUserid() {
        return userid;
    }

    public void setUserid(int userid) {
        this.userid = userid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getUserage() {
        return userage;
    }

    public void setUserage(String userage) {
        this.userage = userage;
    }
}

序列化对象：

public class ObjectOutputStreamObjectTypeDemo {
    public static void main(String[] args) {
        ObjectOutputStream oos = null;
        try{
            oos = new ObjectOutputStream(new FileOutputStream("d:/sxt6.txt"));
            Users users = new Users(1,"Oldlu","18");
            oos.writeObject(users);
            oos.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(oos != null){
                    oos.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

将对象反序列化到内存中：

public class ObjectInputStreamObjectTypeDemo {
    public static void main(String[] args) {
        ObjectInputStream ois = null;
        try{
            ois = new ObjectInputStream(new FileInputStream("d:/sxt6.txt"));
            Users users =  (Users)ois.readObject();
            System.out.println(users.getUserid()+"t"+users.getUsername()+"t"+users.getUserage());
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(ois != null){
                    ois.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

9、随机访问流作用：

实现对一个文件做读和写的操作。
可以访问文件的任意位置。不像其他流只能按照先后顺序读取。

方法：

RandomAccessFile(String name, String mode) name 用来确定文件； mode 取 r(读)或 rw(可读写)，通过 mode 可以确定流对文件的访问权限。
seek(long a) 用来定位流对象读写文件的位置，a 确定读写位置距离文件开头的字节个数。
getFilePointer() 获得流的当前读写位置。

public class RandomAccessFileDemo {
    public static void main(String[] args) {
        RandomAccessFile raf = null;
        try{
            raf = new RandomAccessFile("d:/sxt7.txt","rw");
            //将若干数据写入到文件中
            int[] arr = new int[]{10,20,30,40,50,60,70,80,90,100};
            for(int i=0;i

10、File 类在 IO 中的作用当以文件作为数据源或目标时，除了可以使用字符串作为文件以及位置的指定以外，也可以使用 File 类指定。

public class FileInIODemo {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try{
            br = new BufferedReader(new FileReader(new File("d:/sxt.txt")));
            bw = new BufferedWriter(new FileWriter(new File("d:/sxt8.txt")));
            String temp = "";
            int i =1;
            while((temp = br.readLine()) != null){
                    bw.write(i+","+temp);
                    bw.newLine();
                    i++;
            }
            bw.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(br != null){
                    br.close();
                }
                if(bw != null){
                    bw.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

五、Apache IO 包 1、FileUtils 的使用常用方法：

cleanDirectory：清空目录，但不删除目录。
contentEquals：比较两个文件的内容是否相同。
copyDirectory：将一个目录内容拷贝到另一个目录。可以通过 FileFilter 过滤需要拷贝的
文件。
copyFile：将一个文件拷贝到一个新的地址。
copyFileToDirectory：将一个文件拷贝到某个目录下。
copyInputStreamToFile：将一个输入流中的内容拷贝到某个文件。
deleteDirectory：删除目录。
deleteQuietly：删除文件。
listFiles：列出指定目录下的所有文件。
openInputSteam：打开指定文件的输入流。
readFileToString：将文件内容作为字符串返回。
readLines：将文件内容按行返回到一个字符串数组中。
size：返回文件或目录的大小。
write：将字符串内容直接写到文件中。
writeByteArrayToFile:将字节数组内容写到文件中。
writeLines：将容器中的元素的 toString 方法返回的内容依次写入文件中。
writeStringToFile ：将字符串内容写到文件中。

public class FileUtilsDemo1 {
    public static void main(String[] args)throws Exception { 
        String content = FileUtils.readFileToString(new File("d:/sxt.txt"),"utf-8");
        System.out.println(content);
    } 
}

2、IOUtils 的使用

常用方法：

buffer 方法：将传入的流进行包装，变成缓冲流。并可以通过参数指定缓冲大小。
closeQueitly 方法：关闭流。
contentEquals 方法：比较两个流中的内容是否一致。
copy 方法：将输入流中的内容拷贝到输出流中，并可以指定字符编码。
copyLarge 方法：将输入流中的内容拷贝到输出流中，适合大于 2G 内容的拷贝。
lineIterator 方法：返回可以迭代每一行内容的迭代器。
read 方法：将输入流中的部分内容读入到字节数组中。
readFully 方法：将输入流中的所有内容读入到字节数组中。
readLine 方法：读入输入流内容中的一行。
toBufferedInputStream，
toBufferedReader：将输入转为带缓存的输入流。
toByteArray，
toCharArray：将输入流的内容转为字节数组、字符数组。
toString：将输入流或数组中的内容转化为字符串。
write 方法：向流里面写入内容。
writeLine 方法：向流里面写入一行内容。

public class IOUtilsDemo { 
    public static void main(String[] args)throws Exception {
        String content = IOUtils.toString(new FileInputStream("d:/sxt.txt"),"utf-8"); 
        System.out.println(content); 
    } 
}

Java IO流

Java相关栏目本月热门文章