InputStream字节输入流、OutputStream字节输出流

最新推荐文章于 2024-08-03 09:18:28 发布
最新推荐文章于 2024-08-03 09:18:28 发布
阅读量1.1k 收藏 26
点赞数 36
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64975807/article/details/137511569
版权

InputStream字节输入流

        InputStream就是Java标准库提供的最基本的输入流。它位于java.io这个包中。注意，InputStream并不是一个接口，而是一个抽象类，它是所有输入流的超类。

FileInputStream文件输入流

        FileInputStream是InputStream的一个子类，它是从文件流中读取数据的。

//创建一个基于读取文件的方式的输入流
try(FileInputStream fi=new FileInputStream("D:\\IO流\\21级.txt")){
    //读取方式一：
    //每次读取一个字节数据，读取至文件末尾时返回-1
    //字节数据范围：0-255
    int data1=in.read();
	int data2=in.read();
	int data3=in.read();
    //....
    System.out.println(data1);
	System.out.println(data2);
	System.out.println(data3);
	//...
} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
}

输出结果：

230
157
168

.....

-1

//创建一个基于读取文件的方式的输入流
try(FileInputStream fi=new FileInputStream("D:\\IO流\\21级.txt")){
    //读取方式二：通过循环，读取所有字节数据
    int data=-1;
    //当文件不为空时
    while((data=in.read)!=-1){
        System.out.println(data);
    }
} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
}

输出结果：

230
157
168
229
157
164
13
10
229
188
160
230
150
135 

//写法二：
//创建一个基于读取文件的方式的输入流
try(FileInputStream fi=new FileInputStream("D:\\IO流\\21级.txt")){
    //读取方式1：每次读取若干个数据，并保存至一个数组
    byte[] buff1=new byte[25600];
    int len1=in.read(buff1);
    System.out.println("本次读取到的内容："+Arrays.toString(buff1));
	System.out.println("本次读取到的长度："+len1);
} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
}

  输出结果：

本次读取到的内容：[-26, -99, -88, -27, -99, -92, 13, 10, -27, -68, -96, -26, -106, -121, -24, -117, -79, 13, 10, -24, -94, -127, -24, -119, -70, -23, -72, -93, 13, 10, -27, -68, -96, -25, -108, -100, -25, -108, -100, 13, 10, -24, -76, -70, -28, -67, -77, -25, -111, -74, 13, 10, -27, -68, -96, -26, -106, -121, -27, -115, -114, 13, 10, -23, -97, -87, -28, -67, -77, -25, -111, -74, 13, 10, -26, -99, -88, -25, -101, -68, -25, -101, -68, 13, 10, -24, -75, -75, -24, -116, -71, 13, 10, -24, -117, -105, -23, -108, -112, -27, -88, -100, 13, 10, -23, -67, -112, -23, -97, -84, -27, -80, -118, 13, 10, -23, -125, -99, -24, -117, -105, -24, -117, -105, 13, 10, -24, -116, -125, -28, -70, -102, -28, -72, -67, 13, 10, -26, -99, -88, -26, -106, -121, -25, -112, -90, 13, 10, -24, -82, -72, -27, -88, -100, 13, 10, -28, -69, -93, -24, -74, -123, -25, -66, -92, 13, 10, -27, -68, -96, -25, -99, -65, -26, -77, -67, 13, 10, -27, -68, -96, -23, -104, -65, -25, -102, -124, 13, 10, -24, -75, -75, -28, -66, -99, -27, -87, -73, 13, 10, -23, -83, -113, -28, -70, -102, -26, -91, -96, 13, 10, -23, -103, -120, -23, -71, -113, -24, -66, -119, 13, 10, -26, -99, -88, -26, -128, -99, -27, -67, -92, 13, 10, -27, -115, -85, -26, -126, -90, -28, -67, -77, 13, 10, -23, -103, -120, -27, -115, -102, -24, -65, -100, 13, 10, -27]
本次读取到的长度：256

//写法二：
//创建一个基于读取文件的方式的输入流
try(FileInputStream fi=new FileInputStream("D:\\IO流\\21级.txt")){
    //读取方式二：每次读取每次读取128个数据
	byte[] buff2=new byte[128];
    int len2=0;
    while((len2=in.read(buff2))>0) {	
    System.out.printf("本次读取到%d个字节：%s\n",len2,
                                Arrays.toString(buff2));				
	}
} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
}

输出结果：

本次读取到128个字节：[-26, -99, -88, -27, -99, -92, 13, 10, -27, -68, -96, -26, -106, -121, -24, -117, -79, 13, 10, -24, -94, -127, -24, -119, -70, -23, -72, -93, 13, 10, -27, -68, -96, -25, -108, -100, -25, -108, -100, 13, 10, -24, -76, -70, -28, -67, -77, -25, -111, -74, 13, 10, -27, -68, -96, -26, -106, -121, -27, -115, -114, 13, 10, -23, -97, -87, -28, -67, -77, -25, -111, -74, 13, 10, -26, -99, -88, -25, -101, -68, -25, -101, -68, 13, 10, -24, -75, -75, -24, -116, -71, 13, 10, -24, -117, -105, -23, -108, -112, -27, -88, -100, 13, 10, -23, -67, -112, -23, -97, -84, -27, -80, -118, 13, 10, -23, -125, -99, -24, -117, -105, -24, -117, -105, 13, 10, -24, -116]
本次读取到128个字节：[-125, -28, -70, -102, -28, -72, -67, 13, 10, -26, -99, -88, -26, -106, -121, -25, -112, -90, 13, 10, -24, -82, -72, -27, -88, -100, 13, 10, -28, -69, -93, -24, -74, -123, -25, -66, -92, 13, 10, -27, -68, -96, -25, -99, -65, -26, -77, -67, 13, 10, -27, -68, -96, -23, -104, -65, -25, -102, -124, 13, 10, -24, -75, -75, -28, -66, -99, -27, -87, -73, 13, 10, -23, -83, -113, -28, -70, -102, -26, -91, -96, 13, 10, -23, -103, -120, -23, -71, -113, -24, -66, -119, 13, 10, -26, -99, -88, -26, -128, -99, -27, -67, -92, 13, 10, -27, -115, -85, -26, -126, -90, -28, -67, -77, 13, 10, -23, -103, -120, -27, -115, -102, -24, -65, -100, 13, 10, -27]
本次读取到60个字节：[-120, -104, -28, -67, -77, -23, -99, -103, 13, 10, -24, -75, -75, -25, -66, -114, -25, -66, -92, 13, 10, -27, -68, -96, -26, -76, -117, -26, -76, -117, 13, 10, -24, -76, -70, -27, -68, -96, -27, -82, -127, 13, 10, -27, -68, -96, -27, -106, -122, 13, 10, -23, -69, -114, -23, -111, -85, -23, -101, -88, 10, -24, -75, -75, -28, -66, -99, -27, -87, -73, 13, 10, -23, -83, -113, -28, -70, -102, -26, -91, -96, 13, 10, -23, -103, -120, -23, -71, -113, -24, -66, -119, 13, 10, -26, -99, -88, -26, -128, -99, -27, -67, -92, 13, 10, -27, -115, -85, -26, -126, -90, -28, -67, -77, 13, 10, -23, -103, -120, -27, -115, -102, -24, -65, -100, 13, 10, -27]

        在计算机中，类似文件、网络端口这些资源，都是由操作系统统一管理的。应用程序在运行过程中，如果使用了输入输出流对文件进行了读写，完成后要及时关闭，以便于让操作系统把资源释放掉，否则程序占用的资源会越来越多，不但白白占用内存，还影响其他应用程序的运行。所以我们可以调用close()方法手动关闭，也可以将其放入try块中自动进行关闭。 

BufferedInputStream缓冲输入流

        BufferedInputStream是一个自带缓冲区的输入流，它继承自FilterInputStream。它的本质是通过一个内部缓冲区数组实现的，例如在新建某输入流对应的BufferedInputStream后，我们通过read()方法读取输入流中的数据时，BufferedInputStream会将该输入流的数据分批的填到缓冲区中，每当缓冲区的数据被读取完之后，输入流会再次填充缓冲区，如此反复，直到我们读取完输入流中的数据

FileInputStream fis=new FileInputStream();
//每次read方法，都会产生磁盘的读取
fis.read();

BufferedInputStream in=new BufferedInputStream();
//每次read方法，先在缓冲区读取，如果读取完毕，则统一访问磁盘，进行内容填充
in.read();
//BufferedInputStream可以减少对对磁盘的访问次数
try(BufferedInputStream in=new BufferedInputStream(
    new FileInputStream("D:\\IO流") )){
        byte[] buff2=new byte[128];//用来存储每次读取到的字节数组
        int len2=0;//每次读取到的字节数组的长度
        while((len2=in.read(buff2))>0) {	
		    System.out.printf("本次读取到%d个字节：%s\n",len2,
                                        Arrays.toString(buff2));
		}
} catch (FileNotFoundException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

        BufferedInputStream的作用是为其他输入流提供缓冲功能。创建BufferedInputStream时，我们会通过它的构造函数指定某个输入流为参数。BufferedInputStream会将该输入流数据分批读取，每次读取一部分到缓冲中，操作完缓冲区中的这部分数据之后，再从输入流读取下部分的数据。

OutputStream字节输出流

        OutputStream和InputStream一样，都是一个抽象类，它有一个最重要的方法就是write(int b)方法，这个方法虽然传入的参数是一个int整数，但是只会写入一个字节，OutputStream和InputStream均是以字节为单位进行输入输出的。

FileOutputStream文件输出流

        当我们要实现将指定目录文件读取并重新写入到一个新的目录时，我们既可以一次性将指定目录文件读取完毕再一次性写入，但是这样效率较低。

//完成对指定图片的复制
//写法1：读完再写
try {
    byte[] image=Files.readAllBytes(Paths.get("D:\\美女1.jpg"));
    //创建文件输出流,将读取的图片复制到新地址。
    try(FileOutputStream out=new FileOutputStream("D:\\美女2.jpg")){
        out.write(image);
    }
}catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

        我们也可以采用“边读边写”的方式，先将读取出的数据放入一个指定长度的字节数组，一旦这个数组被填满，就会将此数组中的内容写入，而不是等全部内容被读取完后再写入。这样效率更高。

//写法2：边读边写
try (FileInputStream in = new FileInputStream("D:\\大美女1.jpg");
        FileOutputStream out= new FileOutputStream("D:\\美女1.jpg");){
      byte[] buff=new byte[128];
      int len=0;
      while((len=in.read(buff))>0) {
        out.write(buff,0,len);
      }
}catch (FileNotFoundException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

BufferedStream缓冲输出流

        BufferedStream主要是里面包含了一个8192个字节的缓冲区，new BufferedStream(OutputStream out)这个构造方法默认分配的就是一个8192个字节的byte[]数组（即缓冲区），如果要自己指定缓冲区的大小时，可以调用new BufferedStream(OutputStream out,int size)这个构造方法。

//BufferedOutputStream ：边读边写
try(BufferedInputStream bis=new BufferedInputStream(
        new FileInputStream("D:\\大美女1.jpg"));
    BufferedOutputStream bos=new BufferedOutputStream(
        new FileOutputStream("D:\\IO流\\美女1.jpg"))){
    byte[] buff=new byte[128];
    int len=0;
    while((len=bis.read(buff))>0) {
		bos.write(buff,0,len);
	}
} catch (FileNotFoundException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

小羊瑞士
关注
  • 36
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
流与文件（一）：InputStream和OutputStream
qq_35689573的博客
02-16 1462
相对于内存来说，从文件或网络连接中读取数据到内存称为输入流（InputStream和Reader），从内存中读取数据往文件中写称为输出流（OutputStream和Writer）。其中InputSream和OutputStream针对字节流（8bit）,Reader和Writer针对字符流（2个字节）。所以一般纯文本可以用字符流来处理，如果含有图片、视频等一些非文字的流数据文件就必须按字节流来处理...
字节输出流：OutputStream
qq_43618208的博客
05-07 506
字节的数据是以byte类型为主实现的操作，在进行字节内容输出的时候可以使用OutputStream类完成，类的基本定义： public abstract class OutputStream extends Object implements Closeable,Flushable 首先可以发现这个类实现了两个接口，于是基本定对应关系如下： Closeable Flushable ...
深入剖析Java中的输入输出流：InputStream与OutputStream的精髓解读
程序猿小样的博客
10-19 1659
在计算机编程领域，文件和数据的输入输出是开发中常见的需求。Java作为一门强大的编程语言，提供了丰富的输入输出流（IO）操作功能，使得开发者可以轻松地处理各种数据源，包括文件、网络连接、内存等。本文将深入探讨Java中的输入输出流，着重介绍InputStream和OutputStream的原理、使用方法以及常见应用场景，帮助读者更好地理解和运用Java中的IO操作。希望通过本文的介绍，读者能够更好地掌握Java中InputStream与OutputStream的使用，为今后的开发工作提供有力支持。
java中InputStream, OutputStream 的用法
最新发布
westdjjdjdk的博客
08-03 738
文件操作内容有很多，比如打开文件，关闭文件在java中允许一种方法是为了防止我们打开过多的文件导致指定进程描述符表长度不够实用导致程序出现问题，因为每打开一个文件，都需要消耗制定进程描述符表上的一个项文件描述符表的长度是有限的（不同的系统不一样，也是可以配置的）。这种方法的结果同只有一个参数的方法作用效果除了变异量的差别其他的并无二异，方法是从0偏移量为0开始存储的所以，这里第一次直接将文本中的内容放到buf数组当中，第二次n等于-1循环停止，过程结束；2，文件内容操作，流对象。
java InputStream和OutputStream
weixin_34232363的博客
12-21 99
  InputStream类型 类 功能 构造器参数 如何使用 ByteArrayInputStream 允许将内存的缓冲区当做InputStreams使用 缓冲区，字节将从中取出 作为一种数据源：将其与FilterInputStream对象相连以提供有用接口 StringBufferInputStream 将String转换成...
InputStream 和OutputStream
开发时随笔
03-06 390
　1．InputStream ◇ 从流中读取数据： int read( ); //读取一个字节，返回值为所读的字节 int read( byte b[ ] ); //读取多个字节，放置到字节数组b中，通常 //读取的字节数量为b的长度，返回值为实际 //读取的字节的数量 int read( byte b[ ], int off, int len ); //读取len个字节，放置 ...
InputStream输入流和OutputStream输出流
m0_53193630的博客
05-16 1474
InputStream这个抽象类定义的最重要的方法就是int read（），这个方法会读取输入流的下一个字节，并返回字节表示的int值（0-255），如果已读到末尾，返回-1表示不能继续读取了。这个方法会写入到一个字节到输出流，需要注意的是，虽然传入的是int参数，单只会写入一个字节，即只写入int最低8位表示字节的部分。缓存输出流里面包含了一个8192字节的缓冲区，new这个构造函数默认分配的就是8192个字节的byte[ ]数组（即缓冲区）（多次调用会按顺序依次读取）返回-1表示读取完毕。
InputStream和OutputStream
sspudding
03-20 4018
一、InputStream
关于字节输入流InputStream的使用
Hsssc的博客
07-12 635
FileInputStream类称为文件输入流，继承于InputStream类，是进行文件读操作的最基本类；它的作用是将文件中的数据输入到内存中，我们可以利用它来读文件；它属于字节流。 import java.io.*; public class Test2 { public static void method(File file) { try (InputStream inputStream=new FileInputStream(file)){
Java基础核心+InputStream输入流+OutputStream输出流
04-23
InputStream代表字节输入流，而OutputStream则表示字节输出流。在Java中，文件操作通常涉及到数据的读取和写入，这两个类及其子类就提供了这样的功能。 InputStream主要用于读取数据，常见的子类有FileInputStream...
将输出流OutputStream转化为输入流InputStream的方法
08-07
在实际开发中，`PipedOutputStream`和`PipedInputStream`也可以用来实现输出流和输入流之间的连接，它们之间可以通过管道进行数据传输，但这种方式相对复杂，适用于更高级的同步和异步操作。 总结，将`OutputStream...
BufferedInputStream 比 InputStream 性能点（实验数据报告）
12-21
文本的保存（写入磁盘的时候），字节流 ： BufferedInputStream 比 InputStream 性能会比较好点（本人测试过，有实验数据）
Java基础-day12-InputStream字节输入流·Reader 字符输入流·字节输出流OutputStream·字符输出流Writer·IO的继承结构
weixin_58678891的博客
06-21 317
InputStream字节输入流·Reader 字符输入流·字节输出流OutputStream·字符输出流Writer·IO的继承结构
I/o流（字节输入流inputstream和字节输出流outputstream）
weixin_52318726的博客
11-08 205
1、InputStream、OutputStream是最基本的IO流，它传输的数据基本单位是byte；intread()：读取输入流的下一个byte，返回该byte表示的int值（0~255）。读到末尾，返回-1表示不能继续读了。read( byte[ ] b )：从输入流中读取多个bytes，并将之存入缓冲数组b[ ]中；read( byte[ ] b , int off , int len )：从输出流中off byte处开始读取len bytes到缓冲数组b中；
详解Java的IO流Part1：字节输入流(InputStream)和字节输出流(OutputStream)
"✧treasure mountain✧"
03-06 8955
计算机上数据的传输可以看做是一种数据的流动 按照流动的方向 以内存为基准 分为 输入input 和 输出output 即 流向内存是输入流 流出内存的输出流 流：数据(字符 字节) 1个字符=2个字节 1个字节=8个二进制位 Java中I/O操作是使用 java.io 包下的内容进行输入输出操作 输入也叫做读取数据 将硬盘中的数据读取到内存中使用 输出也叫做作写出数据 将内存中的数据写入到硬盘中...
输入流 输出流 字符串 相互转换
aiyaobucuoo的专栏
01-16 1182
public ByteArrayOutputStream parse(InputStream in) throws Exception { ByteArrayOutputStream swapStream = new ByteArrayOutputStream(); int ch; while ((ch = in.read()) != -1) { swapStream.write(ch);
Java中的OutputStream：字节流与输入输出基础
在Java的输入输出流体系中，与OutputStream相对应的字节输入流是`InputStream`，它的主要方法包括`read()`用于读取字节，`skip()`跳过指定数量的字节，以及同样具备`mark()`、`reset()`用于标记位置并在需要时回溯。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值