JAVA IO流学习笔记

JAVA IO流学习笔记

---

---

一、IO简介_Java中IO流类的体系

1. InputStream/OutputStream
   字节流的抽象类。

2. Reader/Writer
   字符流的抽象类。

3. FileInputStream/FileOutputStream
   节点流：以字节为单位直接操作“文件”。

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

5. ObjectInputStream/ObjectOutputStream
   处理流：以字节为单位直接操作“对象”。

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

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

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

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

10. InputStreamReader/OutputStreamWriter
    处理流：将字节流对象转化成字符流对象。

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

二、IO流入门案例

1.第一个简单的IO流程序

package IO;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class firstDome {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            //创建字节输入流对象
            fis = new FileInputStream("c:/javatest/a.txt");
            int s1 = fis.read();  //打印输入字符a对应的ascii码值97
            int s2 = fis.read();  //打印输入字符a对应的ascii码值98
            int s3 = fis.read();  //打印输入字符a对应的ascii码值99
            int s4 = fis.read();  //由于文件内容已经读取完毕，则返回-1
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
            System.out.println(s4);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (fis != null){
                try{
                    fis.close();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

2.改造入门案例

package IO;

import java.io.FileInputStream;

public class SecondDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try{
            //创建字节输入流对象
            fis = new FileInputStream("c:/javatest/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()//测试文件是否被这个抽象路径名是一个隐藏文件。

package IO;

import java.io.File;

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

2.操作目录

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

package IO;

import java.io.File;

public class DirectoryDemo {
    public static void main(String[] args) {
        //创建File对象
        File file = new File("c:/javatest/a");
        System.out.println(file.mkdir());
        File file2 = new File("c:/javatest/b/c");
        System.out.println(file2.mkdirs());
        System.out.println(file2.exists());
        System.out.println(file2.isDirectory());
        System.out.println(file.getParent());
        System.out.println(file2.getParent());
        System.out.println(file2.getParentFile().getName());
        File file3 = new File("c:/");
        String[] arr = file3.list();  //返回当前目录下所有的文件和所有目录的名字
        for (String temp:arr){
            System.out.println(temp);
        }
        System.out.println("------------------------");
        File[] arr2 = file3.listFiles();   //返回当前文件名和这个文件的绝对路径
        for (File temp:arr2){
            System.out.println(temp);
        }
    }
}

四、常用IO流对象

1.文件字节流

文件字节输入流

package IO;

import java.io.FileInputStream;

public class FileStreamDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try{
                //创建文件字节输入流对象
            fis = new FileInputStream("c:/javatest/java数据结构.png");
            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();
            }
        }
    }
}

文件字节输出流

package IO;

        import java.io.FileInputStream;
        import java.io.FileOutputStream;

public class FileStreamDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
            //创建文件字节输入流对象
            fis = new FileInputStream("c:/javatest/java数据结构.png");
            //创建文件字节输出流对象
            fos = new FileOutputStream("c:/javatest/io.png");
            int temp = 0;
            while ((temp = fis.read())!=-1){
                fos.write(temp);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (fis != null){
                    fis.close();
                }
                if (fos != null){
                    fos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

2.通过缓冲区提高读写效率

方式一（效率较低，空间节省）

通过创建一个指定长度的字节数组作为缓冲区，以此来提高 IO 流的读写效率。该方式
适用于读取较大图片时的缓冲区定义。注意：缓冲区的长度一定是 2 的整数幂。一般情况下
1024 长度较为合适。

package IO;

        import java.io.FileInputStream;
        import java.io.FileOutputStream;

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

方式二（效率高，空间浪费）

通过创建一个字节数组作为缓冲区，数组长度是通过输入流对象的 available()返回当前
文件的预估长度来定义的。在读写文件时，是在一次读写操作中完成文件读写操作的。注意：
如果文件过大，那么对内存的占用也是比较大的。所以大文件不建议使用该方法。

package IO;

        import java.io.FileInputStream;
        import java.io.FileOutputStream;

public class FileStreamDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
            //创建文件字节输入流对象
            fis = new FileInputStream("c:/javatest/java数据结构.png");
            //创建文件字节输出流对象
            fos = new FileOutputStream("c:/javatest/io.png");
            //创建一个缓冲区，提高读写效率
            //方法二
            byte[] buff = new byte[fis.available()];
            fis.read(buff);
            //将数据从内存中写入到磁盘中
            fos.write(buff);
            fos.flush();


            //方法一
//            byte[] buff = new byte[1024];
//            int temp = 0;
//            while ((temp = fis.read(buff))!=-1){
//                fos.write(temp);
//            }
//            //将数据从内存中写到磁盘中
//            fos.flush();


            //原始方法
//            int temp =0;
//            while ((temp = fis.read())!=-1){
//                fos.write(temp);
//            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (fis != null){
                    fis.close();
                }
                if (fos != null){
                    fos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

3.通过字节缓冲流提高读写效率

package IO;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

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("c:/javatest/java数据结构.png");
            bis = new BufferedInputStream(fis);
            fos = new FileOutputStream("c:/javatest/aa.png");
            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();
            }
        }
    }
}

4.定义文件拷贝工具类

//定义文件拷贝工具类
public class FileCopyTools {
    public static void main(String[] args) {
        copyFile("c:/javatest/java数据结构.png","c:/javatest/copy.png");
    }
    //文件拷贝方法
    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();
            }
        }
    }
}

五、文件字符流

1.文件字符输入流

package IO;

import java.io.FileReader;

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

2.文件字符输出流

package IO;

import java.io.FileWriter;

public class FileWriteDemo {
    public static void main(String[] args) {
        FileWriter fw =null;
        FileWriter fw1 = null;
        try{
            //创建字符输出流
            fw = new FileWriter("c:/javatest/fw.txt");
            fw.write("我要进大厂\r\n");
            fw.write("华为\r\n");
            fw1 = new FileWriter("c:/javatest/fw.txt",true);  //第二个参数决定是否追加
            //fw1 = new FileWriter("c:/javatest/fw.txt");   //如果新的FileWriter操作同一个文件没有给定追加的话，默认为覆
            fw1.write("如果新的FileWriter操作同一个文件没有给定追加的话，默认为覆盖");
            fw.flush();
            fw1.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (fw != null){
                    fw.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

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

//使用字符流实现文本文件的拷贝处理
public class FileCopyTools2 {
    public static void main(String[] args) {
        FileReader fr = null;
        FileWriter fw = null;
        try{
            fr = new FileReader("c:/javatest/fw.txt");
            fw = new FileWriter("c:/javatest/fw1.txt");
            int temp = 0 ;
            char[] buffer = new char[1024];
            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();
            }
        }
    }
}

六、字符缓冲流

1.字符输入缓冲流

//字符输入缓冲流
public class BufferedReaderDemo {
    public static void main(String[] args) {
        FileReader fr = null;
        BufferedReader br = null;
        try{
            fr = new FileReader("c:/javatest/fw.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.字符输出缓冲流

//字符输出缓冲流
public class BufferedWriterDemo {
    public static void main(String[] args) {
        FileWriter fw = null;
        BufferedWriter bw = null;
        try{
            fw = new FileWriter("c:/javatest/aaa.txt");
            bw = new BufferedWriter(fw);
            bw.write("这是字符输出缓冲流");
            bw.newLine();
            bw.write("BufferedWriter的newLine具有换行功能");
            bw.newLine();
            bw.write("第三行");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (bw != null){
                    bw.close();
                }
                if (fw != null){
                    fw.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

3.基于字符流缓冲流实现文件拷贝

    //基于字符流缓冲流实现文件拷贝
    public static void FileCopy(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.为文件中的内容添加行号

//为文件中的内容添加行号
public class LineNumberDemo {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try{
            br = new BufferedReader(new FileReader("c:/javatest/aaa.txt"));
            bw = new BufferedWriter(new FileWriter("c:/javatest/aaa2.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();
            }
        }
    }
}

七、转换流

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;
                }else if ("退出".equals(input)){
                    break;
                }
                bw.write("你输入的是:"+input);
                bw.newLine();

            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (br != null){
                    br.close();
                }
                if (bw != null){
                    bw.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

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

//通过字节流读取文本文件并添加行号
public class LineNumberDemo2 {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try{
            br = new BufferedReader(new InputStreamReader(new FileInputStream("c:/javatest/aaa.txt")));
            bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("c:/javatest/aaa3.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();
            }
        }
    }
}

八、字符输出流_PrintWriter

//字符输出流_PrintWriter
public class LineNumberDemo3 {
    public static void main(String[] args) {
        BufferedReader br = null;
        PrintWriter pw = null;
        try{
            br = new BufferedReader(new InputStreamReader(new FileInputStream("c:/javatest/aaa.txt")));
            pw = new PrintWriter("c:/javatest/aaa4.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();
            }
        }
    }
}

九、字节数组流

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{
                if (bis != null){
                    bis.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

2.字节数组输出流

//字节数组输出流
public class ByteArrayOutputDemo {
    public static void main(String[] args) {
        ByteArrayOutputStream bos = null;
        StringBuilder sb = new StringBuilder();
        try{
            bos = new ByteArrayOutputStream();
            bos.write('a');
            bos.write('b');
            bos.write('c');
            byte[] arr = bos.toByteArray();
            for (int i=0;i<arr.length;i++){
                sb.append((char)arr[i]);
            }
            System.out.println(sb.toString());
        }finally {
            try{
                bos.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

十、数据流

1.数据输出流

//数据输出流
public class DataOutputDemo {
    public static void main(String[] args) {
        DataOutputStream dos = null;
        try{
            dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("c:/javatest/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("c:/javatest/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();
            }
        }
    }
}

十一、对象流

对象的本质是用来组织和存储数据的，对象本身也是数据。那么，能不能将对象存储到
硬盘上的文件中呢？能不能将对象通过网络传输到另一个电脑呢？我们可以通过序列化和
反序列化来实现这些需求。

1.ava对象的序列化和反序列化

2.写出基本数据类型数据

//对象流_写出基本数据类型数据
public class ObjectOutputStreamBasicTypeDemo {
    public static void main(String[] args) {
        ObjectOutputStream oos = null;
        try{
            oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("c:/javatest/object.txt")));
            oos.writeInt(10);
            oos.writeDouble(Math.random());
            oos.writeChar('a');
            oos.writeBoolean(true);
            oos.writeUTF("好好努力");
            oos.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (oos != null) {
                    oos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

3.读取基本数据类型数据

//对象流_读取基本数据类型数据
public class ObjectInputStreamBasicTypeDemo {
    public static void main(String[] args) {
        ObjectInputStream ois = null;
        try{
            ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("c:/javatest/object.txt")));
            System.out.println(ois.readInt());
            System.out.println(ois.readDouble());
            System.out.println(ois.readChar());
            System.out.println(ois.readBoolean());
            System.out.println(ois.readUTF());
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (ois != null){
                    ois.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

4.将对象序列化到文件

//将对象序列化到文件
public class ObjectOutputStreamObjectTypeDemo {
    public static void main(String[] args) {
        ObjectOutputStream oos = null;
        try{
            oos = new ObjectOutputStream(new FileOutputStream("c:/javatest/obj.txt"));
            Users users = new Users(1,"Corey","19");
            oos.writeObject(users);
            oos.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (oos != null){
                    oos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

5.将对象反序列化到内存

//对象流_将对象反序列化到内存
public class ObjectInputStreamObjectTypeDemo {
    public static void main(String[] args) {
        ObjectInputStream ois = null;
        try{
            ois = new ObjectInputStream(new FileInputStream("c:/javatest/obj.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();
            }
        }
    }
}

十二、随机访问流

RandomAccessFile 可以实现两个作用：

1. 实现对一个文件做读和写的操作。
2. 可以访问文件的任意位置。不像其他流只能按照先后顺序读取。
   在开发某些客户端软件时，经常用到这个功能强大的可以”任意操作文件内容”的类。比
   如，软件的使用次数和使用日期，可以通过本类访问文件中保存次数和日期的地方进行比对和修改。 Java 很少开发客户端软件，所以在 Java 开发中这个类用的相对较少。
   学习这个流我们需掌握三个核心方法：
   1、 RandomAccessFile(String name, String mode) name 用来确定文件； mode 取
   r(读)或 rw(可读写)，通过 mode 可以确定流对文件的访问权限。
   2、seek(long a) 用来定位流对象读写文件的位置，a 确定读写位置距离文件开头
   的字节个数。
   3、 getFilePointer() 获得流的当前读写位置

//随机访问流
public class RandomAccessFileDemo {
    public static void main(String[] args) {
        RandomAccessFile raf = null;
        try{
            raf = new RandomAccessFile("c:/javatest/raf.txt","rw");
            //将若干数据写入到文件中
            int[] arr = new int[]{10,20,30,40,50,60,70,80,90,100};
            for (int i=0;i<arr.length;i++){
                raf.writeInt(arr[i]);
            }
            //按照字节数读取某一个数据    seek指针位置从0开始
            raf.seek(4);
            System.out.println(raf.readInt());

            //隔一个读取一个数据
            for (int i = 0;i<10;i+=2){
                raf.seek(i*4);
                System.out.print(raf.readInt()+"\t");
            }
            System.out.println();
            //在第8个字节位置插入一个新的数据45，替换之前的数据30
            raf.seek(8);
            raf.writeInt(45);
            for (int i = 0;i<10;i+=2){
                raf.seek(i*4);
                System.out.print(raf.readInt()+"\t");
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (raf != null){
                    raf.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

十三、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("c:/javatest/aaa.txt")));
            bw = new BufferedWriter(new FileWriter(new File("c:/javatest/file.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.Apache IO包简介

2.下载与添加commons-io包

1.下载地址

https://commons.apache.org/proper/commons-io/download_io.cgi

2.添加jar包

具体步骤：

3.FileUitls的使用

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

//FileUitls的使用
//readFileToString：将文件内容作为字符串返回。
public class FileUtilsDemo1 {
    public static void main(String[] args) throws Exception{
        String content = FileUtils.readFileToString(new File("c:/javatest/aaa.txt"),"utf-8");
        System.out.println(content);
    }
}

2.copyDirectory：将一个目录内容拷贝到另一个目录。可以通过 FileFilter 过滤需要拷贝的文件

//copyDirectory：将一个目录内容拷贝到另一个目录。可以通过 FileFilter 过滤需要拷贝的文件
public class FileUtilsDemo2 {
    public static void main(String[] args) throws Exception{
        FileUtils.copyDirectory(new File("c:/javatest/a"),new File("c:/javatest/c"), new FileFilter() {
            //在文件拷贝时的过滤条件
            @Override
            public boolean accept(File pathname) {
                if (pathname.isDirectory() || pathname.getName().endsWith("html")){
                    return true;
                }
                return false;
            }
        });
    }
}

4.IOUtils的使用

打开 IOUtils 的 api 文档，我们发现它的方法大部分都是重载的。所以，我们理解它的方
法并不是难事。因此，对于方法的用法总结如下：
buffer 方法：将传入的流进行包装，变成缓冲流。并可以通过参数指定缓冲大小。
closeQueitly 方法：关闭流。
contentEquals 方法：比较两个流中的内容是否一致。
copy 方法：将输入流中的内容拷贝到输出流中，并可以指定字符编码。
copyLarge 方法：将输入流中的内容拷贝到输出流中，适合大于 2G 内容的拷贝。
lineIterator 方法：返回可以迭代每一行内容的迭代器。
read 方法：将输入流中的部分内容读入到字节数组中。
readFully 方法：将输入流中的所有内容读入到字节数组中。
readLine 方法：读入输入流内容中的一行。
toBufferedInputStream，toBufferedReader：将输入转为带缓存的输入流。
toByteArray，toCharArray：将输入流的内容转为字节数组、字符数组。
toString：将输入流或数组中的内容转化为字符串。
write 方法：向流里面写入内容。
writeLine 方法：向流里面写入一行内容

//toString：将输入流或数组中的内容转化为字符串。
public class IOUtilsDemo {
    public static void main(String[] args) throws Exception{
        String content = IOUtils.toString(new FileInputStream("c:/javatest/aaa.txt"),"utf-8");
        System.out.println(content);
    }
}

十五、总结

---