InputStream抽象类是所有类字节输入流的超类

    InputStream常用的子类

    1. 1.FildInputStream：文件输入流
    2. 2.BufferedInputStream：缓冲字节输入流
    3. 3.ObjectInputStream：对象字节输入流

    • InputStream代码案例

      1. // 演示读取文件
      2.   @Test
      3.   public void readFile01(){
      4.       String filePath = "e:\\news1.txt";
      5.       int readDate = 0;
      6.       FileInputStream fileInputStream = null;
      7.       try {
      8.           // 创建 FileInputStream 对象，用于读取文件
      9.           fileInputStream = new FileInputStream(filePath);
      10.           // 从该输入流读取一个字节的数据，如果没有输入可用，此方法将阻止
      11.           // 如果返回-1，表示读取完毕
      12.           while ((readDate = fileInputStream.read()) != -1){
      13.               System.out.print((char) readDate);    // 转成char显示
      14.           }
      15.       } catch (IOException e) {
      16.           e.printStackTrace();
      17.       }finally {
      18.           // 关闭文件流释放资源
      19.           try {
      20.               fileInputStream.close();
      21.           } catch (IOException e) {
      22.               e.printStackTrace();
      23.           }
      24.       }
      25.   }
      27.   /*
      28.   * 使用read(byte[] b)读取文件，提高效率
      29.   * */
      30.   @Test
      31.   public void readFile02(){
      32.       String filePath = "e:\\news1.txt";
      33.       byte[] buf = new byte[8];   // 一次读取8个字节
      34.       int readLen = 0;
      35.       FileInputStream fileInputStream = null;
      36.       try {
      37.           // 创建 FileInputStream 对象，用于读取文件
      38.           fileInputStream = new FileInputStream(filePath);
      39.           // 从该输入流读取一个字节的数据，如果没有输入可用，此方法将阻止
      40.           // 如果返回-1，表示读取完毕
      41.           // 如果读取正常，返回实际读取的字节数
      42.           while ((readLen = fileInputStream.read(buf)) != -1){
      43.               System.out.print(new String(buf, 0, readLen));    // 转成char显示
      44.           }
      45.       } catch (IOException e) {
      46.           e.printStackTrace();
      47.       }finally {
      48.           // 关闭文件流释放资源
      49.           try {
      50.               fileInputStream.close();
      51.           } catch (IOException e) {
      52.               e.printStackTrace();
      53.           }
      54.       }
      55.   }

    • OutputStream代码案例

      1.   // 演示使用FileOutputStream将数据写到文件中，如果文件不存在，则创建该文件
      2.   @Test
      3.   public void writeFile(){
      4.       // 创建 FileOutputStream对象
      5.       String filePath = "e:\\news1.txt";
      6.       FileOutputStream fileOutputStream = null;
      7.       try {
      8.           /*
      9.               1.fileOutputStream = new FileOutputStream(filePath); 创建方式，当写入内容时，会覆盖原来的文本内容
      10.               2.fileOutputStream = new FileOutputStream(filePath，true); 创建方式，当写入内容时，是追加到文本内容后面
      11.           */
      12.           fileOutputStream = new FileOutputStream(filePath,true);
      13.           // 写入一个字节
      14.           // fileOutputStream.write('H');
      15.           // 写入一个字符串
      16.           String str = "hello,www";
      17.           // str.getBytes() 可以把字符串转成字节数组
      18.           // fileOutputStream.write(str.getBytes());
      19.           // write(str.getBytes(),0,int len) 将len字节从位于偏移量 off的指定字节数组
      20.           fileOutputStream.write(str.getBytes(),0,str.length());
      21.       } catch (IOException e) {
      22.           e.printStackTrace();
      23.       }finally {
      25.           try {
      26.               fileOutputStream.close();
      27.           } catch (IOException e) {
      28.               e.printStackTrace();
      29.           }
      30.       }
      31.   }

    • 拷贝文件代码

      1. public static void main(String[] args) {
      2.       String srcPath = "e:\\1.jpg";
      3.       String destPath = "e:\\2.jpg";
      4.       FileInputStream fileInputStream = null;
      5.       FileOutputStream fileOutputStream = null;
      7.       try {
      8.           fileInputStream = new FileInputStream(srcPath);
      9.           fileOutputStream = new FileOutputStream(destPath);
      11.           // 定义一个字节数组，提高读取效果
      12.           byte[] buf = new byte[1024];
      13.           int readLen = 0;
      15.           while ((readLen = fileInputStream.read(buf)) != -1) {
      16.               // 读取到后，就写入到文件，通过fileOutputStream
      17.               // 即，是一边写一边读
      18.               fileOutputStream.write(buf,0,readLen);  // 一定要使用这个方法
      19.           }
      20.           System.out.println("拷贝成功");
      21.       } catch (IOException e) {
      22.           e.printStackTrace();
      23.       } finally {
      24.           try {
      25.               // 关闭输入流和输出流，释放资源
      26.               if (fileInputStream != null) {
      27.                   fileInputStream.close();
      28.               }
      29.               if (fileOutputStream != null) {
      30.                   fileOutputStream.close();
      31.               }
      32.           } catch (IOException e) {
      33.               e.printStackTrace();
      34.           }
      35.       }
      37.   }