Java IO流

最新推荐文章于 2024-01-27 16:24:57 发布
最新推荐文章于 2024-01-27 16:24:57 发布
阅读量87 收藏
点赞数

Java IO流-Reader和Writer

主要用于文本的读取和写入，一般使用的实现类是FileReader和FileWriter；

我们给出一些实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package  com.java1234.chap10.sec04;
 
import  java.io.File;
import  java.io.FileReader;
import  java.io.Reader;
 
public  class  Demo1 {
 
     public  static  void  main(String[] args)  throws  Exception {
         File file= new  File( "C://测试文件.txt" );
         Reader reader= new  FileReader(file);
         char  c[]= new  char [ 1024 ];  // 字符数组
         int  len=reader.read(c);
         reader.close();   // 关闭输入流
         System.out.println( "读取的内容是：" + new  String(c, 0 ,len));
     }
}

直接读取；


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package  com.java1234.chap10.sec04;
 
import  java.io.File;
import  java.io.FileReader;
import  java.io.Reader;
 
public  class  Demo2 {
 
     public  static  void  main(String[] args)  throws  Exception {
         File file= new  File( "C://测试文件.txt" );
         Reader reader= new  FileReader(file);
         char  c[]= new  char [ 1024 ];  // 字符数组
         int  temp= 0 ;
         int  len= 0 ;
         while ((temp=reader.read())!=- 1 ){
             c[len++]=( char )temp;
         }
         reader.close();   // 关闭输入流
         System.out.println( "读取的内容是：" + new  String(c, 0 ,len));
     }
}

一个一个字符读取；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package  com.java1234.chap10.sec04;
 
import  java.io.File;
import  java.io.FileWriter;
import  java.io.Writer;
 
public  class  Demo3 {
 
     public  static  void  main(String[] args)  throws  Exception {
         File file= new  File( "C://测试文件.txt" );
         Writer out= new  FileWriter(file);
         String str= "我爱中华" ;
         out.write(str);   // 将字符串写入输出流
         out.close();   // 关闭输出流
     }
}

写入文件；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package  com.java1234.chap10.sec04;
 
import  java.io.File;
import  java.io.FileWriter;
import  java.io.Writer;
 
public  class  Demo4 {
 
     public  static  void  main(String[] args)  throws  Exception {
         File file= new  File( "C://测试文件.txt" );
         Writer out= new  FileWriter(file, true );
         String str= "我爱中华2" ;
         out.write(str);   // 将字符串写入输出流
         out.close();   // 关闭输出流
     }
}

追加写入；

Java IO流-BufferedInputStream和BufferedOutputStream

带缓冲的输入和输出流；


这里缓冲的概念，就是在A,B之间建立内存缓冲区，读取得快，就先放缓冲区，然后再从缓冲区写入指定目标，和没有缓冲比，效率快很多。


我们给个实例比对下：

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
package  com.java1234.chap10.sec03;
 
import  java.io.BufferedInputStream;
import  java.io.BufferedOutputStream;
import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.io.InputStream;
import  java.io.OutputStream;
 
public  class  Demo6 {
 
     /**
      * 缓冲
      * @throws Exception
      */
     public  static  void  bufferStream() throws  Exception{
         // 定义了一个带缓冲的字节输入流
         BufferedInputStream bufferedInputStream= new  BufferedInputStream( new  FileInputStream( "C://《一头扎进J2SE》V2.0视频笔录2.doc" ));
         // 定义了一个带缓冲的字节输出流
         BufferedOutputStream bufferedOutputStream= new  BufferedOutputStream( new  FileOutputStream( "C://复制的《一头扎进J2SE》V2.0视频笔录2.doc" ));
         int  b= 0 ;
         long  startTime=System.currentTimeMillis();  // 开始时间
         while ((b=bufferedInputStream.read())!=- 1 ){
             bufferedOutputStream.write(b);
         }
         bufferedInputStream.close();
         bufferedOutputStream.close();
         long  endTime=System.currentTimeMillis();   // 结束时间
         System.out.println( "缓冲花费的时间是：" +(endTime-startTime));
     }
     
     /**
      * 非缓冲
      * @throws Exception
      */
     public  static  void  stream()  throws  Exception{
         InputStream inputStream= new  FileInputStream( "C://《一头扎进J2SE》V2.0视频笔录.doc" );  // 定义一个输入流
         OutputStream outputStream= new  FileOutputStream( "C://复制的《一头扎进J2SE》V2.0视频笔录.doc" );
         int  b= 0 ;
         long  startTime=System.currentTimeMillis();  // 开始时间
         while ((b=inputStream.read())!=- 1 ){
             outputStream.write(b);
         }
         inputStream.close();
         outputStream.close();
         long  endTime=System.currentTimeMillis();   // 结束时间
         System.out.println( "非缓冲花费的时间是：" +(endTime-startTime));
     }
     
     public  static  void  main(String[] args) throws  Exception {
         stream();
         bufferStream();
     }
}


把文件从A地址复制到B地址，运行输出：

非缓冲花费的时间是：2368

缓冲花费的时间是：31


我们明显发现 带缓冲的效率高；

Java IO流-InputStream和OutputStream

InputStream是输入流  OutputStream是输出流；

InputStream输入流可以把文件从硬盘读取到内存；

OutputStream输出流可以把文件从内存写入到硬盘；


我们实际使用的都是InputStream和OutputStream的子类；

比如文件操作方面用的是FileInputStream和FileOutputStream；

我们给下实例，视频教程里会详细讲解：

准备工作，我们在C盘建一个txt文件 测试文件.txt

随便加点内容：

QQ鎴浘20170107104246.jpg

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package  com.java1234.chap10.sec03;
 
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.InputStream;
 
public  class  Demo1 {
 
     public  static  void  main(String[] args)  throws  Exception {
         File file= new  File( "C://测试文件.txt" );
         InputStream inputStream= new  FileInputStream(file);   // 实例化FileInputStream
         byte  b[]= new  byte [ 1024 ];
         int  len=inputStream.read(b);
         inputStream.close();  // 关闭输入流
         System.out.println( "读取的内容是：" + new  String(b, 0 ,len));
     }
}

把文件从硬盘读取到内存，并且输出：

运行结果：

读取的内容是：我是人 www.java1234.com


上面那个是定义了固定字节数组 一批读取的，我们现在改进下，获取文件长度，然后定义指定字节数组的长度；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package  com.java1234.chap10.sec03;
 
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.InputStream;
 
public  class  Demo2 {
 
     public  static  void  main(String[] args)  throws  Exception {
         File file= new  File( "C://测试文件.txt" );
         InputStream inputStream= new  FileInputStream(file);   // 实例化FileInputStream
         int  fileLength=( int )file.length();
         byte  b[]= new  byte [fileLength];
         inputStream.read(b);
         inputStream.close();  // 关闭输入流
         System.out.println( "读取的内容是：" + new  String(b));
     }
}

运行结果也一样；


我们再来一种方式 一个字节一个字节读取；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package  com.java1234.chap10.sec03;
 
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.InputStream;
 
public  class  Demo3 {
 
     public  static  void  main(String[] args)  throws  Exception {
         File file= new  File( "C://测试文件.txt" );
         InputStream inputStream= new  FileInputStream(file);   // 实例化FileInputStream
         int  fileLength=( int )file.length();
         byte  b[]= new  byte [fileLength];
         int  temp= 0 ;
         int  len= 0 ;
         while ((temp=inputStream.read())!=- 1 ){
             // 一个字节一个字节读取，放到b字节数组里
             b[len++]=( byte )temp;
         }
         inputStream.close();  // 关闭输入流
         System.out.println( "读取的内容是：" + new  String(b));
     }
}

运行结果还是一样的；



下面是讲下输出流；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package  com.java1234.chap10.sec03;
 
import  java.io.File;
import  java.io.FileOutputStream;
import  java.io.OutputStream;
 
public  class  Demo4 {
 
     public  static  void  main(String[] args)  throws  Exception {
         File file= new  File( "C://测试文件.txt" );
         OutputStream out= new  FileOutputStream(file);
         String str= "你好，我好，大家好，Java好" ;
         byte  b[]=str.getBytes();
         out.write(b);  //  将b字节数组写入到输出流
         out.close();   // 关闭输出流
     }
}

我们把指定文件写入到文件；


上面那种是直接覆盖的，我们再来一个追加的；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package  com.java1234.chap10.sec03;
 
import  java.io.File;
import  java.io.FileOutputStream;
import  java.io.OutputStream;
 
public  class  Demo5 {
 
     public  static  void  main(String[] args)  throws  Exception {
         File file= new  File( "C://测试文件.txt" );
         OutputStream out= new  FileOutputStream(file, true );
         String str= "你好，我好，大家好，Java好" ;
         byte  b[]=str.getBytes();
         out.write(b);  //  将b字节数组写入到输出流
         out.close();   // 关闭输出流
     }
}

BufferedInputStream和BufferedOutputStream

带缓冲的输入和输出流；


这里缓冲的概念，就是在A,B之间建立内存缓冲区，读取得快，就先放缓冲区，然后再从缓冲区写入指定目标，和没有缓冲比，效率快很多。


我们给个实例比对下：

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
package  com.java1234.chap10.sec03;
 
import  java.io.BufferedInputStream;
import  java.io.BufferedOutputStream;
import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.io.InputStream;
import  java.io.OutputStream;
 
public  class  Demo6 {
 
     /**
      * 缓冲
      * @throws Exception
      */
     public  static  void  bufferStream() throws  Exception{
         // 定义了一个带缓冲的字节输入流
         BufferedInputStream bufferedInputStream= new  BufferedInputStream( new  FileInputStream( "C://《一头扎进J2SE》V2.0视频笔录2.doc" ));
         // 定义了一个带缓冲的字节输出流
         BufferedOutputStream bufferedOutputStream= new  BufferedOutputStream( new  FileOutputStream( "C://复制的《一头扎进J2SE》V2.0视频笔录2.doc" ));
         int  b= 0 ;
         long  startTime=System.currentTimeMillis();  // 开始时间
         while ((b=bufferedInputStream.read())!=- 1 ){
             bufferedOutputStream.write(b);
         }
         bufferedInputStream.close();
         bufferedOutputStream.close();
         long  endTime=System.currentTimeMillis();   // 结束时间
         System.out.println( "缓冲花费的时间是：" +(endTime-startTime));
     }
     
     /**
      * 非缓冲
      * @throws Exception
      */
     public  static  void  stream()  throws  Exception{
         InputStream inputStream= new  FileInputStream( "C://《一头扎进J2SE》V2.0视频笔录.doc" );  // 定义一个输入流
         OutputStream outputStream= new  FileOutputStream( "C://复制的《一头扎进J2SE》V2.0视频笔录.doc" );
         int  b= 0 ;
         long  startTime=System.currentTimeMillis();  // 开始时间
         while ((b=inputStream.read())!=- 1 ){
             outputStream.write(b);
         }
         inputStream.close();
         outputStream.close();
         long  endTime=System.currentTimeMillis();   // 结束时间
         System.out.println( "非缓冲花费的时间是：" +(endTime-startTime));
     }
     
     public  static  void  main(String[] args) throws  Exception {
         stream();
         bufferStream();
     }
}


把文件从A地址复制到B地址，运行输出：

非缓冲花费的时间是：2368

缓冲花费的时间是：31


我们明显发现 带缓冲的效率高

Java IO流-Reader和Writer

主要用于文本的读取和写入，一般使用的实现类是FileReader和FileWriter；

我们给出一些实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package  com.java1234.chap10.sec04;
 
import  java.io.File;
import  java.io.FileReader;
import  java.io.Reader;
 
public  class  Demo1 {
 
     public  static  void  main(String[] args)  throws  Exception {
         File file= new  File( "C://测试文件.txt" );
         Reader reader= new  FileReader(file);
         char  c[]= new  char [ 1024 ];  // 字符数组
         int  len=reader.read(c);
         reader.close();   // 关闭输入流
         System.out.println( "读取的内容是：" + new  String(c, 0 ,len));
     }
}

直接读取；


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package  com.java1234.chap10.sec04;
 
import  java.io.File;
import  java.io.FileReader;
import  java.io.Reader;
 
public  class  Demo2 {
 
     public  static  void  main(String[] args)  throws  Exception {
         File file= new  File( "C://测试文件.txt" );
         Reader reader= new  FileReader(file);
         char  c[]= new  char [ 1024 ];  // 字符数组
         int  temp= 0 ;
         int  len= 0 ;
         while ((temp=reader.read())!=- 1 ){
             c[len++]=( char )temp;
         }
         reader.close();   // 关闭输入流
         System.out.println( "读取的内容是：" + new  String(c, 0 ,len));
     }
}

一个一个字符读取；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package  com.java1234.chap10.sec04;
 
import  java.io.File;
import  java.io.FileWriter;
import  java.io.Writer;
 
public  class  Demo3 {
 
     public  static  void  main(String[] args)  throws  Exception {
         File file= new  File( "C://测试文件.txt" );
         Writer out= new  FileWriter(file);
         String str= "我爱中华" ;
         out.write(str);   // 将字符串写入输出流
         out.close();   // 关闭输出流
     }
}

写入文件；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package  com.java1234.chap10.sec04;
 
import  java.io.File;
import  java.io.FileWriter;
import  java.io.Writer;
 
public  class  Demo4 {
 
     public  static  void  main(String[] args)  throws  Exception {
         File file= new  File( "C://测试文件.txt" );
         Writer out= new  FileWriter(file, true );
         String str= "我爱中华2" ;
         out.write(str);   // 将字符串写入输出流
         out.close();   // 关闭输出流
     }
}

追加写入；




heguiliang_123
关注
Java IO流（超详细！）
一只小菜鸡
05-07 6万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
javascript数组
qq_41662119的博客
01-23 113
js数组 1.创建数组的两种方式 var arr = new Array(); var  arr = []; var arr = new Array('你好','我好','大家好，才是真的好。'); var arr = new Array(7)//7代表的是数组的下标数量为7，没有的为空empty； var arr = ['春节过年','不收礼','收礼还收地黄丸']; var ar
javaIO流详解
weixin_46676497的博客
01-27 2538
java常用io流介绍
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
Java io流 详解
m0_68987535的博客
06-11 4775
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
java IO流
D大调奏鸣曲_第七序章_de博客
11-11 8万+
目录 序 一、IO流开篇 1、概念 2、流的分类 3、IO流的作用 4、IO流的使用场景 二、字节流 1、字节流抽象基类 2、字节流写数据 （1）基本步骤 （2）三种方式 （3）两个问题 （4）异常处理 3、字节缓冲流 （1）基本分类&概述 （2）构造方法 （3）代码演示 三、字符流 1、概念 2、分类 （1）字符流体系图 （2）字符输入流（Reader） （3）字符输出流（Writer） 3、字符缓冲流 （1）概念 （2）构造方法 （3）...
Java IO流详解
ss810540895的博客
04-21 1万+
原文 Java IO流详解 1.什么是IO Java中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。 IO又分为流IO（java.io）和块IO(java.nio) Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的
Java IO流的种类
程序员
02-20 3326
Java IO流的种类
JavaIO流：模型
栗筝i的博客
11-24 3804
IO 的字面意思是读/写数据，IO 模型是读/写数据的方式。常用到的读/写数据方式有：同步阻塞 IO、同步非阻塞 IO、IO 多路复用、信号驱动、异步 IO 本篇内容包括：Java IO 与 IO 模型、五种 IO 模型、三种 Java IO 模型。
java IO流之BufferedReader和BufferedWriter
学习笔记，相关教程 分享
04-03 6271
笑霸能看懂的学习笔记
javaIO流javaIO流javaIO流
07-02
Java IO流是Java平台中用于处理输入输出操作的核心机制，它允许程序与各种数据源（如文件、设备、网络）进行交互。Java IO流体系结构是基于“流”的概念，流是一组有序的数据序列，可以是字节流或字符流。Java IO库...
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、...3、JAVA IO流经典代码示例，示例从易到难。代码功能涉及字节、字符、字符串、文本文件、图片、音频、视频。演示错误用法和经典用法。 4、代码的结构可查看README文件。
java IO流将一个文件拆分为多个子文件代码示例
08-28
Java IO流将一个文件拆分为多个子文件代码示例 Java IO流是一个文件流处理的基础组件，它提供了基本的文件读取和写入操作。将一个文件拆分为多个子文件是文件处理中一个常见的需求，例如上传大文件时，可以先分割成...
山东交通学院在江西2020-2024各专业最低录取分数及位次表.pdf
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
西京学院在江西2020-2024各专业最低录取分数及位次表.pdf
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
山西师范大学在江西2020-2024各专业最低录取分数及位次表.pdf
最新发布
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
沈阳工业大学在江西2020-2024各专业最低录取分数及位次表.pdf
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
Android应用设计与Java IO流
"Android应用程序设计I-Java IO流" 在Android应用程序设计中，理解并掌握Java的IO流是至关重要的，因为这关乎到如何在应用中有效地读取、写入和处理数据。Java IO流提供了在不同数据源之间传输数据的机制，包括设备...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值