IO流详解

2023-05-16

文章目录

File类
- 1.File类的使用
- 2.如何创建File类的实例
- 3.常用方法
IO流
- 1.概述
- 2.节点流-字符流
- - FileReader读入数据的操作
  - FileWriter写出数据的操作
  - 使用FileReader和FileWriter实现文本文件的复制
- 3.节点流-字节流
- - FileInputStream读入数据操作
  - FileInputStream和FileOutputStream读写非文本文件
  - 写一个方法，用来指定路径下的文件复制
  - 记录字节流读写所需时间
- 4.处理流之一：缓冲流
- - 缓冲流（字节型）实现非文本文件的复制
  - 缓冲流（字符型）实现文本文件的复制
  - 缓冲流与节点流读写速度对比
  - 使用BufferedReader和BufferedWriter实现文本文件的复制
- 5.处理流之二：转换流
- 6.其他的流
- - 1.标准的输入、输出流
  - 2.打印流：PrintStream 和PrintWriter
  - 3. 数据流：DataInputStream 和 DataOutputStream
- 7.对象流
- - 面试题：如何理解对象序列化机制？
  - 序列化
  - 反序列化
  - 自定义类实现序列化与反序列化操作
  - serialVersionUID的理解

文章	链接
Java语法	https://blog.csdn.net/weixin_45606067/article/details/107049186
一维数组与二维数组、内存解析	https://blog.csdn.net/weixin_45606067/article/details/107049178
面向对象（1/3）类和对象	https://blog.csdn.net/weixin_45606067/article/details/108234276
面向对象（2/3）封装性、继承性、多态性	https://blog.csdn.net/weixin_45606067/article/details/108234328
面向对象（3/3）抽象类、接口、内部类、代码块	https://blog.csdn.net/weixin_45606067/article/details/108258152
异常处理	待更新
多线程（1/2）	https://blog.csdn.net/weixin_45606067/article/details/107067785
多线程（2/2）	https://blog.csdn.net/weixin_45606067/article/details/107067857
常用类	https://blog.csdn.net/weixin_45606067/article/details/108283203
枚举与注解	待更新
集合（1/5）Collection、Iterator、增强for	https://blog.csdn.net/weixin_45606067/article/details/107046876
集合（2/5）List、ArrayList、LinkedList、Vector的底层源码	https://blog.csdn.net/weixin_45606067/article/details/107069742
集合（3/5）set、HashSet、LinkedHashSet、TreeSet的底层源码
集合（4/5）Map、HashMap底层原理分析	https://blog.csdn.net/weixin_45606067/article/details/107042949
集合（5/5）LinkHashMap、TreeMap、Properties、Collections工具类	https://blog.csdn.net/weixin_45606067/article/details/107069691
泛型与File	https://blog.csdn.net/weixin_45606067/article/details/107124099
IO流与网络编程	https://blog.csdn.net/weixin_45606067/article/details/107143670
反射机制	待更新
Java8新特性	https://blog.csdn.net/weixin_45606067/article/details/107280823
Java9/10/11新特性	待更新

File类

1.File类的使用

File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹)
File类声明在java.io包下。
File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，
并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。
后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的"终点"。

2.如何创建File类的实例

1.如何创建File类的实例

File(String filePath)
File(String parentPath,String childPath)
File(File parentFile,String childPath)

2.相对路径：相较于某个路径下，指明的路径。
绝对路径：包含盘符在内的文件或文件目录的路径

3.路径分隔符

windows:\
unix:/

@Test
    public void test1(){
        //构造器1
        File file1 = new File("hello.txt");//相对于当前module
        File file2 =  new File("D:\\javapratice\\IdeaProjects\\JavaSenior\\day04\\he.txt");

        System.out.println(file1);
        System.out.println(file2);

        //构造器2：
        File file3 = new File("D:\\javapratice\\IdeaProjects","JavaSenior");
        System.out.println(file3);

        //构造器3：
        File file4 = new File(file3,"hi.txt");
        System.out.println(file4);
    }

3.常用方法

public String getAbsolutePath()：获取绝对路径
public String getPath() ：获取路径
public String getName() ：获取名称
public String getParent()：获取上层文件目录路径。若无，返回null
public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
public long lastModified() ：获取最后一次的修改时间，毫秒值

@Test
    public void test2(){
        File file1 = new File("hello.txt");
        File file2 = new File("d:\\io\\hi.txt");

	 	System.out.println(file1.getAbsolutePath());
     	 //D:\javapratice\IdeaProjects\JavaSenior\day04\hello.txt
        System.out.println(file1.getPath());//hello.txt
        System.out.println(file1.getName());//hello.txt
        System.out.println(file1.getParent());//null
        System.out.println(file1.length());//0
        System.out.println(new Date(file1.lastModified()));//Thu Jan 01 08:00:00 CST 1970

        System.out.println();

        System.out.println(file2.getAbsolutePath());//d:\io\hi.txt
        System.out.println(file2.getPath());//d:\io\hi.txt
        System.out.println(file2.getName());//hi.txt
        System.out.println(file2.getParent());//d:\io
        System.out.println(file2.length());//0
        System.out.println(file2.lastModified());//0
    }

如下的两个方法适用于文件目录：

public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组

@Test
public void test3(){
    File file = new File("D:\\workspace_idea1\\JavaSenior");

    String[] list = file.list();
    for(String s : list){
        System.out.println(s);
    }

     System.out.println();

    File[] files = file.listFiles();
    for(File f : files){
        System.out.println(f);
    }
}

public boolean renameTo(File dest):把文件重命名为指定的文件路径

/*
     比如：file1.renameTo(file2)为例：
        要想保证返回true,需要file1在硬盘中是存在的，且file2不能在硬盘中存在。
*/
@Test
public void test4(){
    File file1 = new File("hello.txt");
    File file2 = new File("D:\\io\\hi.txt");

    boolean renameTo = file2.renameTo(file1);
    System.out.println(renameTo);
}

public boolean isDirectory()：判断是否是文件目录
public boolean isFile() ：判断是否是文件
public boolean exists() ：判断是否存在
public boolean canRead() ：判断是否可读
public boolean canWrite() ：判断是否可写
public boolean isHidden() ：判断是否隐藏

@Test
public void test5(){
     File file1 = new File("hello.txt");
     file1 = new File("hello1.txt");

     System.out.println(file1.isDirectory());
     System.out.println(file1.isFile());
     System.out.println(file1.exists());
     System.out.println(file1.canRead());
     System.out.println(file1.canWrite());
     System.out.println(file1.isHidden());

     System.out.println();

     File file2 = new File("d:\\io");
     file2 = new File("d:\\io1");
     System.out.println(file2.isDirectory());
     System.out.println(file2.isFile());
     System.out.println(file2.exists());
     System.out.println(file2.canRead());
     System.out.println(file2.canWrite());
     System.out.println(file2.isHidden());
 }

创建硬盘中对应的文件或文件目录

public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
public boolean mkdirs() ：创建文件目录。如果此文件目录存在，就不创建了。如果上层文件目录不存在，一并创建

删除磁盘中的文件或文件目录

public boolean delete()：删除文件或者文件夹
删除注意事项：Java中的删除不走回收站。

@Test
    public void test6() throws IOException {
        File file1 = new File("hi.txt");
        if(!file1.exists()){
            //文件的创建
            file1.createNewFile();
            System.out.println("创建成功");
        }else{//文件存在
            file1.delete();
            System.out.println("删除成功");
        }
    }
    @Test
    public void test7(){
        //文件目录的创建
        File file1 = new File("d:\\io\\io1\\io3");

        boolean mkdir = file1.mkdir();
        if(mkdir){
            System.out.println("创建成功1");
        }

        File file2 = new File("d:\\io\\io1\\io4");

        boolean mkdir1 = file2.mkdirs();
        if(mkdir1){
            System.out.println("创建成功2");
        }
        //要想删除成功，io4文件目录下不能有子目录或文件
        File file3 = new File("D:\\io\\io1\\io4");
        file3 = new File("D:\\io\\io1");
        System.out.println(file3.delete());
    }

注意：file.delete()删除目录时，要想删除成功，该目录下不能有文件或目录。

IO流

1.概述

IO流原理及流的分类
input/output的缩写，处理设备之间的数据传输。
input：读取外部数据到程序中。
output：将程序中的数据输出到磁盘等存储设备中。
Java程序中，对于数据的输入/输出操作以“流（stream）”的方式进行。

按照操作数据单位，分为字节流（8bit）和字符流（6bit）适合于文本。
输入流：inputStream，reader
输出流：outputStream，Writer

按照流的角色：作用在文件上的：节点流，作用在已经有的流上的：处理流。
按照数据流向：输入流，输出流。

IO流的体系结构
在这里插入图片描述
IO流原理及流的分类

2.节点流-字符流

FileReader读入数据的操作

说明：
①read()地理解：返回读入的一个字符，如果达到文件末尾，返回-1
②异常的处理：为了保证流资源一定可以执行关闭操作，需要使用try-catch-finally处理。
③读入的文件一定要存在，否则就会报FileNotFoundException。

	/*
    将day09下的hello.txt文件内容读入程序中，并输出到控制台
     */
    @Test
    public void testFileReader(){
        FileReader fr = null;
        try {
            //1.实例化File类的对象，指明要操作的文件
            File file = new File("hello.txt");//相较于当前Module
            //2.提供具体的流
            fr = new FileReader(file);

            //3.数据的读入
            //read():返回读入的一个字符。如果达到文件末尾，返回-1
            //方式一：
//        int data = fr.read();
//        while(data != -1){
//            System.out.print((char)data);
//            data = fr.read();
//        }

            //方式二：语法上针对于方式一的修改
            int data;
            while((data = fr.read()) != -1){
                System.out.print((char)data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流的关闭操作
//            try {
//                if(fr != null)
//                    fr.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
            //或
            if(fr != null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

对read()操作升级：使用read的重载方法

	@Test
    public void testFileReader1()  {
        FileReader fr = null;
        try {
            //1.File类的实例化
            File file = new File("hello.txt");

            //2.FileReader流的实例化
            fr = new FileReader(file);

            //3.读入的操作
            //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
            char[] cbuf = new char[5];
            int len;
            while((len = fr.read(cbuf)) != -1){
                //方式一：
                //错误的写法
//                for(int i = 0;i < cbuf.length;i++){
//                    System.out.print(cbuf[i]);
//                }
                //正确的写法
//                for(int i = 0;i < len;i++){
//                    System.out.print(cbuf[i]);
//                }
                //方式二：
                //错误的写法,对应着方式一的错误的写法
//                String str = new String(cbuf);
//                System.out.print(str);
                //正确的写法
                String str = new String(cbuf,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fr != null){
                //4.资源的关闭
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

FileWriter写出数据的操作

从内存中写出数据到硬盘的文件里。

说明：

输出操作，对应的File可以不存在的。并不会报异常。
File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
File对应的硬盘中的文件如果存在：
如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖。
如果流使用的构造器是：FileWriter(file,true):不会对原有文件覆盖，而是在原有文件基础上追加内容。

@Test
public void testFileWriter() {
  FileWriter fw = null;
  try {
    //1.提供File类的对象，指明写出到的文件
    File file = new File("hello1.txt");

    //2.提供FileWriter的对象，用于数据的写出
    fw = new FileWriter(file,false);

    //3.写出的操作
    fw.write("I have a dream!\n");
    fw.write("you need to have a dream!");
  } catch (IOException e) {
    e.printStackTrace();
  } finally {
    //4.流资源的关闭
    if(fw != null){
      try {
        fw.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}

使用FileReader和FileWriter实现文本文件的复制

注意：不能使用字符流来处理图片等字节数据

@Test
    public void testFileReaderFileWriter() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //1.创建File类的对象，指明读入和写出的文件
            File srcFile = new File("hello.txt");
            File destFile = new File("hello2.txt");

            //不能使用字符流来处理图片等字节数据
//            File srcFile = new File("爱情与友情.jpg");
//            File destFile = new File("爱情与友情1.jpg");

            //2.创建输入流和输出流的对象
            fr = new FileReader(srcFile);
            fw = new FileWriter(destFile);

            //3.数据的读入和写出操作
            char[] cbuf = new char[5];
            int len;//记录每次读入到cbuf数组中的字符的个数
            while((len = fr.read(cbuf)) != -1){
                //每次写出len个字符
                fw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            //方式一：
//            try {
//                if(fw != null)
//                    fw.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }finally{
//                try {
//                    if(fr != null)
//                        fr.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
            //方式二：
            try {
                if(fw != null)
                    fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

            try {
                if(fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

3.节点流-字节流

FileInputStream读入数据操作

使用FileInputStream不能读取文本文件的测试:

结论：

对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理。
对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,…)，使用字节流处理。

//使用字节流FileInputStream处理文本文件，可能出现乱码。
@Test
public void testFileInputStream() {
  FileInputStream fis = null;
  try {
    //1. 造文件
    File file = new File("hello.txt");

    //2.造流
    fis = new FileInputStream(file);

    //3.读数据
    byte[] buffer = new byte[5];
    int len;//记录每次读取的字节的个数
    while((len = fis.read(buffer)) != -1){
      String str = new String(buffer,0,len);
      System.out.print(str);
    }
  } catch (IOException e) {
    e.printStackTrace();
  } finally {
    if(fis != null){
      //4.关闭资源
      try {
        fis.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}

FileInputStream和FileOutputStream读写非文本文件

/*
    实现对图片的复制操作
*/
@Test
public void testFileInputOutputStream()  {
  FileInputStream fis = null;
  FileOutputStream fos = null;
  try {
    File srcFile = new File("爱情与友情.jpg");
    File destFile = new File("爱情与友情2.jpg");

    fis = new FileInputStream(srcFile);
    fos = new FileOutputStream(destFile);

    //复制的过程
    byte[] buffer = new byte[5];
    int len;
    while((len = fis.read(buffer)) != -1){
      fos.write(buffer,0,len);
    }
  } catch (IOException e) {
    e.printStackTrace();
  } finally {
    if(fos != null){
      try {
        fos.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    if(fis != null){
      try {
        fis.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}

写一个方法，用来指定路径下的文件复制

//指定路径下文件的复制
public void copyFile(String srcPath,String destPath){
  FileInputStream fis = null;
  FileOutputStream fos = null;
  try {
    File srcFile = new File(srcPath);
    File destFile = new File(destPath);

    fis = new FileInputStream(srcFile);
    fos = new FileOutputStream(destFile);

    //复制的过程
    byte[] buffer = new byte[1024];
    int len;
    while((len = fis.read(buffer)) != -1){
      fos.write(buffer,0,len);
    }
  } catch (IOException e) {
    e.printStackTrace();
  } finally {
    if(fos != null){
      //
      try {
        fos.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    if(fis != null){
      try {
        fis.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}

记录字节流读写所需时间

@Test
public void testCopyFile(){
  long start = System.currentTimeMillis();

  String srcPath = "C:\\Users\\Administrator\\Desktop\\01-视频.avi";
  String destPath = "C:\\Users\\Administrator\\Desktop\\02-视频.avi";

  //        String srcPath = "hello.txt";
  //        String destPath = "hello3.txt";

  copyFile(srcPath,destPath);

  long end = System.currentTimeMillis();

  System.out.println("复制操作花费的时间为：" + (end - start));//618
}

4.处理流之一：缓冲流

1.缓冲流：

BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter

2.作用：提供流的读取、写入的速度
提高读写速度的原因：内部提供了一个缓冲区：1024*8=8192

3.处理流，就是“套接”在已有的流的基础上。

缓冲流（字节型）实现非文本文件的复制

/*
    缓冲流（字节型）实现非文本文件的复制
     */
    @Test
    public void BufferedStreamTest() throws FileNotFoundException {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        try {
            //1.造文件
            File srcFile = new File("爱情与友情.jpg");
            File destFile = new File("爱情与友情3.jpg");
            //2.造流
            //2.1 造节点流
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2 造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //3.复制的细节：读取、写入
            byte[] buffer = new byte[10];
            int len;
            while((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);

//                bos.flush();//刷新缓冲区
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
//        fos.close();
//        fis.close();
        }
    }

缓冲流（字符型）实现文本文件的复制

//实现文件复制的方法
    public void copyFileWithBuffered(String srcPath,String destPath){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        try {
            //1.造文件
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);
            //2.造流
            //2.1 造节点流
            FileInputStream fis = new FileInputStream((srcFile));
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2 造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //3.复制的细节：读取、写入
            byte[] buffer = new byte[1024];
            int len;
            while((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
//        fos.close();
//        fis.close();
        }
    }

缓冲流与节点流读写速度对比

@Test
public void testCopyFileWithBuffered(){
    long start = System.currentTimeMillis();

    String srcPath = "C:\\Users\\Administrator\\Desktop\\01-视频.avi";
    String destPath = "C:\\Users\\Administrator\\Desktop\\03-视频.avi";

    copyFileWithBuffered(srcPath,destPath);

    long end = System.currentTimeMillis();

    System.out.println("复制操作花费的时间为：" + (end - start));//618 - 176
}

使用BufferedReader和BufferedWriter实现文本文件的复制

@Test
public void testBufferedReaderBufferedWriter(){
  BufferedReader br = null;
  BufferedWriter bw = null;
  try {
    //创建文件和相应的流
    br = new BufferedReader(new FileReader(new File("dbcp.txt")));
    bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));

    //读写操作
    //方式一：使用char[]数组
    //            char[] cbuf = new char[1024];
    //            int len;
    //            while((len = br.read(cbuf)) != -1){
    //                bw.write(cbuf,0,len);
    //    //            bw.flush();
    //            }

    //方式二：使用String
    String data;
    while((data = br.readLine()) != null){
      //方法一：
      //                bw.write(data + "\n");//data中不包含换行符
      //方法二：
      bw.write(data);//data中不包含换行符
      bw.newLine();//提供换行的操作
    }
  } catch (IOException e) {
    e.printStackTrace();
  } finally {
    //关闭资源
    if(bw != null){
      try {
        bw.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    if(br != null){
      try {
        br.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}

5.处理流之二：转换流

处理流之二：转换流的使用
1.转换流：属于字符流

InputStreamReader：将一个字节的输入流转换为字符的输入流
OutputStreamWriter：将一个字符的输出流转换为字节的输出流

2.作用：提供字节流与字符流之间的转换

3.解码：字节、字节数组 —>字符数组、字符串
编码：字符数组、字符串 —> 字节、字节数组

4.字符集

ASCII：美国标准信息交换码。
用一个字节的7位可以表示。
ISO8859-1：拉丁码表。欧洲码表
用一个字节的8位表示。
GB2312：中国的中文编码表。最多两个字节编码所有字符
GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。

public class InputStreamReaderTest {

    /*
    InputStreamReader的使用，实现字节的输入流到字符的输入流的转换
     */
    @Test
    public void test1(){

        InputStreamReader isr = null;
        try {
            FileInputStream fis = new FileInputStream("dbcp.txt");
//        InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集
            //参数2指明了字符集，具体使用哪个字符集，取决于文件dbcp.txt保存时使用的字符集
            isr = new InputStreamReader(fis,"UTF-8");//使用系统默认的字符集

            char[] cbuf = new char[20];
            int len;
            while((len = isr.read(cbuf)) != -1){
                String str = new String(cbuf,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(isr != null){
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /*
    综合使用InputStreamReader和OutputStreamWriter
     */
    @Test
    public void test2() {
        InputStreamReader isr = null;
        OutputStreamWriter osw = null;
        try {
            //1.造文件、造流
            File file1 = new File("dbcp.txt");
            File file2 = new File("dbcp_gbk.txt");

            FileInputStream fis = new FileInputStream(file1);
            FileOutputStream fos = new FileOutputStream(file2);

            isr = new InputStreamReader(fis,"utf-8");
            osw = new OutputStreamWriter(fos,"gbk");

            //2.读写过程
            char[] cbuf = new char[20];
            int len;
            while((len = isr.read(cbuf)) != -1){
                osw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //3.关闭资源
            if (isr != null){
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (osw != null){
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

6.其他的流

其他流的使用

1.标准的输入、输出流
2.打印流
3.数据流

1.标准的输入、输出流

System.in:标准的输入流，默认从键盘输入
System.out:标准的输出流，默认从控制台输出

System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出的流。

/*
从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。

方法一：使用Scanner实现，调用next()返回一个字符串
方法二：使用System.in实现。System.in  --->  转换流 ---> BufferedReader的readLine()
*/
public static void main(String[] args) {
   BufferedReader br = null;
    try {
        InputStreamReader isr = new InputStreamReader(System.in);
        br = new BufferedReader(isr);

        while (true) {
            System.out.println("请输入字符串：");
            String data = br.readLine();
            if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)) {
                System.out.println("程序结束");
                break;
            }
            String upperCase = data.toUpperCase();
            System.out.println(upperCase);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (br != null) {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.打印流：PrintStream 和PrintWriter

提供了一系列重载的print() 和 println()

@Test
public void test2() {
    PrintStream ps = null;
    try {
        FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt"));
        // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
        ps = new PrintStream(fos, true);
        if (ps != null) {// 把标准输出流(控制台输出)改成文件
            System.setOut(ps);
        }

        for (int i = 0; i <= 255; i++) { // 输出ASCII字符
            System.out.print((char) i);
            if (i % 50 == 0) { // 每50个数据一行
                System.out.println(); // 换行
            }
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } finally {
        if (ps != null) {
            ps.close();
        }
    }
}

3. 数据流：DataInputStream 和 DataOutputStream

作用：用于读取或写出基本数据类型的变量或字符串

/*
	练习：将内存中的字符串、基本数据类型的变量写出到文件中。
*/
@Test
public void test3() {
    DataOutputStream dos = null;
    try {
        //1.
        dos = new DataOutputStream(new FileOutputStream("data.txt"));
        //2.
        dos.writeUTF("刘建辰");
        dos.flush();//刷新操作，将内存中的数据写入文件
        dos.writeInt(23);
        dos.flush();
        dos.writeBoolean(true);
        dos.flush();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (dos != null){
            //3.
            try {
                dos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
/*
将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。

注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！
 */
@Test
public void test4() throws IOException {
    DataInputStream dis = null;
    try {
        //1.
        dis = new DataInputStream(new FileInputStream("data.txt"));
        //2.
        String name = dis.readUTF();
        int age = dis.readInt();
        boolean isMale = dis.readBoolean();

        System.out.println("name = " + name);
        System.out.println("age = " + age);
        System.out.println("isMale = " + isMale);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (dis != null){
            //3.
            dis.close();
        }
    }
}

7.对象流

1.ObjectOutputStream和ObjectInputStream
2.作用：用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
要求对象所属的类是可序列化的—>实现了Seralizable接口

面试题：如何理解对象序列化机制？

把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久的保存在硬盘上，或者通过网络，将这种二进制流传输到另一个网络节点。当其他程序获取了这种二进制流，就可以恢复成原来的Java对象。

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

序列化

    /*
        序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
        使用ObjectOutputStream实现
    */
    @Test
    public void testObjectOutputStream(){
      ObjectOutputStream oos = null;
    
      try {
        //1.
        oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
        //2.
        oos.writeObject(new String("我爱北京天安门"));
        oos.flush();//刷新操作
    
        oos.writeObject(new Person("王铭",23));
        oos.flush();
    
        oos.writeObject(new Person("张学良",23,1001,new Account(5000)));
        oos.flush();
    
      } catch (IOException e) {
        e.printStackTrace();
      } finally {
        if(oos != null){
          //3.
          try {
            oos.close();
          } catch (IOException e) {
            e.printStackTrace();
          }
    
        }
      }
    
    }

反序列化

    /*
        反序列化：将磁盘文件中的对象还原为内存中的一个java对象
        使用ObjectInputStream来实现
    */
    @Test
    public void testObjectInputStream(){
      ObjectInputStream ois = null;
      try {
        ois = new ObjectInputStream(new FileInputStream("object.dat"));
    
        Object obj = ois.readObject();
        String str = (String) obj;
    
        Person p = (Person) ois.readObject();
        Person p1 = (Person) ois.readObject();
    
        System.out.println(str);
        System.out.println(p);
        System.out.println(p1);
    
      } catch (IOException e) {
        e.printStackTrace();
      } catch (ClassNotFoundException e) {
        e.printStackTrace();
      } finally {
        if(ois != null){
          try {
            ois.close();
          } catch (IOException e) {
            e.printStackTrace();
          }
        }
      }
    }

自定义类实现序列化与反序列化操作

Person需要满足如下的要求，方可序列化
1.需要实现java.io.Serializable接口
2.当前类提供一个全局常量：serialVersionUID
3.除了当前Person类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化的。（默认情况下，基本数据类型可序列化）
4.ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

    public class Person implements Serializable{
    
        public static final long serialVersionUID = 475463534532L;
    
        private String name;
        private int age;
        private int id;
        private Account acct;
    
        public Person(String name, int age, int id) {
            this.name = name;
            this.age = age;
            this.id = id;
        }
    
        public Person(String name, int age, int id, Account acct) {
            this.name = name;
            this.age = age;
            this.id = id;
            this.acct = acct;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", id=" + id +
                    ", acct=" + acct +
                    '}';
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public Person(String name, int age) {
    
            this.name = name;
            this.age = age;
        }
    
        public Person() {}
    }
    
    class Account implements Serializable{
        public static final long serialVersionUID = 4754534532L;
        private double balance;
    
        @Override
        public String toString() {
            return "Account{" +
                    "balance=" + balance +
                    '}';
        }
    
        public double getBalance() {
            return balance;
        }
    
        public void setBalance(double balance) {
            this.balance = balance;
        }
    
        public Account(double balance) {
    
            this.balance = balance;
        }
    }

    public static void main(String[] args) {
        //序列化
        ObjectOutputStream oos =null;
        ObjectInputStream ois=null;
        try {
            oos=new ObjectOutputStream(new FileOutputStream(new File("D://object.txt")));
            Person person = new Person("张贝贝", 25);
            oos.writeObject(person);
            //反序列化
            ois=new ObjectInputStream(new FileInputStream(new File("D:\\object.txt")));
            Object obj=ois.readObject();
            Person p1= (Person) obj;
            System.out.println(p1.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois!=null){
                    ois.close();
                }
                if (oos!=null){
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

serialVersionUID的理解

如果不手动写，Java会自动生成一个。
如果序列化以后修改了类，serialVersionUID也会被Java修改，反序列化会失败！

如果有收获！！！希望老铁们来个三连，点赞、收藏、转发
创作不易，别忘点个赞，可以让更多的人看到这篇文章，顺便鼓励我写出更好的博客

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

IO流详解的相关文章

Java小型计算器

通过对程序的编写 xff0c 可以不同位数实现对加减乘除的计算 xff0c 以及对错误答案给出提示以满足一些大人给小孩出题的困惑 xff0c 此程序可以自己出题 xff0c 自己检测答案随时随地想做就做需求 xff1a 1 实现计算器
杨辉三角 | 回形数 | 复制 | 赋值练习题

目录杨辉三角回形数格式方阵的实现使用简单数组拓展 xff1a 修改题目 xff0c 实现array2对array1数组的复制杨辉三角使用二维数组打印一个10行杨辉三角 span class token keyword public s
水仙花数 | 平闰年 | 斐波那契数列 | 反转单词

目录水仙花1 三位数的水仙花2 四位数的水仙花平闰年斐波那契数列反转句子中单词顺序水仙花 1 三位数的水仙花 span class token keyword for span span class token punctuation
图像去雾：AOD-Net

论文地址 xff1a https arxiv org pdf 1707 06543 pdf 相关代码 xff1a GitHub MayankSingal PyTorch Image Dehazing PyTorch implementati
打印三角形 | 所有素数

目录 3 100的所有素数找出来5 5正方形直角三角形反直角三角形正等腰三角形 xff08 金字塔 xff09 倒立等腰三角形 4 61 1 1 1 3 43 1 5 1 7 43 1 9 1 11 43 43 1 n 若n为99 3 10
冒泡排序 | 快速排序 | 线性查找 | 二分查找等

目录排序算法 xff1a 冒泡排序排序算法 xff1a 快速排序数组的复制反转查询 xff08 线性查找二分查找 xff09 排序算法 xff1a 冒泡排序 span class token keyword public span
多线程（1/2）

文章目录一多线程概述1 概念1 1 程序进程线程1 2 单核cpu和多核cpu1 3 并行和并发 2 优点3 何时需要二继承Thread类1 多线程创建的方式一 xff1a 继承于Thread类2 线程常用方法3 线程的优先级4
多线程（2/2）

文章目录一程序安全的单例模式之懒汉式1 通过同步代码块解决懒汉式单例设计模式的线程安全问题2 通过同步方法解决懒汉式单例设计模式的线程安全问题二死锁问题1 死锁的理解 2 说明三 Lock锁方式解决线程安全问题四线程的通信1 涉
集合框架（5）：LinkHashMap | TreeMap | Properties | Collections工具类

文章目录一 LinkedHashMap底层实现原理二 TreeMap1 自然排序2 定制排序三 Properties四 Collections 工具类1 工具类中常用的方法2 代码演示文章链接Java语法https blog csdn
集合框架（2）：List | ArrayList | LinkedList | Vector的底层源码

文章目录一 list比较ArrayList LinkedList Vector三者的异同 xff1f List接口常用方法List遍历及常用方法总结 ArrayList源码分析LinkedList源码分析Vector源码分析ArrayLi
集合框架（3）：set | HashSet | LinkedHashSet | TreeSet的底层源码

文章目录一 Set练习题 xff1a 在list内去除重复数据值二 HashSet三 LinkHashSet四 TreeSet1 自然排序2 定制排序文章链接Java语法https blog csdn net weixin 45606
单例设计模式

目录一设计模式1 理解2 常用设计模式 23种经典的设计模式二单例设计模式1 概念 xff1a 2 如何实现 xff1f 3 饿汉式和懒汉式的区别4 应用场景 xff1a 三模板方法的设计模式1 解决的问题2 举例3 应用场景一
PageHelper实现分页详细版、整合SSM应用

在项目开发中我们经常要实现分页技术 xff0c 传统的开发过于繁琐 xff0c 这里我们讲解MyBatis中引进的PageHelper实现分页简单易懂 xff0c 便于上手 xff01 xff01 xff01 参照官网完成以下分页技术的
最详细IDEA 的安装、配置与使用

目录 IDEA 的安装配置与使用一 IntelliJ IDEA 介绍1 IntelliJ IDEA 介绍2 官网 xff1a 3 IDEA 的下载地址 xff1a 官网 4 官网提供的详细使用文档 xff1a 二 windows 下载安装
对遗传算法(GA)的一些理解

目录 1 遗传算法的原理 2 遗传算法的主要流程 3 对遗传算法中的选择编码交叉及变异的理解 1 遗传算法的原理基因以染色体为载体在种群间得以传播 xff0c 而基因在相当程度上决定了个体的表现型性状 xff0c 这个传播过程常常伴
最详细IDEA 常用配置、布局说明

目录一创建 Java 工程 xff0c 分析页面布局1 设置显示常见的视图2 工程界面展示3 查看项目配置二常用配置以idea 2019为例 1 设置主题2 设置字体大小 xff08 1 xff09 非代码窗口设置UI样式和字体
Springboot整合阿里云短信服务

文章目录开通阿里云了解阿里云用户权限操作开通阿里云短信服务添加短信模板添加签名 Springboot整合短信到项目中1 创建一个SpringBoot的项目2 导入依赖3 配置文件4 主启动类5 工具类6 控制器7 业务层8 测试最好有S
使用JS实现表单验证

目录表单页面展示FormCheck jsp CSS样式Register css JavaScript代码FormCheck js 效果图展示平时我们在注册账号的时候经常看到有提示xxx不得法 xff0c 请重新填写字样 xff0c 本文
对Spring深入的理解 | 概念的总结

一 Spring的概述官网 xff1a https spring io projects spring framework overview 官方下载地址 xff1a https docs spring io spring docs 4
Spring AOP详解

1 简述 AOP 概念 AOP xff1a Aspect Oriented Program xff0c 面向方面切面的编程 xff1b Filter 过滤器也是一种 AOP AOP 是一种新的方法论 xff0c 是对传统 OOP Ob

随机推荐

Spring IOC详解

一 IOC的基本概念 1 简述 IOC 概念 IOC Invert Of Control xff0c 控制反转也成为 DI 依赖注入其思想是反转资源获取的方向传统的资源查找方式要求组件向容器发起请求查找资源作为回应容器适时的返回资
Spring 声明式事务

文章目录 1 回顾事务2 spring的事务管理3 Spring事务的种类4 基于XML的事务配置1 使用说明2 代码如下 5 基于注解的事务配置1 使用说明2 代码如下 6 基于XML和注解的事务配置代码如下 7 64 Transacti
Spring 依赖注入详解

一 IOC 依赖注入 1 什么是Spring的依赖注入依赖注入 xff0c 是IOC的一个方面 xff0c 是个通常的概念 xff0c 它有多种解释这概念是说你不用创建对象 xff0c 而只需要描述它如何被创建你不在代码里直接组装你的
JDBC（1） API详细说明

目录一 JDBC概述1 什么是 JDBC2 JDBC API3 JDBC 程序编写步骤二用使用 JDBC API1 引入 JDBC 驱动程序1 1 如何获取 JDBC 驱动程序1 2 在Java Project 项目应用中添加数据库驱
JDBC（2）工具类 | PreparedStatement详细说明

目录一 JDBC 工具类使用 JDBC API 操作数据库的基本步骤编写工具类 JDBCUtils 二 PreparedStatement1 PreparedStatement 概述2 Statement 的不足3 PreparedSta
python: image.paste函数的理解

目录 image paste函数举例说明 xff1a image paste函数 python中PIL库中的paste函数的作用为将一张图片覆盖到另一张图片的指定位置去函数的声明如下 xff1a def paste self im bo
JDBC（3）实现通用的增删改查方法

编写通用的增删改查方法不明白的可以看代码中注释 xff0c 写的很详细 1 通用的增删改 span class token comment 通用的更新数据库的方法 xff1a insert update delete 语句时 span s
JDBC（4）DBCP数据源 | C3P0 数据源

1 DBCP 数据源 DBCP 是 Apache 软件基金组织下的开源连接池实现 xff0c 该连接池依赖该组织下的另一个开源系统 xff1a Common pool 如需使用该连接池实现 xff0c 应在系统中增加如下两个 jar 文件
JDBC（5）DBUtils类详解

1 DbUtils 类 DbUtils xff1a 提供如关闭连接装载 JDBC 驱动程序等常规工作的工具类 xff0c 里面的所有方法都是静态的主要方法如下 xff1a public static void close throws
验证码实现 - html页面版

前言图片验证码是我们日常经常用到的 xff0c 本文将介绍如何实现以及其原理 xff0c 并没有过多注重css样式 xff0c 单纯实现验证码功能如果对滑块验证码感兴趣的可以看这篇文章 xff1a 滑块验证码实现及原理如果对验证码实现
验证码实现 - 工具类调用版

前言图片验证码是我们日常经常用到的 xff0c 本文将介绍如何实现以及其原理 xff0c 以注册页面为例实现功能如果对滑块验证码感兴趣的可以看这篇文章 xff1a 滑块验证码实现及原理如果对验证码实现感兴趣的可以看这篇文章 xff1a
滑块验证码实现

前言滑块验证码也是生活中常见的 xff0c 本文会介绍如何实现以及原理如果对验证码实现感兴趣的可以看这篇文章 xff1a 验证码实现 html页面版如果对验证码实现感兴趣的可以看这篇文章 xff1a 验证码实现工具类调用版代码实现
MySQL（1）的使用 | SQL

目录 MySQL 的使用1 启动和停止服务方式一 xff1a 图形化方式方式二 xff1a 命令行 2 客户端登录方式一 xff1a MySQL 自带客户端方式二 xff1a 命令行方式三 xff1a 可视化工具 SQL1 SQL 的语言规
MySQL（2）DDL详解

一 DDL 1 1 操作 Database 注意 xff1a database 不能改名一些可视化工具可以改名 xff0c 它是建新库 xff0c 把所有表复制到新库 xff0c 再删旧库完成的 1 创建数据库 create databa
MySQL（4）运算符 | 关联查询详解

一 MySQL 的运算符 xff08 1 xff09 算术运算符 xff1a 43 xff08 除也可以写成 div xff08 取模可以写成 mod xff09 xff08 2 xff09 比较运算符 xff1a 61 gt gt 61
MySQL（5）条件查询 | 单行函数 | 事务详解

一 select 的的 5 个子句 1 where 条件查询从原表中的记录中进行筛选 2 group by 分组查询很多情况下 xff0c 用户都需要进行一些汇总操作 xff0c 比如统计整个公司的人数或者统计每一个部门的人数等聚合
python：tqdm——进度条显示操作

在代码执行过程中 xff0c 如果想要看到代码的实时运行进度 xff0c 可以使用tqdm库来进行进度条可视化 tqdm的安装 xff1a pip install tqdm 举一个常用参数的使用例子 xff1a from tqdm impo
MySQL（3）DML详解

一 DML 数据操纵语言 xff08 DML xff09 DML 用于插入修改删除数据记录 xff0c 包括如下 SQL 语句 xff1a INSERT xff1a 添加数据到数据库中 UPDATE xff1a 修改数据库中的数据 DE
泛型的使用与通配符

文章目录泛型的使用1 jdk1 5新特性泛型2 为什么要使用泛型 xff1f 3 在集合中使用泛型自定义泛型结构 xff1a 泛型类 xff0c 泛型接口 xff1b 泛型方法泛型类被某个类继承自定义泛型的注意点泛型方法泛型在继承方面
IO流详解

文章目录 File类1 File类的使用2 如何创建File类的实例3 常用方法 IO流1 概述2 节点流字符流FileReader读入数据的操作FileWriter写出数据的操作使用FileReader和FileWriter实现文本文件