• Java学习——文件和IO流


    Java学习——文件和IO流

    文件操作

    概念

    File是数据源(保存数据的地方)的一种,可以表示一个文件,也可以表示一个文件目录。

    File类只能对文件和文件夹进行创建和删除等操作,可以查看文件和文件夹的属性,不能读取或修改内容。如果需要读取或修改文件的内容,需要使用IO流。

    常常将File类的对象作为参数传递到IO流的类的构造器中。

    绝对路径和相对路径

    绝对路径:绝对路径名是完整的路径名,不需要任何其他信息就可以定位它所表示的文件或文件夹。

    相对路径:相对路径名必须使用取自其他路径名的信息进行解释。

    相对路径创建的实例不等于绝对路径创建的实例。

    常用方法

    ◆ 查看文件和文件夹

    获得文件名或目录名:String getName();

    获得相对路径:String getPath();

    获得绝对路径:String getAbsolutePath();

    ◆ 创建或删除文件和文件夹

    创建一个空文件:boolean createNewFile();

    创建一个空目录:boolean mkdir();

    创建指定的目录及父目录:boolean mkdirs();

    删除文件或空目录:boolean delete();

    ◆ 常用的判断方法

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

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

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

    常量

    ◆ File.separator

    与系统有关的默认名称分隔符,为了方便,它被表示为一个字符串。此字符串只包含一个字符,即separatorChar。

    separatorChar被初始化为包含系统属性file.separator值的第一个字符。在UNIX系统上,此字段的值为“/”;在Windows系统上,它为“”。

    ◆ File.pathSeparator

    与系统有关的路径分隔符,为了方便,它被表示为一个字符串。此字符串只包含一个字符,即pathSeparatorChar。

    pathSeparatorChar被初始为包含系统属性path.separator值的第一个字符。此字符用于分隔以路径列表形式给定的文件序列中的文件名。在UNIX系统上,此字段为“:”;在Windows系统上,它为“;”。

    IO流

    概念

    流:数据在数据源(文件)和程序(内存)之间经历的路径。

    以内存为参照,如果数据流向内存流动,则是输入流,反之,则是输出流。

    文件和文件夹在程序中是以流的形式来操作的。

    凡是与输入输出相关的都定义在java.io包下。

    打开的资源不属于内存里的资源,垃圾回收机制无法回收该资源,所以应该显式关闭IO资源。不过在JDK1.7之后,可以在try代码块中打开流,最后程序会自动关闭流对象,不再需要显示地关闭流。

    关闭流时只需要考虑关闭最外层的流即可,如果要强制关闭所有流,必须先关闭外层的流。

    流的分类

    按数据流的流向不同分为:输入流,输出流。

    按操作数据单位不同分为:字节流(InputStream、OutputStream),字符流(Reader、Writer)。

    按流的角色的不同分为:节点流,处理流。

    文件流

    文件流主要有:FileInputStream、FileOutputStream、FileReader、FileWriter。

    这四个类是专门操作文件流的,用法高度相似,区别在于前面两个是操作字节流,后面两个是操作字符流。

    它们都会直接操作文件流,直接与OS底层交互,因此他们也被称为节点流,节点流在输出时不需要考虑flush操作。

    FileInputStream

    构造方法

    FileInputStream(File file);

    FileInputStream(String name);

    常用方法

    从输入流中读入一个字节:int read();

    从输入流中读入到数组:int read(byte[] b);

    从输入流中将len个数据读入到数组:int read(byte[] b, int off, int len);

    关闭输入流并释放系统资源:void close();

    读入文件到输入流

     1 public void test() {
     2     FileInputStream fis = null;
     3     try {
     4         fis = new FileInputStream(new File("D:" + File.separator + "hello.txt"));
     5         byte[] buffer = new byte[1024];
     6         int len = 0;
     7         String txt = "";
     8         while ((len = fis.read(buffer)) != -1) {
     9             txt += new String(buffer, 0, len);
    10         }
    11         System.out.println(txt);
    12     } catch (IOException e) {
    13         e.printStackTrace();
    14     } finally {
    15         if (fis != null) {
    16             try {
    17                 fis.close();
    18             } catch (IOException e) {
    19                 e.printStackTrace();
    20             }
    21         }
    22     }
    23 }

    FileOutputStream

    构造方法

    FileOutputStream(File file);

    FileOutputStream(File file, boolean append);

    FileOutputStream(String name);

    FileOutputStream(String name, boolean append);

    常用方法

    从指定字节中写出到输出流:void write(int b);

    从数组中写出到输出流:void write(byte[] b);

    从数组中将len个数据写出到输出流:void write(byte[] b, int off, int len);

    刷新该流的缓冲:void flush();

    关闭输出流并释放系统资源:void close();

    读出文件到输出流

     1 public void test() {
     2     FileOutputStream fos = null;
     3     try {
     4         fos = new FileOutputStream(new File("D:" + File.separator + "hello.txt"));
     5         fos.write("hello".getBytes());
     6     } catch (IOException e) {
     7         e.printStackTrace();
     8     } finally {
     9         if (fos != null) {
    10             try {
    11                 fos.close();
    12             } catch (IOException e) {
    13                 e.printStackTrace();
    14             }
    15         }
    16     }
    17 }

    FileReader

    构造方法

    FileReader(File file);

    FileReader(String fileName);

    常用方法

    返回此流使用的字符编码的名称:String getEncoding();

    从输入流中读入一个字节:int read();

    从输入流中读入到数组:int read(char[] cbuf);

    从输入流中将len个数据读入到数组:int read(char[] cbuf, int off, int len);

    关闭输入流并释放系统资源:void close();

    读入文本到输入流

     1 public void test() {
     2     FileReader fr = null;
     3     try {
     4         fr = new FileReader(new File("D:" + File.separator + "hello.txt"));
     5         char[] buffer = new char[1024];
     6         int len = 0;
     7         String txt = "";
     8         while ((len = fr.read(buffer)) != -1) {
     9             txt = new String(buffer, 0, len);
    10         }
    11         System.out.print(txt);
    12     } catch (IOException e) {
    13         e.printStackTrace();
    14     } finally {
    15         if (fr != null) {
    16             try {
    17                 fr.close();
    18             } catch (IOException e) {
    19                 e.printStackTrace();
    20             }
    21         }
    22     }
    23 }

    FileWriter

    构造方法

    FileWriter(File file);

    FileWriter(File file, boolean append);

    FileWriter(String fileName);

    FileWriter(String fileName, boolean append);

    常用方法

    返回此流使用的字符编码的名称:String getEncoding();

    从指定字节中写出到输出流:void write(int b);

    从数组中写出到输出流:void write(byte[] b);

    从数组中将len个数据写出到输出流:void write(byte[] b, int off, int len);

    从字符串中写出到输出流:void write(String str);

    从字符串中将len个数据写出到输出流:void write(String str, int off, int len);

    刷新该流的缓冲:void flush();

    关闭输出流并释放系统资源:void close();

    读出文本到输出流

     1 public void test() {
     2     FileWriter fw = null;
     3     try {
     4         fw = new FileWriter(new File("D:" + File.separator + "hello.txt"));
     5         fw.write("hello");
     6     } catch (IOException e) {
     7         e.printStackTrace();
     8     } finally {
     9         if (fw != null) {
    10             try {
    11                 fw.close();
    12             } catch (IOException e) {
    13                 e.printStackTrace();
    14             }
    15         }
    16     }
    17 }

    文件的复制

    字节文件的复制

     1 public void test() {
     2     FileInputStream fis = null;
     3     FileOutputStream fos = null;
     4     try {
     5         fis = new FileInputStream("D:" + File.separator + "old.jpeg");
     6         fos = new FileOutputStream("D:" + File.separator + "new.jpeg");
     7         byte[] buffer = new byte[1024];
     8         int len = 0;
     9         while ((len = fis.read(buffer)) != -1) {
    10             fos.write(buffer, 0, len);
    11         }
    12     } catch (IOException e) {
    13         e.printStackTrace();
    14     } finally {
    15         if (fis != null) {
    16             try {
    17                 fis.close();
    18             } catch (IOException e) {
    19                 e.printStackTrace();
    20             }
    21         }
    22         if (fos != null) {
    23             try {
    24                 fos.close();
    25             } catch (IOException e) {
    26                 e.printStackTrace();
    27             }
    28         }
    29     }
    30 }

    字符文件的复制

     1 public void test() {
     2     FileReader fr = null;
     3     FileWriter fw = null;
     4     try {
     5         fr = new FileReader("D:" + File.separator + "old.txt");
     6         fw = new FileWriter("D:" + File.separator + "new.txt");
     7         char[] buffer = new char[1024];
     8         int len = 0;
     9         while ((len = fr.read(buffer)) != -1) {
    10             fw.write(buffer, 0, len);
    11         }
    12     } catch (IOException e) {
    13         e.printStackTrace();
    14     } finally {
    15         if (fr != null) {
    16             try {
    17                 fr.close();
    18             } catch (IOException e) {
    19                 e.printStackTrace();
    20             }
    21         }
    22         if (fw != null) {
    23             try {
    24                 fw.close();
    25             } catch (IOException e) {
    26                 e.printStackTrace();
    27             }
    28         }
    29     }
    30 }

    缓冲流

    缓冲流主要有:BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter。

    这四个类可以封装现有的节点流,实现对数据传输的效率的提升。

    缓冲流比文件流多了一个缓冲区,执行read时先从缓冲区读取,当缓冲区数据读完时再把缓冲区填满。因此,当每次读取的数据量很小时,文件流每次都是从硬盘读入,而缓冲流大部分是从缓冲区读入。读取内存速度比读取硬盘速度快得多,因此缓冲流效率高。

    缓冲流的默认缓冲区大小是8192字节。当每次读取数据量接近或远超这个值时,两者效率就没有明显差别了。

    缓冲流属于处理流,在输出时需要考虑使用flush操作。

    BufferedInputStream

    构造方法

    BufferedInputStream(InputStream in);

    BufferedInputStream(InputStream in, int size);

    常用方法

    从输入流中读入一个字节:int read();

    从输入流中读入到数组:int read(byte[] b);

    从输入流中将len个数据读入到数组:int read(byte[] b, int off, int len);

    关闭输入流并释放系统资源:void close();

    BufferedOutputStream

    构造方法

    BufferedOutputStream(OutputStream out);

    BufferedOutputStream(OutputStream out, int size);

    常用方法

    从指定字节中写出到输出流:void write(int b);

    从数组中写出到输出流:void write(byte[] b);

    从数组中将len个数据写出到输出流:void write(byte[] b, int off, int len);

    刷新该流的缓冲:void flush();

    关闭输出流并释放系统资源:void close();

    BufferedReader

    构造方法

    BufferedReader(Reader in);

    BufferedReader(Reader in, int size);

    常用方法

    从输入流中读入一个字节:int read();

    从输入流中读入到数组:int read(char[] cbuf);

    从输入流中将len个数据读入到数组:int read(char[] cbuf, int off, int len);

    关闭输入流并释放系统资源:void close();

    BufferedWriter

    构造方法

    BufferedWriter(Writer out);

    BufferedWriter(Writer out, int size);

    常用方法

    从指定字节中写出到输出流:void write(int c);

    从数组中写出到输出流:void write(char[] cbuf);

    从数组中将len个数据写出到输出流:void write(char[] cbuf, int off, int len);

    从字符串中写出到输出流:void write(String str);

    从字符串中将len个数据写出到输出流:void write(String str, int off, int len);

    刷新该流的缓冲:void flush();

    关闭输出流并释放系统资源:void close();

    文件的复制

    字节文件的复制

     1 public void test() {
     2     BufferedInputStream bis = null;
     3     BufferedOutputStream bos = null;
     4     try {
     5         bis = new BufferedInputStream(new FileInputStream("D:" + File.separator + "old.mp3"));
     6         bos = new BufferedOutputStream(new FileOutputStream("D:" + File.separator + "new.mp3"));
     7         byte[] buffer = new byte[1024];
     8         int len = 0;
     9         while ((len = bis.read(buffer)) != -1) {
    10             bos.write(buffer, 0, len);
    11         }
    12     } catch (IOException e) {
    13         e.printStackTrace();
    14     } finally {
    15         if (bis != null) {
    16             try {
    17                 bis.close();
    18             } catch (IOException e) {
    19                 e.printStackTrace();
    20             }
    21         }
    22         if (bos != null) {
    23             try {
    24                 bos.close();
    25             } catch (IOException e) {
    26                 e.printStackTrace();
    27             }
    28         }
    29     }
    30 }

    字符文件的复制

     1 public void test() {
     2     BufferedReader br = null;
     3     BufferedWriter bw = null;
     4     try {
     5         br = new BufferedReader(new FileReader("D:" + File.separator + "old.txt"));
     6         bw = new BufferedWriter(new FileWriter("D:" + File.separator + "new.txt"));
     7         char[] buffer = new char[1024];
     8         int len = 0;
     9         while ((len = br.read(buffer)) != -1) {
    10             bw.write(buffer, 0, len);
    11         }
    12     } catch (IOException e) {
    13         e.printStackTrace();
    14     } finally {
    15         if (br != null) {
    16             try {
    17                 br.close();
    18             } catch (IOException e) {
    19                 e.printStackTrace();
    20             }
    21         }
    22         if (bw != null) {
    23             try {
    24                 bw.close();
    25             } catch (IOException e) {
    26                 e.printStackTrace();
    27             }
    28         }
    29     }
    30 }

    转换流

    转换流主要有:InputStreamReader、OutputStreamWriter。

    这两个流可以将文本在字节流和字符流之间进行转换,但只能处理文本文件。

    InputStreamReader

    构造方法

    InputStreamReader(InputStream in);

    InputStreamReader(InputStream in, String charsetName);

    常用方法

    返回此流使用的字符编码的名称:String getEncoding();

    从输入流中读入一个字节:int read();

    从输入流中读入到数组:int read(char[] cbuf);

    从输入流中将len个数据读入到数组:int read(char[] cbuf, int off, int len);

    关闭输入流并释放系统资源:void close();

    OutputStreamWriter

    构造方法

    OutputStreamWriter(OutputStream out);

    OutputStreamWriter(OutputStream out, String charsetName);

    常用方法

    返回此流使用的字符编码的名称:String getEncoding();

    从指定字节中写出到输出流:void write(int c);

    从数组中写出到输出流:void write(char[] cbuf);

    从数组中将len个数据写出到输出流:void write(char[] cbuf, int off, int len);

    从字符串中写出到输出流:void write(String str);

    从字符串中将len个数据写出到输出流:void write(String str, int off, int len);

    刷新该流的缓冲:void flush();

    关闭输出流并释放系统资源:void close();

    文件的复制

     1 public void test() {
     2     InputStreamReader isr = null;
     3     OutputStreamWriter osw = null;
     4     try {
     5         isr = new InputStreamReader(new FileInputStream("D:" + File.separator + "old.txt"), "UTF-8");// 确定解码集
     6         osw = new OutputStreamWriter(new FileOutputStream("D:" + File.separator + "new.txt"), "UTF-8");// 确定编码集
     7         char[] buffer = new char[20];
     8         int len = 0;
     9         while ((len = isr.read(buffer)) != -1) {
    10             osw.write(buffer, 0, len);
    11         }
    12     } catch (IOException e) {
    13         e.printStackTrace();
    14     } finally {
    15         if (isr != null) {
    16             try {
    17                 isr.close();
    18             } catch (IOException e) {
    19                 e.printStackTrace();
    20             }
    21         }
    22         if (osw != null) {
    23             try {
    24                 osw.close();
    25             } catch (IOException e) {
    26                 e.printStackTrace();
    27             }
    28         }
    29     }
    30 }

    内存读写流

    内存读写流主要有:ByteArrayOutputStream、ByteArrayInputStream。

    内存读写流将数组当作流输入输出对象的类。

    不同于指向硬盘的流,它内部是使用字节数组读内存的,这个字节数组是它的成员变量,当这个数组不再使用变成垃圾的时候,Java的垃圾回收机制会将它回收,所以内存读写流不需要关流。

    ByteArrayInputStream

    构造方法

    ByteArrayInputStream(byte[] b);

    ByteArrayInputStream(byte[] b, int off, int len);

    常用方法

    从输入流中读入一个字节:int read();

    从输入流中将len个数据读入到数组:int read(byte[] b, int off, int len);

    ByteArrayIOutputStream

    构造方法

    ByteArrayIOutputStream();

    ByteArrayIOutputStream(int size);

    常用方法

    从指定字节中写出到输出流:void write(int b);

    从数组中将len个数据写出到输出流:void write(byte[] b, int off, int len);

    将缓冲区内容转换字节数组:byte toByteArray();

    将缓冲区内容转换为字符串:String toString();

    将缓冲区内容转换为指定编码格式的字符串:String toString(String charsetName);

    将缓冲区内容输出到指定的输出流:void writeTo(OutputStream out);

    解决乱码

    当用字节数组读取字符串时,受数组长度的影响,导致产生乱码。

    如果用String类型接收,则不能完全解析出正常的文字,需要使用字节数组输出流将字节数组的内容输出到缓冲区,待读取完成后再转换为String类型的字符串。

     1 public void test() {
     2     ByteArrayInputStream bais = null;
     3     ByteArrayOutputStream baos = null;
     4     try {
     5         bais = new ByteArrayInputStream("测试写入内容".getBytes());
     6         baos = new ByteArrayOutputStream();
     7         byte[] buffer = new byte[1];
     8         int len = -1;
     9         String txt = "";
    10         while ((len = bais.read(buffer)) != -1) {
    11             baos.write(buffer, 0, len);
    12             txt += new String(buffer, 0, len);
    13         }
    14         System.out.println("正常:" + baos.toString());
    15         System.out.println("乱码:" + txt);
    16     } catch (IOException e) {
    17         e.printStackTrace();
    18     }
    19 }

    标准流

    System.in

    可以获取键盘输入的值,属于字节流。

    获取方式

    static InputStream in;

    System.out

    可以将文本从控制台输出,属于字节流。

    PrintStream是FileOutputStream下的子类,而FileOutputStream是OutputStream下的子类。

    获取方式

    static PrintStream out;

    获取输入内容

    获取输入内容并显示在控制台

     1 public void test() {
     2     BufferedReader br = null;
     3     try {
     4         br = new BufferedReader(new InputStreamReader(System.in));
     5         System.out.println("请输入字符串:");
     6         System.out.println("输入的字符串为:" + br.readLine());
     7     } catch (IOException e) {
     8         e.printStackTrace();
     9     } finally {
    10         if (br != null) {
    11             try {
    12                 br.close();
    13             } catch (IOException e) {
    14                 e.printStackTrace();
    15             }
    16         }
    17     }
    18 }

    将内容保存在文件

    1 public void test() {
    2     try {
    3         System.out.println("这是输出到控制台的文字。");
    4         System.setOut(new PrintStream("D:" + File.separator + "input.txt"));
    5         System.out.println("这是输出到文件里的文字。");
    6     } catch (IOException e) {
    7         e.printStackTrace();
    8     }
    9 }

    从文件中读取内容

     1 public void test() {
     2     try {
     3         System.setIn(new FileInputStream("D:" + File.separator + "output.txt"));
     4         byte[] buffer = new byte[1024];
     5         int len = 0;
     6         String str = "";
     7         while ((len = System.in.read(buffer)) != -1) {
     8             str += new String(buffer, 0, len);
     9         }
    10         System.out.println(str);
    11     } catch (IOException e) {
    12         e.printStackTrace();
    13     }
    14 }

    对象流

    对象流主要有:ObjectInputStream、ObjectOutputStream。

    这两个类型都是字节流,可以处理所有文件,可以将内存中的对象保存到本地,也可以将本地的对象还原到内存中。

    序列化

    概念

    对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流,当其它程序获取了这种二进制流,就可以恢复成原来的Java对象。

    如果想将一个对象进行网络传输,要求是该对象必须是可序列化的,该类必须实现Serializable接口或者Externalizable接口。

    不能序列化static和transient修饰的属性。

    好处

    序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据,使其在保存和传输时可被还原。

    序列化是远程方法调用(Remote Method Invoke)过程的参数和返回值都必须实现的机制,而RMI是JavaEE的基础,因此序列化机制是JavaEE平台的基础。

    实现

    序列化:用ObjectOutputStream类保存基本类型数据或对象的机制,因为是输出到文件里,所以是输出流。

    反序列化:用ObjectInputStream类读取基本类型数据或对象的机制,因为将数据输入到内存里,所以是输入流。

    手动序列化

    进行序列化、反序列化时,虚拟机会首先试图调用对象里的writeObject和readObject方法,进行用户自定义的序列化和反序列化。

    如果没有这样的方法,那么默认调用的是ObjectOutputStream的defaultWriteObject以及ObjectInputStream的defaultReadObject方法。

    serialVersionUID

    Java的序列化机制是通过判断类的serialVersionUID来验证版本一致性的。

    在进行反序列化时,JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较,如果相同就认为是一致的,可以进行反序列化,否则就会出现序列化版本不一致的异常,即是InvalidCastException。

    serialVersionUID有两种生成方式:默认的1L,生成一个64位的Hash字段。

    ObjectInputStream

    构造方法

    ObjectInputStream(InputStream in);

    常用方法

    从输入流中读入一个字节:int read();

    从输入流中读入到数组:int read(byte[] buf);

    从输入流中将len个数据读入到数组:int read(byte[] buf, int off, int len);

    使用UTF-8编码读取字符串:String readUTF();

    读取要保存的变量:Object readObject();

    默认的读取变量的方法:void defaultReadObject();

    关闭输入流并释放系统资源:void close();

    反序列化实例

     1 public void deserialize() {
     2     try {
     3         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:" + File.separator + "object.obj"));
     4         System.out.println(ois.readInt());
     5         System.out.println(ois.readObject());
     6         System.out.println((Box) ois.readObject());
     7         ois.close();
     8     } catch (IOException e) {
     9         e.printStackTrace();
    10     }
    11 }

    ObjectOutputStream

    构造方法

    DataOutputStream(OutputStream out);

    常用方法

    从指定字节中写出到输出流:void write(int b);

    从数组中写出到输出流:void write(byte[] b);

    从数组中将len个数据写出到输出流:void write(byte[] b, int off, int len);

    使用UTF-8编码写入字符串:void writeUTF(String str);

    写入要保存的变量:void writeObject(Object obj);

    默认的写入变量的方法:void defaultWriteObject();

    刷新该流的缓冲:void flush();

    关闭输出流并释放系统资源:void close();

    序列化实例

     1 public void serialize() {
     2     try {
     3         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:" + File.separator + "object.obj"));
     4         oos.writeInt(100);
     5         oos.writeObject("String");
     6         oos.writeObject(new Box("box", 6, 8));
     7         oos.close();
     8     } catch (IOException e) {
     9         e.printStackTrace();
    10     }
    11 }

    随机存取文件流

    字节流,可以处理所有文件。

    既可以充当输入流,又可以充当输出流。

    若此将要输出文件不存在则尝试自动创建,并将内容输出到此文件中。若此将要输出的文件存在,则将对文件内容进行覆盖,默认从开头进行覆盖。

    RandomAccessFile

    构造方法

    RandomAccessFile(File file, String mode);

    RandomAccessFile(String name, String mode);

    mode指定文件的访问模式:

    r:以只读方式打开。

    rw:打开以便读取和写入。

    rws:还要求对文件的内容或元数据的更新都同步到底层存储设备。

    rwd:还要求对文件内容的更新都同步到底层存储设备。

    常用方法

    从指定字节中写出到输出流:void write(byte[] b);

    从数组中写出到输出流:void write(int b);

    从数组中将len个数据写出到输出流:void write(byte[] b, int off, int len);

    从输入流中读入一个字节:int read();

    从输入流中读入到数组:int read(byte[] b);

    从输入流中将len个数据读入到数组:int read(byte[] b, int off, int len);

    获取文件记录指针的当前位置:long getFilePointer();

    将文件记录指针定位到pos位置:void seek(long pos);

    关闭流并释放系统资源:void close();

    复制文件

     1 public void test() {
     2     RandomAccessFile r = null;
     3     RandomAccessFile w = null;
     4     try {
     5         r = new RandomAccessFile(new File("D:" + File.separator + "read.txt"), "r");
     6         w = new RandomAccessFile(new File("D:" + File.separator + "write.txt"), "rw");
     7         byte[] buffer = new byte[1024];
     8         int len = 0;
     9         while ((len = r.read(buffer)) != -1) {
    10             w.write(buffer, 0, len);
    11         }
    12     } catch (IOException e) {
    13         e.printStackTrace();
    14     } finally {
    15         if (r != null) {
    16             try {
    17                 r.close();
    18             } catch (IOException e) {
    19                 e.printStackTrace();
    20             }
    21         }
    22         if (w != null) {
    23             try {
    24                 w.close();
    25             } catch (IOException e) {
    26                 e.printStackTrace();
    27             }
    28         }
    29     }
    30 }

    插入内容

     1 public void test() {
     2     RandomAccessFile raf = null;
     3     try {
     4         raf = new RandomAccessFile("D:" + File.separator + "read.txt", "rw");
     5         raf.seek(3);
     6         byte[] buffer = new byte[1024];
     7         int len = 0;
     8         String str = "";
     9         while ((len = raf.read(buffer)) != -1) {
    10             str += new String(buffer, 0, len);
    11         }
    12         raf.seek(3);
    13         raf.write("read".getBytes());
    14         raf.write(str.getBytes());
    15     } catch (IOException e) {
    16         e.printStackTrace();
    17     } finally {
    18         try {
    19             raf.close();
    20         } catch (IOException e) {
    21             e.printStackTrace();
    22         }
    23     }
    24 }
  • 相关阅读:
    201671010105 201620172《Java程序设计》第四章学习心得
    201671010105 201620172《Java程序设计》第一、第二章学习心得
    201671010105 201620172《Java程序设计》第三章学习心得
    201671010105 201620172《Java程序设计》第四周学习心得
    计算三个数字的大小,按从小到大顺序输出。
    js实现网页的两个input标签内的数值加减
    传入一个4位数的整数,进行简单的加密,并1和4,2和3交换输出
    一些简单的循环案例
    计算任意两个个位整数之间所能组成的奇数个数
    js判断输入的年份是否为闰年
  • 原文地址:https://www.cnblogs.com/shamao/p/10523350.html
Copyright © 2020-2023  润新知