首页 > 编程语言 >InputStream类、OutputStream类、BufferedInputStream类与BufferedOutputStream类--Java基础084

InputStream类、OutputStream类、BufferedInputStream类与BufferedOutputStream类--Java基础084

时间：2023-02-06 20:35:49浏览次数：44  
标签：OutputStream Java io BufferedInputStream File import new 字节 out 


package com.sqf.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;

/*
 File类: 用于描述一个文件或者文件夹的。
 
 通过File对象我们可以读取文件或者文件夹的属性数据，如果我们需要读取文件的内容数据，那么我们需要使用IO流技术。
 
IO流（Input Output）

IO流解决问题： 解决设备与设备之间的数据传输问题。  内存--->硬盘   硬盘--->内存


IO流技术：


IO流分类：
  如果是按照数据的流向划分：
    
    输入流
    
    
    输出流
    
  如果按照处理的单位划分：
  
    字节流: 字节流读取得都是文件中二进制数据，读取到二进制数据不会经过任何的处理。
    
    
    字符流： 字符流读取的数据是以字符为单位的 。 字符流也是读取文件中的二进制数据，不过会把这些二进制数据转换成我们能 识别的字符。  
        字符流 = 字节流 + 解码
        
输入字节流：
--------| InputStream 所有输入字节流的基类  抽象类
------------| FileInputStream  读取文件数据的输入字节流 
      
使用FileInputStream读取文件数据的步骤：
  1. 找到目标文件
  2. 建立数据的输入通道。
  3. 读取文件中的数据。
  4. 关闭 资源.

问题1： 读取完一个文件的数据的时候，我不关闭资源有什么影响?
 答案： 资源文件一旦 使用完毕应该马上释放，否则其他的程序无法对该资源文件进行其他 的操作。
         
 */
public class Demo {
  
  
  public static void main(String[] args) throws IOException {
    readTest4();
    
  }
  //方式4：使用缓冲数组配合循环一起读取。28
  public static void readTest4() throws IOException {
    File file = new File("g:\\a.txt");
    FileInputStream in = new FileInputStream(file);
    int length = 0;
    byte[] buf = new byte[1024];
    
    while((length=in.read(buf))!=-1){
      System.out.println(new String(buf,0,length));
    }
  }

  //读取的方式一缺陷： 无法读取完整一个文件 的数据.
  public static void readTest1() throws FileNotFoundException, IOException {
    //1. 找到目标文件
    File file = new File("g:\\a.txt");
    //建立数据的输入通道。
    FileInputStream in = new FileInputStream(file);
    //读取文件中的数据
    int content = in.read();
    
    System.out.println((char)content);
    //关闭资源    实际上就是释放资源。 
    in.close();
  }
  
  //方式2 ： 使用循环读取文件的数据
  public static void readTest2() throws IOException {
    
    long startTime = System.currentTimeMillis();
    //找到目标文件
    File file = new File("g:\\a.jpg");
    //建立数据的输入通道
    FileInputStream in = new FileInputStream(file);
    //读取文件的数据
    int content = 0;//声明该变量用于存储读取到的数据
    while((content=in.read())!=-1){
      System.out.println((char)content);
    }
    in.close(); //关闭资源
    
    long endTime = System.currentTimeMillis();
    System.out.println("读取的时间:" + (endTime-startTime));
  }
  
  //方式3：使用缓冲 数组 读取。    缺点： 无法读取完整一个文件的数据。     12G
  public static void readTest3() throws IOException {
    File file = new File("g:\\a.txt");
    
    FileInputStream in = new FileInputStream(file);
    //建立缓冲字节数组，读取文件的数据。
    byte[] buf = new byte[1024];//建立缓冲字节数组，读取文件的数据。
    int length = in.read(buf);
    // 如果使用read读取数据传入字节数组，那么数据是存储到字节数组中的，而这时候read方法的返回值是表示的是本次读取了几个字节数据到字节数组中。
    System.out.println("length:" + length);
    
    String content = new String(buf,0,length);
    System.out.println("内容:" + content);
    
    in.close();
  }
  
}


package com.sqf.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 输出字节流：
 
 --------| OutputStream 是所有输出字节流 的父类。  抽象类
 -----------| FileOutStream 向文件输出数据的输出字节流。
 
FileOutputStream如何使用呢？
  1. 找到目标文件
  2. 建立数据的输出通道。
  3. 把数据转换成字节数组写出。
  4. 关闭资源

FileOutputStream要注意的细节：
  1. 使用FileOutputStream 的时候，如果目标文件不存在，那么会自动创建目标文件对象。 
  2. 使用FileOutputStream写数据的时候，如果目标文件已经存在，那么会先清空目标文件中的数据，然后再写入数据。
  3.使用FileOutputStream写数据的时候, 如果目标文件已经存在，需要在原来数据基础上追加数据的时候应该使用new FileOutputStream(file,true)构造函数，第二参数为true。
  4.使用FileOutputStream的write方法写数据的时候，虽然接收的是一个int类型的数据，但是真正写出的只是一个字节的数据，只是
  把低八位的二进制数据写出，其他二十四位数据全部丢弃。
   
   00000000-000000000-00000001-11111111   511
   
   
   11111111---> -1 
 */
public class Demo2 {
  
  public static void main(String[] args) throws IOException {
    writeTest4();
  }
  
   
  //需求： 拷贝一张图片。
  private static void writeTest4() throws IOException {
    //找到目标文件
    File file = new File("g:\\a.jpg");
    File aimFile = new File("g:\\r.jpg");
    //建立数据的输入输出通道
    FileInputStream in = new FileInputStream(file);
    FileOutputStream out = new FileOutputStream(aimFile);
    //每新创建一个FileOutputStream的时候，默认情况下FileOutputStream 的指针是指向了文件的开始的位置。 每写出一次，指向都会出现相应移动。
    //建立缓冲数据，边读边写
    byte[] buf = new byte[1024];
    int length = 0;
    while((length=in.read(buf))!=-1){
      out.write(buf, 0, length);
    }
    //关闭资源 原则： 先开后关，后开先关。
    out.close();
    in.close();
    
  }

  public static void writeTest3() throws IOException {
    
    File file = new File("g:\\b.txt");
    FileOutputStream out = new FileOutputStream(file);
    String data = "abcasd";
    byte[] buf = data.getBytes();
    out.write(buf, 0, 2);//  将指定字节数组中从偏移量 off 开始的 len 个字节写入此输出流。
  }

  //使用字节数组把数据写出。
  public static void writeTest2() throws IOException {
    
    File file = new File("g:\\b.txt");
    FileOutputStream out = new FileOutputStream(file);
    String data = "\r\nhello world!";
    out.write(data.getBytes());
    out.close();
  }

  //每次只能写一个字节的数据出去。
  public static void writeTest1() throws IOException {
    
    File file = new File("g:\\b.txt");
    FileOutputStream out = new FileOutputStream(file);
    out.write('h');
    out.write('e');
    out.write('l');
    out.write('l');
    out.write('o');
    
    out.close();
  }
  
}



package com.sqf.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
IO异常 的处理
*/
public class Demo3 {
  
  public static void main(String[] args) throws IOException {
    //readTest();
    copyImage();
  }

  
  public static void copyImage() {
    
    FileInputStream in = null;
    FileOutputStream out = null;
    
    try {
      File inFile = new File("g:\\a.jpg");
      File outFile = new File("g:\\r.jpg");
      
      in = new FileInputStream(inFile);
      out = new FileOutputStream(outFile);
      
      int length = 0;
      byte[] buf = new byte[1024];
      while((length=in.read(buf))!=-1){
        out.write(buf, 0, length);
      }
    } catch (IOException e) {
      System.out.println("拷贝图片出错...");
      throw new RuntimeException(e);
    }finally{
      // 关闭资源
      try {
        if (out != null) {
          out.close();
          System.out.println("关闭输出流对象成功...");
        }
      } catch (IOException e) {
        System.out.println("关闭输出流资源失败...");
        throw new RuntimeException(e);
      } finally {
        if (in != null) {
          try {
            in.close();
            System.out.println("关闭输入流对象成功...");
          } catch (IOException e) {
            System.out.println("关闭输入流对象失败...");
            throw new RuntimeException(e);
          }
        }

      }
    }
    
  }


  public static void readTest()  {
    FileInputStream in = null;
    
    try {
      
      File file = new File("g:\\a.txt");
       in = new FileInputStream(file);
      
      int length = 0;
      byte[] buf = new byte[1024];
      while((length=in.read())!=-1){
        System.out.println(new String(buf,0,length));
      }
    }catch (IOException e) {
      /*
       * //处理的代码... 首先你要阻止后面的代码执行,而且要需要通知调用者这里出错了... throw new
       * RuntimeException(e);
       * //把IOException传递给RuntimeException包装一层，然后再抛出，这样子做的目的是
       * 为了让调用者使用变得更加灵活。
       */
      System.out.println("读取文件资源错误。。。。。");
      throw new RuntimeException(e);
    }finally{
      try {
        if (in != null) {
          in.close();
        }
      } catch (Exception e) {
        System.out.println("关闭资源失败...");
        throw new RuntimeException(e);
      }
    }
    
  }
  
}
package com.sqf.io;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import javax.imageio.stream.FileImageInputStream;

/*
我们清楚读取文件数据使用缓冲数组读取效率更高，sun也知道使用缓冲数组读取效率更高，那么
这时候sun给我们提供了一个------缓冲输入字节流对象,让我们可以更高效率读取文件。

输入字节流体系： 
----| InputStream  输入字节流的基类。 抽象
----------| FileInputStream 读取文件数据的输入字节流
----------| BufferedInputStream 缓冲输入字节流    缓冲输入字节流的出现主要是为了提高读取文件数据的效率。    
其实该类内部只不过是维护了一个8kb的字节数组而已。 

注意： 凡是缓冲流都不具备读写文件的能力。

使用BufferedInputStream的步骤  :
  1. 找到目标文件。
  2. 建立数据 的输入通道
  3. 建立缓冲 输入字节流流
  4. 关闭资源
*/
public class Demo4 {
  
  public static void main(String[] args) throws IOException {
    //readTest();
    teadTest2();
  }
  
  private static void teadTest2() throws IOException {
    
    File file = new File("g:\\a.txt");
    
    FileInputStream in = new FileInputStream(file);
    //疑问一 为什么创建BufferInputStream的时候需要传递FileInputStream？
    //BufferInputStream本身是不具读备文件的能力，所以需要借助FileInputStream来读文件的数据。
    BufferedInputStream bis = new BufferedInputStream(in);
    
    int content = 0;
    while((bis.read())!=-1){
      System.out.println((char)content);
    }
    //关闭资源
    bis.close();调用BufferedInputStream的close方法实际上关闭的是FileinputStream.
  }

  //读取文件的时候我们都是使用缓冲数组读取。效率会更加高
  @SuppressWarnings("resource")
  public static void readTest() throws IOException{
    File file = new File("g:\\a.txt");
    
    FileImageInputStream in = new FileImageInputStream(file);
    byte[] buf = new byte[1024*8];
    int length = 0;
    while((length=in.read(buf))!=-1){
      System.out.println(new String(buf,0,length));
    }
    in.close();
  }
  
}



package com.sqf.io;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
输出字节流
--------| OutputStream  所有输出字节流的基类  抽象类
------------| FileOutputStream 向文件 输出数据 的输出字节流
------------| Bufferedoutputstream  缓冲输出字节流    BufferedOutputStream出现的目的是为了提高写数据的效率。 
                    内部也是维护了一个8kb的字节数组而已。
 
 使用BufferedOutputStream的步骤：
  1. 找到目标文件
  2. 建立数据的输出通道

 
BufferedOutputStream 要注意的细节
  1. 使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中。
  2. 使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中，如果需要把数据真正的写到硬盘上面，需要
  调用flush方法或者是close方法、 或者是内部维护的字节数组已经填满数据的时候。
 */
public class Demo5 {
  
  @SuppressWarnings("resource")
  public static void main(String[] args) throws IOException {
    //找到目标文件
    File file = new File("g:\\a.txt");
    //建立数据的输出通道
    FileOutputStream out = new FileOutputStream(file);
    //建立缓冲输出字节流对象
    BufferedOutputStream bot = new BufferedOutputStream(out);
    //把数据写出
    bot.write("hello world".getBytes());
    //bot.flush();  //把缓冲数组中内部的数据写到硬盘上面。
    bot.close();//这个方法的底层调用了flush()方法
  }
  
}


package com.sqf.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 练习： 使用缓冲输入输出字节流拷贝一个图片。
 * */

public class CopyImage {
  
  @SuppressWarnings("resource")
  public static void main(String[] args) throws IOException {
    File inFile = new File("g:\\a.jpg");
    File outFile = new File("g:\\aa.jpg");
    
    FileInputStream in = new FileInputStream(inFile);
    FileOutputStream out = new FileOutputStream(outFile);
    
    BufferedInputStream bis = new BufferedInputStream(in);
    BufferedOutputStream bos = new BufferedOutputStream(out);
    
    /*
      int length = 0;
              方法一:  如果传入了缓冲数组，内容是存储到缓冲数组中，返回值是存储到缓冲数组中的字节个数。
      byte[] buf = new byte[1024];
      while((length = bis.read(buf))!=-1){
        bos.write(buf, 0, length);
      }
    */
    int content = 0;
    while((content=bis.read())!=-1){
      bos.write(content);//如果使用read方法没有传入缓冲数组，那么返回值是读取到的内容。
      //bos.flush(); //刷新缓冲区数据     
    }

    bos.close();
    bis.close();
    
  }
}



标签：OutputStream,Java,io,BufferedInputStream,File,import,new,字节,out
From： https://blog.51cto.com/u_15955675/6040445

相关文章

  • File类详解--Java基础083
    packagecom.sqf.file;importjava.io.File;importjava.io.IOException;/*File类的构造方法：File(Stringpathname)指定文件或者文件夹的路径创建一个File文件......
  • javaScript - 输入与输出语句，javaScript中的数据类型，字符类型与其它基本数据类型的互
    1.输入与输出语句//输出语句alert("hello,world")//提示弹窗console.log("hello，world")//输出到控制台//输入语句//第一个参数设置提示用户输入的提示信息//第......
  • 基本数据类型(JAVA)
    基本数据类型(JAVA)标识符和关键字标识符Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。所有的标识符都应该以字母（A-Z或者a-z），美元（$），或者下划......
  • 面试必问：说一下 Java 虚拟机的内存布局？
    我们通常所说的Java虚拟机（JVM）的内存布局，一般是指Java虚拟机的运行时数据区（RuntimeDataArea），也就是当字节码被类加载器加载之后的执行区域划分。当然它通常是JVM模块......
  • JavaScript的原型和原型链
    说到JavaScript的原型和原型链，相关文章已有不少，但是大都晦涩难懂。本文将换一个角度出发，先理解原型和原型链是什么，有什么作用，再去分析那些令人头疼的关系。一、......
  • 函数的重载--Java基础026
    /*函数的重载：在一个类中出现两个或者两个以上的同名函数，这个称作为函数的重载。函数重载的作用：同一个函数名可以出现了不同的函数，以应对不同个数或者不同数据类型的参数。......
  • 数组的定义--Java基础027
    /*数组：数组是存储同一种数据类型数据的集合容器。数组的定义格式：数据类型[]变量名=new数据类型[长度];数组：存储同一种数据类型的集合容器.数组的特点：1.只能存储......
  • JavaScript国际化API
    JavaScript国际化API前言：英语是世界上使用最广泛的语言，但只有七分之一的人说英语。它是3.79亿人口的第一种（母语）语言，但是有9.17亿人说普通话，4.6亿人说西班牙语和3.41亿人......
  • JavaDoc生成文档
    JavaDoc生成文档1、单击Tools-GenerateJavaDoc2、选择要生成文档的类或包，存放路径，设置字符格式，单击OK3、进入存放JavaDoc文件夹，点击index.html即可看生成的JavaDoc......
  • JAVAHOME的配置--Java基础003
    有时候可能需要更换Jdk的目录，但是经常修改path的值可能会不小心修改其他的路径，解决方法：1、 创建一个JAVA_HOME的变量。 2、 JAVA_HOME的值为JDK的安装目录。3、配置path......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99