IO

所谓IO就是输出输出（input/output）。一般的理解都是相对于计算机而言的输入输出。

比如：

输出设备：显示器，耳机，音响，打印机.....

输入设备：键盘，鼠标，麦克风......

上面的所有的输入输出都是相对于计算机而言的。

我们这里说的输入输出是相对于内存而言的

• 数据读取到内存就是输入。

• 数据从内存写出就是输出。

输入输出的原理：

输出的数据流称之为输出流，输入的数据流称之为输入流。

 面试题：java的流是如何分类的？
 按照方向分为：输入流和输出流。
 按照处理方式：分为字节流和字符流。

File类

在java.io包下有一个File。 这个类的所有对象都表示一个文件。（一个File类的对象就是一个文件或者文件夹的抽象表示）

内部的常量

• static String pathSeparator 与系统相关的路径分隔符字符，为方便起见，表示为字符串。

• static char pathSeparatorChar 与系统相关的路径分隔符。

• static String separator 与系统相关的默认名称 - 分隔符字符，以方便的方式表示为字符串。

• static char separatorChar 与系统相关的默认名称分隔符。

前面两个常量是路径相关的分隔符。后面两个是名称分隔符。

 以前在linux中分隔符是 \"/\" 在windows中是 \"\\\"

构造方法

• File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例。

• File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。

• File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 File实例。

• File(URI uri) 通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。

 相对路径和绝对路径。
 所谓相对路径，就是相对于当前的文件而言，目标的位置。
 所谓绝对路径，就是从盘符开始的路径。
 一般建议使用相对路径。

 public class HelloFile{
     public static void main(String [] args){
         // 我们这里先使用绝对路径
         File file = new File(\"E:\\\\202201\\\\第二阶段\\\\01.java高级\\\\0317\\\\temp\\\\hello.txt\");
         // 当然我们也可以使用相对路径表示
         File file1 = new File(\"s.txt\");
         file1.createNewFile();
 ​
         // 使用父子文件创建(父路径字符串，子路径字符串)
         File file2 = new File(\"E:\\\\202201\\\\第二阶段\\\\01.java高级\\\\0317\\\\temp\",\"hello.txt\");
         File file3_1 = new File(\"E:\\\\202201\\\\第二阶段\\\\01.java高级\\\\0317\\\\temp\");
         File file3 = new File(file3_1,\"hello.txt\");
     }
 }

File类的一些API：

获取信息的---

• exists() 测试此抽象路径名表示的文件或目录是否存在。

• getName() 返回由此抽象路径名表示的文件或目录的名称。

• getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。

• getParent() 返回此抽象路径名的父 null的路径名字符串，如果此路径名未命名为父目录，则返回null。

• getParentFile() 返回此抽象路径名的父，或抽象路径名 null如果此路径名没有指定父目录。

• isDirectory() 测试此抽象路径名表示的文件是否为目录。

• isFile() 测试此抽象路径名表示的文件是否为普通文件。

• lastModified() 返回此抽象路径名表示的文件上次修改的时间。

• length() 返回由此抽象路径名表示的文件的长度。

• list() 返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录。

• listFiles() 返回一个抽象路径名数组，表示由该抽象路径名表示的目录中的文件。

案例：

 public class FileTest1 {
     public static void main(String[] args) {
         // 文件
         String path = \"E:\\\\202201\\\\第二阶段\\\\01.java高级\\\\0317\\\\temp\\\\hello.txt\";
         File file = new File(path);
         // 文件夹
         String path1 = \"E:\\\\202201\\\\作业\\\\20220315\";
         File file1 = new File(path1);
         System.out.println(\"------------------\");
         System.out.println(\"文件名：\"+file.getName());
         System.out.println(\"文件夹名：\"+ file1.getName());
         System.out.println(\"文件的绝对路径\"+file.getAbsolutePath());
         System.out.println(\"文件夹的绝对路径:\"+file1.getAbsolutePath());
         System.out.println(\"文件是否存在：\"+file.exists());
         System.out.println(\"文件夹是否存在:\"+file1.exists());
         System.out.println(\"文件的父文件夹路径：\"+file.getParent());
         System.out.println(\"文件是否是文件：\"+file.isFile());
         System.out.println(\"文件是否是文件夹：\"+file.isDirectory());
         System.out.println(\"文件的最后修改时间:\"+new Date(file.lastModified()));
         System.out.println(\"文件夹的最后修改时间:\"+new Date(file1.lastModified()));
         System.out.println(\"文件长度：\"+file.length()+\" 字节\");
         System.out.println(\"-- 文件夹的length是无效 --\");
         System.out.println(\"文件夹长度:\"+file1.length()+\" 字节\");
         // list是获取当前文件夹下的所有文件和文件夹的名字的字符串数组
         String[] names = file1.list();
         System.out.println(Arrays.toString(names));
         // listFile获取File类型的数组
         File[] files = file1.listFiles();
         for (File f: files){
             System.out.println(f.getAbsolutePath()+\":\"+f.length());
         }
     }
 }

我们查看文件的大小，从现在开始都是看字节：

 1B byte = 8bit
 1K = 1024B
 1M = 1024K
 1G = 1024M
 1T = 1024G
 1P = 1024T

创建删除判断的一些API----

• canExecute() 测试应用程序是否可以执行此抽象路径名表示的文件。

• canRead() 测试应用程序是否可以读取由此抽象路径名表示的文件。

• canWrite() 测试应用程序是否可以修改由此抽象路径名表示的文件。

• delete() 删除由此抽象路径名表示的文件或目录。

• boolean mkdir() 创建由此抽象路径名命名的目录。

• boolean mkdirs() 创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录。

• createNewFile() 当且仅当具有该名称的文件尚不存在时，原子地创建一个由该抽象路径名命名的新的空文件。

异常问题：

案例：

 public class FileTest2 {
     public static void main(String[] args) throws IOException {
         File file = new File(\"file-list\");
         // 创建这个文件夹
         // 文件不存在或者文件不是文件夹
         if(!file.exists() || !file.isDirectory()){
             // 创建它
             file.mkdir();
         }
         // 创建一组文件夹
         File file1 = new File(\"E:\\\\202201\\\\第二阶段\\\\01.java高级\\\\0317\\\\temp\\\\stu\\\\info\\\\names\");
         if(!file1.exists() || !file1.isDirectory()){
             // 创建它 前往不要忘记s
             boolean mkdirs = file1.mkdirs();
             System.out.println(mkdirs);
         }
         // 创建文件
         File file2 = new File(\"file-list\\\\names.txt\");
         if(!file2.exists() || !file2.isFile()){
             file2.createNewFile();// 这里会有异常，直接抛出
         }
         // 删除文件
         File file3 = new File(\"s.txt\");
         boolean delete = file3.delete();
         System.out.println(delete);
     }
 }

字节输入流InputStream

所有的字节输入流的老祖宗就是 java.io.InputStream。

字节流的特点：是以字节的方式处理数据

这个类是一个抽象类，其目的就是为了让其他的类实现。所以我们都是使用这个类的子类。

浏览API：

• int available() 返回从该输入流中可以读取（或跳过）的字节数的估计值，而不会被下一次调用此输入流的方法阻塞。 （这个方法对于网络流是无效的）

• void close() 关闭此输入流并释放与流相关联的任何系统资源。

• void mark(int readlimit) 标记此输入流中的当前位置。

• boolean markSupported() 测试这个输入流是否支持 mark和 reset方法。

• abstract int read() 从输入流读取数据的下一个字节。

• int read(byte[] b) 从输入流读取一些字节数，并将它们存储到缓冲区 b 。

• int read(byte[] b, int off, int len) 从输入流读取最多 len字节的数据到一个字节数组。

• void reset() 将此流重新定位到上次在此输入流上调用 mark方法时的位置。

• long skip(long n) 跳过并丢弃来自此输入流的 n字节数据。

FileInputStream--InputStream的实现类

构造方法：

• FileInputStream(File file) 通过打开与实际文件的连接创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。

• FileInputStream(String name) 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

API：就是参考父类的API。

使用：按照单个的字节读取数据。

 public class FileInputStreamTest {
     public static void main(String[] args) {
         // 通过文件名构建一个字节输入流
         InputStream in = null;
         try {
             // 创建输入流
             in = new FileInputStream(\"names.txt\");
             int len = in.available();// 可读去字节的长度
             System.out.println(\"数据长度：\"+len);
             // 准备一个len长度的字节数组
             byte [] buff = new byte[len];
             int index = 0;
             // 准备读取数据
             //  读取一个字节的数据
             //int read = in.read();
             // 循环读取
             int data = -1;
             while((data = in.read())!=-1){
             //System.out.println(data);
                 // 将数据放入字节数组
              buff[index++] = (byte)data;
                 // index++;
             };
             // 字节数组中的数据
             System.out.println(Arrays.toString(buff));
             // 根据字节数组创建一个字符串
             String str = new String(buff);
             System.out.println(str);
         }catch (IOException e){
             e.printStackTrace();
         }finally {
             try{
                 if(in!=null){
                     in.close();
                 }
             }catch (IOException ex){
                 ex.printStackTrace();
             }
         }
     }
 }

输入流还提供了一些API可以按组读取数据

按组读取数据的API-1：

public class FileInputStreamTest1 {
    public static void main(String[] args) {
        // 通过文件名构建一个字节输入流
        InputStream in = null;
        try {
            // 根据文件创建输入流
            File file = new File(\"names.txt\");
            in = new FileInputStream(file);
            // 按组读取
            // int read(byte[] b)读取最多b.length字节的数据到字节数组    返回值实际读取的长度。如果到达文件末尾返回-1
            // 准备一个字节数组
            byte [] buff = new byte[500];
            // 读取数据到缓冲数组
            int len = in.read(buff);
            System.out.println(\"实际读取的长度是：\"+len);
            String str = new String(buff);// 根据整个数组创建字符串
            System.out.println(str);
            System.out.println(\"--------------\");
            // 根据实际读取的字节长度创建字符串
            //(字节数组,偏移量,使用长度)
            String info = new String(buff,0,len);
            System.out.println(info);
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(in!=null){
                    in.close();
                }
            }catch (IOException ex){
                ex.printStackTrace();
            }
        }
    }
}

按组读取数据API-2:

 public class FileInputStreamTest2 {
     public static void main(String[] args) {
         // 通过文件名构建一个字节输入流
         InputStream in = null;
         try {
             // 根据文件创建输入流
             File file = new File(\"names.txt\");
             in = new FileInputStream(file);
             // 按组读取
             // read(byte[] b, int off, int len) 读取数据，从还数组的off位置开始放数据，放len长度
             // 准备一个字节数组
             byte [] buff = new byte[500];
             // 读取数据
             int len = in.read(buff, 100, 355);
             // 创建字符串
             String str = new String(buff,100,len);
             System.out.println(str);
         }catch (IOException e){
             e.printStackTrace();
         }finally {
             try{
                 if(in!=null){
                     in.close();
                 }
             }catch (IOException ex){
                 ex.printStackTrace();
             }
         }
     }
 }

实际应用中读取文件：

上面的按组读取的例子中，都是一次性将所有的数据读取到内存中。

如果一个文件有一个T，我们肯定无法一次性读取到内存。

解决方案：按组，循环读取，重复使用缓冲数组。

看程序：

 public class FileInputStreamTest3 {
     public static void main(String[] args) {
         // 通过文件名构建一个字节输入流
         InputStream in = null;
         try {
             // 根据文件创建输入流
             File file = new File(\"data.txt\");
             in = new FileInputStream(file);
             // 准备一个缓冲数组
             byte [] buff = new byte[1024];
             int len = -1;
             long total = 0;
             // 将每次读取到数组中的实际的长度赋值给len，如果len是-1表示已经到达文件末尾，结束读取
             while((len = in.read(buff))!=-1){
                 total += len;
                 // 输出缓冲数组中的数据
                 String str = new String(buff,0,len);
                 System.out.print(str);
             }
             System.out.println(\"\\n读取的数据的总长度是：\"+total);
         }catch (IOException e){
             e.printStackTrace();
         }finally {
             try{
                 if(in!=null){
                     in.close();
                 }
             }catch (IOException ex){
                 ex.printStackTrace();
             }
         }
     }
 }

字节输出流OuputStream

OuputStream是所有的字节输出流的老祖宗。

API：

• void close() 关闭此输出流并释放与此流相关联的任何系统资源。

• void flush() 刷新此输出流并强制任何缓冲的输出字节被写出。

• void write(byte[] b) 将 b.length字节从指定的字节数组写入此输出流。

• void write(byte[] b, int off, int len) 从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。

• abstract void write(int b) 将指定的字节写入此输出流。

FileOutputStream--OutputStream的实现类

• FileOutputStream(File file) 创建文件输出流以写入由指定的 File对象表示的文件。

• FileOutputStream(File file, boolean append) 创建文件输出流以写入由指定的 File对象表示的文件。

• FileOutputStream(String name) 创建文件输出流以指定的名称写入文件。

• FileOutputStream(String name, boolean append) 创建文件输出流以指定的名称写入文件。

api就是父类中的方法。

构造方法案例：

public class FileOutputStreamTest1 {
    public static void main(String[] args) {
        // 申明字节输出流
        OutputStream out = null;
        try{
            // 创建流
            // 根据文件创建输出流
            File file = new File(\"st.txt\");
            // 从文件开头开始写数据。 覆盖了原有的数据
            out = new FileOutputStream(file);
            // 根据文件创建输出流
            // append:
            //  true 从文件的末尾开始写，续在文件原有数据的后面。
            //  false  从文件的开头开始写，覆盖原有数据
            out = new FileOutputStream(file,true);
            // 根据文件名创建输出流
            // 从文件开头开始写数据。 覆盖了原有的数据
            out = new FileOutputStream(\"hell.txt\");
            // append:
            //  true 从文件的末尾开始写，续在文件原有数据的后面。
            //  false  从文件的开头开始写，覆盖原有数据
            out = new FileOutputStream(\"hell.txt\",true);
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(out!=null){
                    out.close();
                }
            }catch (IOException ex){
                ex.printStackTrace();
            }
        }
    }
}

tips：如果我们创建的输出流指向的文件不存在，当我们写出数据的时候会自动创建这个文件。

三个写数据的API：

输出一个字节：

public class FileOutputStreamTest1 {
    public static void main(String[] args) {
        // 申明字节输出流
        OutputStream out = null;
        try{
            //--------------------------------------------------
            // 创建流
            out = new FileOutputStream(\"hell.txt\",true);// ***
            // 准备一个字符串
            String str = \"吃鸡全靠苟\";
            // 将字符串转换为字节数组
            byte[] bytes = str.getBytes();//???
            // 循环的将字节数组的内容写入文件
            for(byte b : bytes) {
                out.write(b);// ****
            }
            //-------------------------------------------------
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(out!=null){
                    out.close();
                }
            }catch (IOException ex){
                ex.printStackTrace();
            }
        }
    }
}

写出一个字节数组:

public class FileOutputStreamTest2 {
    public static void main(String[] args) {
        // 申明字节输出流
        OutputStream out = null;
        try{
            //------------------------
            // 创建流
            // 根据文件创建输出流
            File file = new File(\"st1.txt\");
            // 从文件开头开始写数据。 覆盖了原有的数据
            out = new FileOutputStream(file);
            // 准备一个字符串
            String str = \"吃鸡全靠苟\";
            // 将字符串转换为字节数组
            byte[] bytes = str.getBytes();
            // 直接写出一个字节数组
            out.write(bytes);
            //------------------
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(out!=null){
                    out.close();
                }
            }catch (IOException ex){
                ex.printStackTrace();
            }
        }
    }
}

写出字节数组的一部分：

 public class FileOutputStreamTest3 {
     public static void main(String[] args) {
         // 申明字节输出流
         OutputStream out = null;
         try{
             // 创建流
             // 根据文件创建输出流
             File file = new File(\"st2.txt\");
             // 从文件开头开始写数据。 覆盖了原有的数据
             out = new FileOutputStream(file);
             // 准备一个字符串
             String str = \"吃鸡全靠苟\";
             // 将字符串转换为字节数组
             byte[] bytes = str.getBytes();
             // 直接写出一个字节数组的一部分
             // (字节数组,偏移量，长度)  从字节数组的偏移量位置开始写数据，写长度这么常
             out.write(bytes,0,6);
         }catch (IOException e){
             e.printStackTrace();
         }finally {
             try{
                 if(out!=null){
                     out.close();
                 }
             }catch (IOException ex){
                 ex.printStackTrace();
             }
         }
     }
 }

一个需求：

从控制台输入一个商品的信息，将商品信息写入商品文件。文件中一行存储一个商品信息。​

 /**
  * 从控制台输入一个商品的信息，将商品信息写入商品文件。文件中一行存储一个商品信息。
  */
 public class Ex1 {
     public static void main(String[] args) {
         Scanner sc = new Scanner(System.in);
         OutputStream out = null;
         try{
             // 创建输出流
             out = new FileOutputStream(\"products.txt\",true);
             // 提示输出商品的内容
             String op = \"\";
             do{
                 System.out.println(\"请输入商品编号:\");
                 String itemId = sc.next();
                 System.out.println(\"请输入商品名称:\");
                 String itemName = sc.next();
                 System.out.println(\"请输入商品价格:\");
                 String itemPrice = sc.next();
                 // 用户输入的数据要写入文件
                 String info = itemId+\"&\"+itemName+\"&\"+itemPrice+\"\\n\";
                 // 将字符串写入文件
                 out.write(info.getBytes());
                 System.out.println(\"退出请输入(exit):\");
                 op = sc.next();
             }while(!op.equalsIgnoreCase(\"exit\"));
         }catch (IOException e){
             e.printStackTrace();
         }finally {
             try{
                 if(out!=null){
                     out.close();
                 }
             }catch (IOException ex){
                 ex.printStackTrace();
             }
         }
     }
 }

再来一个需求：

将上一个需求写文件的商品，读取出来，使用[9527,尤克里里,1525] 形式输出到控制台。​

 /**
  * 将上一个需求写文件的商品，读取出来，使用[9527,尤克里里,1525] 形式输出到控制台。
  */
 public class Ex2 {
     public static void main(String[] args) {
         // 读取所有的数据，再进行分割处理
         InputStream in = null;
         try{
             // 创建输入流
             in = new FileInputStream(\"products.txt\");
             // 循环的读取所有的内容放在一个StringBuilde中
             StringBuilder sb = new StringBuilder();
             // 准备读取
             int len = -1;// 每次读取的实际长度
             byte [] buff = new byte[1024]; // 缓冲数组
             while((len = in.read(buff))!=-1){
                 // 将数据转换为字符串
                 String str = new String(buff,0,len);
                 // 将字符串键入StringBuilder
                 sb.append(str);
             }
             System.out.println(sb.toString());
             // 完整的商品信息字符串
             String ps = sb.toString();
             String[] rows = ps.split(\"\\n\");// 使用换行符拆分
             for (String row : rows){
                 // 9530&路基亚打电脑&150
                 String[] attrs = row.split(\"&\");
                 String info = \"[\"+attrs[0]+\",\"+attrs[1]+\",\"+attrs[2]+\"]\";
                 System.out.println(info);
             }
         }catch (IOException e){
             e.printStackTrace();
         }finally {
             try{
                 if(in!=null){
                     in.close();
                 }
             }catch (IOException ex){
                 ex.printStackTrace();
             }
         }
     }
 }

文件拷贝：

文件拷贝流程：

我们来拷贝一个压缩文件：

 public class CopyFileTest {
     public static void main(String[] args) {
         InputStream in = null;
         OutputStream out = null;
         try {
             // -------------------------------------------
             // 创建输入流
             in = new FileInputStream(\"java-SE.rar\");
             // 创建输出流
             out = new FileOutputStream(\"java-SE-V1.rar\");
             // 使用字节流读取数据
             int len = -1;
             byte [] buff = new byte[1024];
             while((len = in.read(buff))!=-1){
                 // 写出数据
                 out.write(buff,0,len);
             }
             // ---------------------------------------------
         }catch (IOException e){
             e.printStackTrace();;
         }finally {
             try{
                 if(in != null){
                     in.close();
                 }
                 if(out != null){
                     out.close();
                 }
             }catch (IOException ex){
                 ex.printStackTrace();
             }
         }
     }
 }

字符流

字符流，就是按照字符处理文件的。

字节流，按照字节处理文件。可以处理所有的文件。一般使用中，字节流偏多。

文本文件：纯文本文件。不保存任何的格式，文件头之类的信息。

字符流往往是用来处理纯文本文件或者网络上的文本信息。

字符输入流Reader

Reader本身是一个抽象类

API：

• abstract void close() 关闭流并释放与之相关联的任何系统资源。

• void mark(int readAheadLimit) 标记流中的当前位置。

• boolean markSupported() 告诉这个流是否支持mark（）操作。

• int read() 读一个字符

• int read(char[] cbuf) 将字符读入数组。

• abstract int read(char[] cbuf, int off, int len) 将字符读入数组的一部分。

• int read(CharBuffer target) 尝试将字符读入指定的字符缓冲区。

• boolean ready() 告诉这个流是否准备好被读取。

• void reset() 重置流。

• long skip(long n) 跳过字符

FileReader --Reader类的子类

也是我们常用的字符输入流. （FileInputStream）

构造方法

• FileReader(File file) 创建一个新的 FileReader ，给出 File读取。

• FileReader(String fileName) 创建一个新的 FileReader ，给定要读取的文件的名称。

API：所有的API都是来自于父类。

使用：

 public class FileReaderTest1 {
     public static void main(String[] args) {
         FileReader reader = null;
         try{
             // 创建reader
             reader = new FileReader(\"names.txt\");
             // 读取一个字符(这里返回的是整形)
             int read = reader.read();
             // 将整形强制转换为字符型
             char ch = (char)read;
             System.out.println(ch);
             // 读取一组字符
             // 准备一个字符缓冲区
             char [] buff = new char[20];
             reader.read(buff);
             System.out.println(Arrays.toString(buff));
             // 读取一部分字符，放在一个字符数组的某一部分
             int len = reader.read(buff,3,10);
             System.out.println(Arrays.toString(buff));
         }catch (IOException e){
             e.printStackTrace();
         }finally {
             try{
                 if(reader!=null)
                     reader.close();
             }catch (IOException ex){
                 ex.printStackTrace();
             }
         }
     }
 }

字符输出流Writer

API:

• Writer append(char c) 将指定的字符附加到此作者。

• Writer append(CharSequence csq) 将指定的字符序列附加到此作者。

• Writer append(CharSequence csq, int start, int end) 将指定字符序列的子序列附加到此作者。

• abstract void close() 关闭流，先刷新。

• abstract void flush() 刷新流。

• void write(char[] cbuf) 写入一个字符数组。

• abstract void write(char[] cbuf, int off, int len) 写入字符数组的一部分。

• void write(int c) 写一个字符

• void write(String str) 写一个字符串

• void write(String str, int off, int len) 写一个字符串的一部分。

FileWriter--在字节流中对应：FileOutputStream

构造方法：

• FileWriter(File file) 给一个File对象构造一个FileWriter对象。

• FileWriter(File file, boolean append) 给一个File对象构造一个FileWriter对象。

• FileWriter(String fileName) 构造一个给定文件名的FileWriter对象。

• FileWriter(String fileName, boolean append) 构造一个FileWriter对象，给出一个带有布尔值的文件名，表示是否附加写入的数据。

没有自己的特殊API。全部是父类的API。

案例：

 public class FileWriterTest1 {
     public static void main(String[] args) {
         FileWriter writer = null;
         try{
             // 创建writer  (当写入数据的时候，会自动创建这个文件)
             writer = new FileWriter(\"rzs.txt\",true);
             // 可以写数据了
             writer.write(\"木叶的旗木五五开老师!!!\\n\");
             // 也可以写一个字符
             writer.write(96);
             writer.write(97);
             // 可以写一个字符数组
             char [] chs = {\'宇\',\'智\',\'波\',\'五\',\'五\',\'开\',\'\\n\'};
             writer.write(chs);
             // 写字符数组的一部分
             writer.write(chs,3,4);
         }catch (IOException e){
             e.printStackTrace();
         }finally {
             try{
                 if(writer!=null)
                     writer.close();
             }catch (IOException ex){
                 ex.printStackTrace();
             }
         }
     }
 }

下载一个HTML文件

 package com.qidian.spider;
 ​
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.HttpURLConnection;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLConnection;
 ​
 public class DownloadHtml {
     private static String path = \"http://search.dangdang.com/?key=java&act=input\";
     public static void main(String[] args)  {
         // 申明
         InputStream in = null;
         OutputStream out = null;
         try {
             // 连接网络-------------
             URL url = new URL(path);
             HttpURLConnection urlConnection = 
                 (HttpURLConnection) url.openConnection();
             urlConnection.connect();
             // 得到指向这个网页的输入流
             in = urlConnection.getInputStream();
             out = new FileOutputStream(\"hehe.html\");
             // 拷贝的过程
             int len = -1;
             byte [] buff = new byte[1024];
             while((len = in.read(buff))!=-1){
                 out.write(buff,0,len);
             }
         }catch (IOException e){
             e.printStackTrace();
         }finally {
             try{
                 if(in!=null)
                     in.close();
                 if(out!=null)
                     out.close();
             }catch (IOException ex){
                 ex.printStackTrace();
             }
         }
     }
 }

字符流的文件拷贝

 package com.qidian.demo1;
 ​
 import java.io.*;
 public class CopyFileTest {
     public static void main(String[] args) {
         Reader reader = null;
         Writer writer = null;
         try {
             reader = new FileReader(\"hehe.html\");
             writer = new FileWriter(\"haha.html\");
             int len = -1;
             char [] buff = new char[256];
             while((len = reader.read(buff))!=-1){
                 writer.write(buff,0,len);
             }
         }catch (IOException e){
             e.printStackTrace();
         }finally {
             try{
                 if(reader!=null)
                     reader.close();
                 if(writer!=null)
                     writer.close();
             }catch (IOException ex){
                 ex.printStackTrace();
             }
         }
     }
 }

缓冲字符输入流：BufferedReader

构造方法：

• BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。

• BufferedReader(Reader in, int sz) 创建使用指定大小的输入缓冲区的缓冲字符输入流。

在缓冲流中用到了“装饰设计模式”。 使用BufferedReader包裹一个Reader，实现缓冲。

其中大部分API和Reader没啥区别。有一个特殊的API：

• String readLine() 读一行文字。

案例：

 public class BufferedReaderTest {
     public static void main(String[] args) {
         BufferedReader bufReader = null;
         Reader reader = null;// 这个reader对象就是让BufferedReader包裹的对象
         try{
             // 先创建reader
             reader = new FileReader(\"names.txt\");
             // 创建缓冲输入流  (任何需要父类型的地方，都可以使用子类型代替)
             bufReader = new BufferedReader(reader);
             // 按行读取（读取不到数据的时候，返回null）
 //            String s = bufReader.readLine();
 //            System.out.println(s);
             String line = null;
             while((line = bufReader.readLine())!=null){
                 System.out.println(line);
             };
         }catch (IOException e){
             e.printStackTrace();
         }finally {
             try{
                 if(bufReader!=null)
                     bufReader.close();
             }catch (IOException ex){
                 ex.printStackTrace();
             }
         }
     }
 }

缓冲字符输出流--BufferedWriter

构造方法：

• BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。

• BufferedWriter(Writer out, int sz) 创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。

创建BufferedWriter的时候需要包裹一个Writer对象

特殊的API：

• void newLine() 写一行行分隔符。

缓冲输出流要注意的问题：

当调用了缓冲输出流的write方法之后，数据可能只是写在缓冲区，并没有实际写到输出流。理论上当关闭输出流的时候，所有缓冲区的数据会刷出。 一般建议我们手动调用 flush方法刷出缓冲区数据。

案例：

 public class BufferedWriterTest {
     public static void main(String[] args) {
         BufferedWriter bufWriter = null;
         Writer writer = null;
         try{
             // 创建writer
             writer = new FileWriter(\"rzs.txt\");
             // 创建BufferedWriter
             bufWriter = new BufferedWriter(writer);
             // 写数据
             // 循环写
             for(int i = 0;i < 100;i++){
                 // 缓冲流在调用了write方法之后，不一定把数据写出去了。
                 // 数据可能仅仅在缓冲区。
                 bufWriter.write(\"[adminName:\'鸣人\"+i+\"\',adminPass:\'123456\']\");
                 // 写入一个换行符
                 bufWriter.newLine();
             }
             // 刷出缓冲区的数据
             //bufWriter.flush();
         }catch (IOException e){
             e.printStackTrace();
         }finally {
             // 缓冲流在关闭的时候，理论上会将缓冲区所有的数据全部写出去
             try{
                 if(bufWriter!=null)
                     bufWriter.close();
                 if(writer!=null)
                     writer.close();
             }catch (IOException ex){
                 ex.printStackTrace();
             }
         }
     }
 }

缓冲字节输入流--BufferedInputStream

构造方法

• BufferedInputStream(InputStream in) 创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使用。

• BufferedInputStream(InputStream in, int size) 创建 BufferedInputStream具有指定缓冲区大小，并保存其参数，输入流 in ，供以后使用。

其他的API，不需要说明，和FileOutputStream用法完全一致。只不过提高了底层的效率。

缓冲字节输出流：BufferedOutputStream

构造方法

• BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。

• BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流，以便以指定的缓冲区大小将数据写入指定的底层输出流。

API........你就把它当FileOutputStream使用就行了。

我们使用 缓冲（高效）字节流完成一个文件拷贝的过程。

案例：

 public class CopyFileTest {
     public static void main(String[] args) {
         InputStream in = null;
         OutputStream out = null;
         BufferedInputStream bufIn = null;
         BufferedOutputStream bufOut = null;
         try{
             // 创建4个流。
             // 输入流
             in = new FileInputStream(\"java-SE.rar\");
             bufIn = new BufferedInputStream(in);
             // 输出流
             out = new FileOutputStream(\"java-SE-V1.rar\");
             bufOut = new BufferedOutputStream(out);
             // 拷贝过程。。。。。。
             int len = -1;
             byte [] buff = new byte[1024];
             while((len = bufIn.read(buff))!=-1){
                 bufOut.write(buff,0,len);
             }
         }catch (IOException e){
             e.printStackTrace();
         }finally {
             try{
                 // 输入流先关闭里面的流，在关闭外面的流
                 if(in!=null)
                     in.close();
                 if(bufIn!=null)
                     bufIn.close();
                 // 输出流先关闭外面的流，再关闭里面的流
                 if(bufOut!=null)
                     bufOut.close();
                 if(out!=null)
                     out.close();
             }catch (IOException ex){
                 ex.printStackTrace();
             }
         }
     }
 }

转换流目的：将字节流转换为字符流。 能不能将字符流转换为字节流？NO

转换输入流：InputStreamReader

构造方法：

• InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader。

• InputStreamReader(InputStream in, Charset cs) 创建一个使用给定字符集的InputStreamReader。

• InputStreamReader(InputStream in, CharsetDecoder dec) 创建一个使用给定字符集解码器的InputStreamReader。

• InputStreamReader(InputStream in, String charsetName) 创建一个使用命名字符集的InputStreamReader。

API和Reader一致。

转换输出流：OutputStreamWriter

• OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。

• OutputStreamWriter(OutputStream out, Charset cs) 创建一个使用给定字符集的OutputStreamWriter。

• OutputStreamWriter(OutputStream out, CharsetEncoder enc) 创建一个使用给定字符集编码器的OutputStreamWriter。

• OutputStreamWriter(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter。

API和writer完全一致。

案例：转换输入流。

 public class InputStreamReaderTest {
     public static void main(String[] args) {
         InputStream in = null;
         InputStreamReader reader = null;
         BufferedReader bufReader = null;
         try{
             // 创建这些流
             // 创建字节流
             in = new FileInputStream(\"names.txt\");
             // 将字节流转换字符流
             reader = new InputStreamReader(in);
             // 将字符流包裹为缓冲字符流
             bufReader = new BufferedReader(reader);
             // 循环读取数据
             String line = null;
             while((line = bufReader.readLine())!=null){
                 System.out.println(line);
             };
         }catch (IOException e){
             e.printStackTrace();
         }finally {
             try{
                 if(bufReader!=null)
                     bufReader.close();
             }catch (IOException ex){ex.printStackTrace();}
         }
     }
 }

字节输出流转换为字符输出流：

案例：

public class OutputStreamWriterTest {
    public static void main(String[] args) {
        OutputStream out = null;
        OutputStreamWriter writer = null;
        try {
            // 创建字节流
            out = new FileOutputStream(\"hehe.txt\");
            // 将字节流包裹成字符流
            writer = new OutputStreamWriter(out);
            // 写字符串
            writer.write(\"一个字符串\\n\");
            writer.write(\"下午两点上课\\n\");
            writer.write(\"上完可，做好防护，去做核算\");
            writer.flush();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(out!=null){
                    out.close();
                }
            }catch (IOException ex){
                ex.printStackTrace();
            }

        }
    }
}

对象流

序列化

为了方便数据的存储或者传输，将数据或者对象转换为可存储或者传输的形式的过程称之为序列化。相反就是反序列化。

例子：在线购物，卖家给你打包的过程就是序列化。你拆包裹的过程就是反序列化。

项目中的：

将一个对象转换为json输出到客户端。将对象转换为json就是序列化。

将JSON转换对象的过程就是反序列化。

对象流就是专门用来对对象进行序列化和反序列化。

对象输出流：ObjectOutputStream(写出)

专门用来序列化对象的。（卖家打包）

构造方法：

• ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。

对象输出流内部其实是包裹了一个字节输出流。

对象输出流的作用：

API：

• void close() 关闭流。

• void write(byte[] buf) 写入一个字节数组。

• void write(byte[] buf, int off, int len) 写入一个子字节数组。

• void write(int val) 写一个字节。

• void writeBoolean(boolean val) 写一个布尔值。

• void writeByte(int val) 写入一个8位字节。

• void writeBytes(String str) 写一个字符串作为字节序列。

• void writeChar(int val) 写一个16位的字符。

• void writeChars(String str) 写一个字符串作为一系列的字符。

• void writeDouble(double val) 写一个64位的双倍。

• void writeFloat(float val) 写一个32位浮点数。

• void writeInt(int val) 写一个32位int。

• void writeLong(long val) 写一个64位长

• void writeShort(int val) 写一个16位短。

• void writeObject(Object obj) 将指定的对象写入ObjectOutputStream。

对象输出流是写一个对象出去的操作。

java中都有哪些对象？

java中的对象真的很多，但是所有的对象统称为Object。其实对象流特意准备了几个方法，写这些对象。

• writeXxxx(Xxx xxx) 这里的Xxxx表示任何一个基本类型。

• writeObject(Object obj) 其余的类型全部使用Object。

案例1： 序列化基本类型

public class ObjectWriteTest1 {
    public static void main(String[] args) {
        OutputStream out = null;
        ObjectOutputStream objOut = null;
        try{
            // 创建字节输出流
            out = new FileOutputStream(\"ints.txt\");
            // 创建对象流
            objOut = new ObjectOutputStream(out);
            // 写出一个整形
            objOut.writeInt(12);
            objOut.writeDouble(12.5);
            // 刷出数据
            objOut.flush();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(out!=null)
                    out.close();
            }catch (IOException ex){
                ex.printStackTrace();;
            }
        }
    }
}

案例2： 序列化自定义类型

准备一个实体类：

public class User {
    private int id;
    private String name;
    
}

测试：

出现异常。

这个异常产生的原因是因为ObjectOutputStream写的对象必须实现接口java.io.Serializable。否则无法序列化。 这个接口本身是没有任何的方法和成员的，它就是用来标记一个类的对象是否可以被序列化。

public interface Serializable {
}

我们让我们的User类实现这个接口：

完整的测试代码：

public class ObjectWriteTest2 {
    public static void main(String[] args) {
        OutputStream out = null;
        ObjectOutputStream objOut = null;
        try{
            // 创建字节输出流
            out = new FileOutputStream(\"u.txt\");
            // 创建对象流
            objOut = new ObjectOutputStream(out);
            // 创建一个User
            User u = new User(1,\"就乌尔奇\");
            // 写出对象u
            objOut.writeObject(u);
            // 刷出数据
            objOut.flush();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(out!=null)
                    out.close();
            }catch (IOException ex){
                ex.printStackTrace();;
            }
        }
    }
}

对象输入流：ObjectInputStream（读取）

专门用来反序列化对象的。（买家拆包裹）

构造方法：

• ObjectInputStream(InputStream in) 创建从指定的InputStream读取的ObjectInputStream。

ObjectInputStream会包裹一个InputStream

其他的API：

• int read() 读取一个字节的数据。

• int read(byte[] buf, int off, int len) 读入一个字节数组。

• boolean readBoolean() 读取布尔值。

• byte readByte() 读取一个8位字节。

• char readChar() 读一个16位字符。

• double readDouble() 读64位双倍。

• float readFloat() 读32位浮点数。

• int readInt() 读取一个32位int。

• long readLong() 读64位长。

• short readShort() 读取16位短。

• Object readObject() 从ObjectInputStream读取一个对象。

有个小问题：无法判定是否到达了文件的末尾。

当使用ObjectInputStream读取数据的时候，如果出现了EOFException。说明到达了文件的末尾。

案例1： 读取上一小节写入文件的int和double。

public class ObjectInputTest1 {
    public static void main(String[] args) {
        InputStream in = null;
        ObjectInputStream objIn = null;
        try{
            // 创建字节流
            in = new FileInputStream(\"ints.txt\");
            // 创建对象流
            objIn = new ObjectInputStream(in);
            // 反序列化数据
            int i = objIn.readInt();
            System.out.println(i);
            double d = objIn.readDouble();
            System.out.println(d);
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(objIn!=null)
                    objIn.close();
            }catch (IOException ex){
                ex.printStackTrace();
            }
        }
    }
}

案例2：读取写入的自定义对象

public class ObjectInputTest2 {
    public static void main(String[] args) {
        InputStream in = null;
        ObjectInputStream objIn = null;
        try{
            // 创建字节流
            in = new FileInputStream(\"u.txt\");
            // 创建对象流
            objIn = new ObjectInputStream(in);
            // 反序列化数据
            Object o = objIn.readObject();
            // 类型转换
            User u = (User) o;
            System.out.println(u);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(objIn!=null)
                    objIn.close();
            }catch (IOException ex){
                ex.printStackTrace();;
            }
        }
    }
}

一组对象的读写

情况1： 循环读写

循环的写入数据

public class ObjectWriteTest3 {
    public static void main(String[] args) {
        OutputStream out = null;
        ObjectOutputStream objOut = null;
        try{
            // 创建字节输出流
            out = new FileOutputStream(\"us.txt\");
            // 创建对象流
            objOut = new ObjectOutputStream(out);
            // 创建一组User
            List<User> us = new ArrayList<>();
            for (int i = 0;i< 100; i++){
                us.add(new User(i+1,\"鸣人\"+i));
            }
            // 循环的写出对象
            for (User u : us) {
                objOut.writeObject(u);
            }
            // 刷出数据
            objOut.flush();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(out!=null)
                    out.close();
            }catch (IOException ex){
                ex.printStackTrace();;
            }
        }
    }
}

循环的读数据

public class ObjectInputTest3 {
    public static void main(String[] args) {
        InputStream in = null;
        ObjectInputStream objIn = null;
        try{
            // 创建字节流
            in = new FileInputStream(\"us.txt\");
            // 创建对象流
            objIn = new ObjectInputStream(in);
            // 反序列化数据
            // 循环读取数据
            // 知道循环次数的处理
//            for (int i = 0;i < 100;i++){
//                Object o = objIn.readObject();
//                User u = (User) o;
//                System.out.println(u);
//            }
            // 不知道循环次数
            while(true){
                // 当到达文件的末尾的时候，会抛出异常EOFException
                Object o = objIn.readObject();
                User u = (User) o;
                System.out.println(u);
            }
        }catch(EOFException e){
            System.out.println(\"读取完成\");
        } catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(objIn!=null)
                    objIn.close();
            }catch (IOException ex){
                ex.printStackTrace();;
            }
        }
    }
}

本文来自博客园，作者：{潇潇消消气}，转载请注明原文链接：{https://www.cnblogs.com/xiaoxiaodeboke/}

来源：https://www.cnblogs.com/xiaoxiaodeboke/p/16032817.html
本站部分图文来源于网络，如有侵权请联系删除。