java基础io流——OutputStream和InputStream的故事

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量208 收藏
点赞数
分类专栏： Java 文章标签： java linux 编程语言 大数据 python
原文链接：https://blog.csdn.net/weixin_36586120/article/details/80486112
版权

io流概述：

IO流用来处理设备之间的数据传输，上传文件和下载文件，Java对数据的操作是通过流的方式，Java用于操作流的对象都在IO包中。

IO流分类

按照数据流向

输入流 读入数据

输出流 写出数据

按照数据类型

字节流

字符流

什么情况下使用哪种流呢?

如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流，其他用字节流。

如果你什么都不知道，就用字节流。

IO流常用基类

字节流的抽象基类：

InputStream ，OutputStream。

字符流的抽象基类：

Reader ， Writer。

注：
由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream。
如：Reader的子类FileReader。

OutputStream的子类FileOutputStream

构造方法：

FileOutputStream(File file)

FileOutputStream(String name)

推荐第二种构造方法：

FileOutputStream outputStream = new FileOutputStream("a.txt");

   
   

   
   
  • 1

创建字节输出流对象了做了几件事情：

A:调用系统功能去创建文件
B:创建outputStream对象
C:把foutputStream对象指向这个文件

   
   

   
   
  • 1
  • 2
  • 3
通过字节输出流写出数据到文本
public void write(int b)
public void write(byte[] b)
public void write(byte[] b,int off,int len)

   
   

   
   
  • 1
  • 2
  • 3

从方法中可看出，只能通过字节写出

outputStream.write("hello".getBytes()); 文本中出现hello
outputStream.write(96)  //文本中出现 a

byte[] bys={97,98,99,100,101};
outputStream.write(bys,1,3); 文本中出现bcd

  • 1
  • 2
  • 3
  • 4
  • 5

如此写出，文本中数据不会换行，不会追加，每次写出都是覆盖原来。

追加：
FileOutputStream outputStream = new FileOutputStream("a.txt",true);
//第二个参数true设置为可追加。

 
 

 
 
  • 1
  • 2
换行 \n\r ：
for (int i = 0; i <5 ; i++) {
    outputStream.write("hello".getBytes());
    outputStream.write("\n\r".getBytes());
    }

 
 

 
 
  • 1
  • 2
  • 3
  • 4

注：用完流一定要记得关闭。

outputStream.close();

 
 

 
 
  • 1

完整示例：

package io2;

import java.io.FileOutputStream;
import java.io.IOException;
/**

  • new FileOutputStream(“a.txt”,true); 第二个参数true，设置为写入的数据拼接在尾部
  • \n\r 换行
  • write(bys,1,3); 写入字节数组
    /
    public class out {
    public static void main(String args[]){
    FileOutputStream outputStream = null;
    try {
    //FileOutputStream fos = new FileOutputStream(file);
    outputStream = new FileOutputStream(“a.txt”,true);
    /
    * 创建字节输出流对象了做了几件事情：
    * A:调用系统功能去创建文件
    * B:创建outputStream对象
    * C:把foutputStream对象指向这个文件
    */

// for (int i = 0; i <5 ; i++) {
// outputStream.write(“hello”.getBytes());
// outputStream.write("\n\r".getBytes());
// }
byte[] bys={97,98,99,100,101};
outputStream.write(bys,1,3);
} catch (IOException e) {
e.printStackTrace();
}
finally {
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

InputStream的子类FileInputStream

FileInputStream的构造方法
FileInputStream(File file)
FileInputStream(String name)

 
 

 
 
  • 1
  • 2

推荐第二种构造方法：

 FileInputStream inputStream = new FileInputStream("a.txt");

 
 

 
 
  • 1
把刚才写的数据现在读取到控制台：
public int read()
public int read(byte[] b)

 
 

 
 
  • 1
  • 2

第一个read是读一个字节，第二个read是读一个字节数组。

//读一个字节
int by = 0;
while ((by=inputStream.read())!=-1){
      System.out.println((char)by);
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5

读到没数据了就返回-1，这个用来判断是否读完。

//读一个字节数组，一般是1024大小
int len = 0 ;
byte[] bys = new byte[1024];
while ((len = inputStream.read(bys)) != -1) {
    System.out.println(new String(bys,0,len));
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

两个read的返回值略有不同，read()返回读取的字节，读到末尾返回-1，read(byte[] b)返回的是读到的字节个数，读到的字节放在了bytes字节数组里，读到末尾没数据了返回-1。

两种读取方式图解：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yv0oyKLy-1603813798619)(http://p5kllyq5h.bkt.clouddn.com/174401.jpg)]

同样的用完了流，也要及时的关闭，以防占用内存。

inputStream.close();

 
 

 
 
  • 1

完整示例：

建议以字节数组的方式读取数据。

package io2;

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

/**

  • Create by stefan

  • Date on 2018-05-27 23:00

  • Convertion over Configuration!
    /
    public class input2 {
    public static void main(String args[]){
    FileInputStream inputStream = null;
    try {
    inputStream = new FileInputStream(“a.txt”);
    // byte[] bys = new byte[4];
    // int len = inputStream.read(bys);
    // System.out.println(new String(bys)); //bcd
    // System.out.println(len); //3
    // System.out.println(inputStream.read(bys)); //-1
    int len = 0 ;
    byte[] bys = new byte[1024];
    while ((len = inputStream.read(bys)) != -1) {
    System.out.println(new String(bys,0,len));
    }
    /    *
    * public String(byte bytes[]) {
    this(bytes, 0, bytes.length);
    }
    */

     } catch (IOException e) {
     e.printStackTrace();
 }finally {
     try {
         inputStream.close();
     } catch (IOException e) {
         e.printStackTrace();
     }
 }

    }
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

字节流复制文件

利用输入流读取一个文件里的字节，再利用输出流将读取到的字节写出到另一个文件中（不存在会自动创建）

package io2;

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

/**

  • Create by stefan

  • Date on 2018-05-27 23:19

  • Convertion over Configuration!
    */
    public class copy {
    public static void main(String args[]) throws IOException {
    FileInputStream inputStream = new FileInputStream(“E:\huge1.jpg”);
    FileOutputStream outputStream = new FileOutputStream(“E:\古月.jpg”);

     byte[] bytes = new byte[1024];
 int len = 0;
 while ((len=inputStream.read(bytes)) != -1) {
     outputStream.write(bytes,0,len);
 }
 inputStream.close();
 outputStream.close();

    }
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

注：复制文本、图片、mp3、视频等的方式一样。

字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果。

java本身在设计的时候，也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流。

字节缓冲输出流
BufferedOutputStream
字节缓冲输入流
BufferedInputStream

 
 

 
 
  • 1
  • 2
  • 3
  • 4
BufferedOutputStream
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt",true));
bos.write("hello world".getBytes());
bos.close();

 
 

 
 
  • 1
  • 2
  • 3
BufferedInputStream
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
byte[] bytes = new byte[1024];
int len = 0;
while ((len=bis.read(bytes)) != -1) {
    System.out.println(new String(bytes,0,len));
}
bis.close();

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

注：

  • 成员方法与字节流基本一样，字节缓冲流的作用就是提高输入输出的效率。
  • 构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
  • 为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。
复制文件的升级：
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\modern-java.pdf"));
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf"));
int len = 0;
byte[] bytes =new byte[1024];
while ((len=bis.read(bytes)) != -1) {
    bos.write(bytes,0,len);
}
bis.close();
bos.close();

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

测试：四种复制文件的效率高低

package io2;

import java.io.*;

/**
*

  • 测试复制的时间

  • Create by stefan

  • Date on 2018-05-28 10:28

  • Convertion over Configuration!
    */
    public class copy2 {
    //一个字节一个字节的复制，耗时22697毫秒
    public static void fun() throws IOException {
    FileInputStream fis = new FileInputStream(“F:\汤包\慕课大巴\modern-java.pdf”);
    FileOutputStream fos = new FileOutputStream(“E:\modern-java.pdf”);
    int by = 0;
    while ((by=fis.read()) != -1) {
    fos.write(by);
    }
    fis.close();
    fos.close();
    }
    //1024字节数组复制 耗时63毫秒
    public static void fun1() throws IOException {
    FileInputStream fis = new FileInputStream(“F:\汤包\慕课大巴\modern-java.pdf”);
    FileOutputStream fos = new FileOutputStream(“E:\modern-java.pdf”);
    int len = 0;
    byte[] bytes =new byte[1024];
    while ((len=fis.read(bytes)) != -1) {
    fos.write(bytes,0,len);
    }
    fis.close();
    fos.close();
    }
    // 一个字节一个字节复制，但是用了缓冲流 耗时64毫秒
    public static void fun2() throws IOException {
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(“E:\modern-java.pdf”));
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(“F:\汤包\慕课大巴\modern-java.pdf”));
    int by = 0;
    while ((by=bis.read()) != -1) {
    bos.write(by);
    }
    bis.close();
    bos.close();
    }
    // 1024字节数组复制并用了缓冲流 耗时7毫秒
    public static void fun3() throws IOException {
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(“E:\modern-java.pdf”));
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(“F:\汤包\慕课大巴\modern-java.pdf”));
    int len = 0;
    byte[] bytes =new byte[1024];
    while ((len=bis.read(bytes)) != -1) {
    bos.write(bytes,0,len);
    }
    bis.close();
    bos.close();
    }

    public static void main(String args[]) throws IOException {
    long t1 = System.currentTimeMillis();
    fun3();
    long t2 = System.currentTimeMillis();
    System.out.println(t2-t1);
    }

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68

经测试结果显示：
1024字节数组复制并用了缓冲流 的方式效率最高。

以上是本人学习笔记整理，重温java经典，欢迎各位同道中人批评指正。

Java架构师之路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java.io.OutputStream和InputStream详解
Brilliant_yjj的博客
11-28 788
IO流的分类： 按照流的方向可以分为：输入流和输出流； 按照流的数据类型来分：字节流和字符流； 字节流->输入流：InputStream 输出流：OutputStream 字符流-> 输入流：Reader 输出流：Writer 一切皆字节：计算机中的任何数据（文本、图片、视频、音乐）都是以二进制的形式存储的，在数据传输时，也都是以二进制的形式存储的，后续学习的任何流，在传输时底层都是二进制。 Java.io.FileOutputStream 是OutputStream用的最多的一个
Java : 数据流 InputStream 和 OutputStream
qq_30207527的博客
12-18 325
一、文件 输入输出流 ：FileInputStream 与  FileOutputStream     1、FileInputStream、FileOutputStream 顾名思义 属于文件流，用于 文件流操作。继承 InputSream，outputSream，属于InputSream,outputSream     2、用法          //读取一个字符 // ...
java -- IO流之字节流
xiaoyaoLee1955
02-03 453
Java类库中的IO类，可以从不同的角度将其进行不同的分类。比如按数据的流向可分分为输入流和输出流；按数据处理单位的不同，又可将其分为字节流和字符流。但不管怎样分，其本质都是一样的。本人更倾向将其分成字节流和字符流，再在字节流和字符流里面讨论输入流和输出流。  必须要知道的的是，输入输出是相对于“程序”来说的，从物理学方面来讲就是以“程序”为参照物：从程序中流向外部的数据就叫“输出流
Java字节流基础详解（InputStream/OutputStream）
墨辰JC的博客
01-12 5144
在Java中，字节流一般适用于处理字节数据（诸如图片、视频），InputStream/OutPutStream为字节流基类（超类或父类），字节流的类通常以stream结尾。创建一个文件输出流写入指定的 File对象表示的文件。FileOutputStream流是指文件字节输出流，专用于输出原始字节流如图像数据等，其继承OutputStream类，拥有输出流的基本特性。读取E盘下的hello.txt文本，此时文本的内容为：h e l l o , w o r l d （这是我文件的内容，可自定义）
Java IO流 InputStream(字节输入流) & OutputStream(字节输出流)
天行健 君子以自强不息，地势坤 君子以厚德载物。
08-04 5262
1. InputStream(字节输入流) 我们看到的具体的某一些管道，凡是以InputStream结尾的管道，都是以字节的形式向我们的程序输入数据。 继承自InputStream的流都是用于向程序中输入数据，且数据的单位为字节（Byte）=> (8bit)；下图中深色为节点流，浅色为处理流。 InputStream的基本方法 read()方法是一个字节一个字节地往外读，每读取一个字节，就处理一个字节。read(byte[] buffer)方法读取数据时，先把读取到的数据填满这个byte
JAVA 中InputStream和OutputStream的基本使用
NiKaBoy的博客
09-25 5668
读取字节文件到buf内存中，值得注意的是会中文乱码，所以需要自己转GBK或者UTF-8，当buf过小的时候会分多次读入到buf中，就帮我解决了这个临时数据存储的问题，不需要手动创建一个临时的数据缓存，同提供了一行一行去读取数据。上面的代码我都是手动去创建一个buf缓存内存，去存储临时数据流，比较麻烦，而。方法可以返回文件长度，但是如果文件过大，会占用很大的内存，所以慎用。java IO流，对数据流进行输入输出，其中输入流的抽象类为。，这字符流很好的解决了中文乱码的问题。才能将数据流写出到指定文件。
Java InputStream 和OutputStream
yKan_SF
03-01 600
一、OutputStream用法：     1、OutputStream类是Java IO API中所有输出流的基类。子类包括BufferedOutputStream，FileOutputStream等等 BufferedOutputStream： 提供了缓冲功能的输出流，在写出完成之前要调用flush来保证数据的输出。 DataOutputStream: 数
浅谈java IO流——四大抽象类
08-26
在java中，四大抽象类是IO流的基础，它们分别是InputStream、OutputStream、Reader、Writer。这四大抽象类是java IO流的核心，我们在编程中经常使用它们来实现输入输出操作。 一、InputStream InputStream是字节...
Java基础核心+InputStream输入流+OutputStream输出流
04-23
本教程将聚焦于Java的基础核心，以及两个重要的I/O（输入/输出）流类——InputStream和OutputStream，它们在文件操作中扮演着关键角色。 InputStream和OutputStream是Java.io包下的抽象类，是所有字节流的基类。...
Java中String类和IO流——学习小结
12-22
Java的IO库提供了许多类，如InputStream、OutputStream、Reader、Writer等，它们各自处理字节流和字符流，支持缓冲、转换、过滤等功能，使得数据的读写更加高效和灵活。学习如何结合使用String类和IO流，可以有效地...
java IO流学习笔记——(1)文件字节流
12-21
java IO流学习笔记——(1) IO流总述 • 输入流：数据源到程序(InputStream、Reader读进来) • 输出流：程序到目的地(OutputStream、Writer写出去) 流分类 : • 节点流：可以直接从数据源或目的地读写数据 • 处理...
java 使用IO流实现文件的复制
06-13
字节流又分为输入流（InputStream）和输出流（OutputStream），字符流则有Reader和Writer。 文件复制的基本过程涉及到两个主要步骤：读取源文件和写入目标文件。这里我们以字节流为例，使用`java.io....
[Java] 文件 , InputStream, OutputStream
pawlaibd的博客
03-30 709
针对文件的读写操作
AS中java.lang.NullPointerException: Attempt to invoke virtual method on a null object reference
天气
02-14 844
E/AndroidRuntime: FATAL EXCEPTION: main Process: com.skypan.travelsystem, PID: 23801 java.lang.NullPointerException: Attempt to invoke virtual method ‘void com.skypan.travelsystem.DataStructure.Point.setPoint_name(java.lang.String)’ on a null object refere
Attempt to invoke virtual method ‘…’ on a null object reference
weixin_45681602的博客
10-16 7407
Attempt to invoke virtual method ‘…’ on a null object reference 遇到了两次这样的提示，逐个解析之。 一、只声明，未创建。如下代码： public class SortMallFragment extends Fragment { ... ... private ArrayList<Fragment> rightFragments; @Override public void onViewC
android 服务器201,【报Bug】h5+app 网络请求 状态码返回201会报错200不会
weixin_33273250的博客
05-26 1102
Android 系统 h5+app request接口 GET 请求 服务器返回状态码201会出错 (h5 小程序不会出错){"data":"Attempt to invoke virtual method 'int java.io.InputStream.available()' on a null object reference","statusCode":201,"header":{"X-...
java 输入输出流详解_Java输入输出(io)流详解、图解
weixin_42525264的博客
02-13 355
stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。在Java的IO中，所有的stream(包括Inputstream和Out stream)都包括两种类型：(1)字节流表示以字节为单位从stream中读取或往stream中写入信息，即io包中的inputstream类和outputstream类的派生类。通常用来读取二进制数据，如图象和声音。(2)字符流以Unicod...
输入输出流及其17个类（一）
qq_51810428的博客
08-18 1321
另一方面，程序在处理数据后，可能需要将处理的结果写入到永久的存储媒介中或传送给其他的应用程序，这就需要使用输出流。程序在运行期间，可能需要从外部的存储媒介或其他程序中读入所需要的数据，这就需要使用输入流。虽然I/O流经常与磁盘文件存取有关，但是源和目的地也可以是键盘、内存或显示器窗口。返回文件的长度，单位为字节, 如果文件不存在，则返回 0L。返回此对象表示的文件的相对路径名。返回此对象表示的文件的绝对路径名。返回此对象表示的文件或目录的名称。创建名称的空文件，不创建文件夹。删除此对象指定的文件或目录。..
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 587
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java字节流读取详解：InputStream基础
详细列举了`java.io`包下的核心I/O类，如`InputStream`系列（如`ByteArrayInputStream`、`FileInputStream`等）、`OutputStream`系列（如`ByteArrayOutputStream`、`FileOutputStream`等），以及读写器类`Reader`和`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值