JAVA中IO流详解

最新推荐文章于 2024-03-05 10:00:45 发布
最新推荐文章于 2024-03-05 10:00:45 发布
阅读量276 收藏 2
点赞数
分类专栏： java基础知识
原文链接：https://www.cnblogs.com/ywzbky/p/10692238.html
版权

IO流：数据传输是需要通道的，而IO流就是数据传输的通道。

　　　　IO流可以形象的比喻为运送货物的传输带。

IO流的分类：

　　①根据操作的数据类型的不同可以分为 ：字节流与字符流。

　　②根据数据的流向分为：输入流与输出流，程序（内存）作为参照物，程序从外部读取称为输入（Input），程序向外部写数据成为输出（Output）。

字节输入流：

    父类：InputStream

　常用的字节输入流：FileInputStream

1.FileInputStream

   ①构造方法：

　　FileInputStream（File）

　　FileInputStream（String  filename）

2.常用方法　

　　①read　：读取一个字节，返回该字节的值，如果到达文件的末尾，则返回-1。需要注意：read()方法和迭代器一样，会自动下移的

　　②read（byte[ ]）从输入流中读取至多一个数组长度的内容，到达文件末尾，则返回-1。　　　　

  • 数组称为缓冲区数组，大小一般取值为1024的整数倍。
  • 转换为字符时，使用String（byte [ ]   bytes，int offset，int length）
  • available（）没有读取的剩余字节数，如果该文件还从未被读取，就返回该文件的长度。
  • close（） 关闭流并释放资源

字节输入流代码演示：

其中1.txt位于本项目的根目录下：内容为"abcdefg"

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

public class Demo6 {

    public static void main(String[] args) throws IOException{
        File file=new File("1.txt");     //新建一个文件的抽象路径
        FileInputStream fis=new FileInputStream(file);  
        int result=fis.read();
        System.out.println(result);

    }

}

 程序执行的结果为97，因为读取的a的ASCII码值

字节输入流的循环读取：

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

public class Demo7 {

    public static void main(String[] args) throws IOException{
        File file =new File("1.txt");
        FileInputStream fis=new FileInputStream(file);
        int result;
        while((result=fis.read())!=-1) {
            System.out.print(result+"\t");
        }
        

    }

}

 打印了a到g的ASCII码值

字符流的读取方法：

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

public class Demo8 {

    public static void main(String[] args) throws IOException{
        File file =new File("1.txt");
        FileInputStream fis=new FileInputStream(file);
        byte[] bt=new byte[1024];
        int count;
        while((count=fis.read(bt))!=-1) {
            String string =new String(bt,0,count);
            System.out.println(string);
        }
    }
}

输出结果

 

下面可以用同样的文件来比较字节输入流和字符输入流的读取速度：

文件是一张格式为png图片

先是字节输入流的读取速度

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

public class Demo9 {

    public static void main(String[] args) throws IOException{
        File file =new File("D:\\Java代码\\123.png");
        FileInputStream fis=new FileInputStream(file);
        int count;
        long start=System.currentTimeMillis();
        while((count=fis.read())!=-1) {
            System.out.println(count);
        }
        long end=System.currentTimeMillis();
        System.out.println("======下面是所用的时间======");
        System.out.println(end-start);
    }

}

结果如下：

下面是字符输入流：

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

public class Demo10 {

    public static void main(String[] args) throws IOException {
        File file=new File("D:\\Java代码\\123.png");
        FileInputStream fis=new FileInputStream(file);
        byte[] bt=new byte[1024];
        int count;
        long start=System.currentTimeMillis();
        while((count=fis.read(bt))!=-1) {
            System.out.println(count);
        }
        long end=System.currentTimeMillis();
        System.out.println("======下面是所用的时间======");
        System.out.println(end-start);
    }
}

结果如下：

 

字节输入流读取文件花费了760毫秒，而字符输入流读取文件花费了3毫秒，由此可见，字符输入流的速度要比字节输入流更快。

 

文件字节输出流：

字节输出流：OutputStream  是所有输出流的超类

常用子类：FileOutputStream  文件字节输出流

构造方法：

　　  FileOutputStream（File file） /FileOutputStream（String name）

　　注意：如果父目录不存在，会报FileNotFoundException异常，如果父目录存在，会创建一个新的文件，如果此时已经有文件存在，会覆盖原文件

　　 FileOutputStream(File file,boolean flag)/FileOutputStream(String name,boolean flag)

　　注意:如果当前文件需要从文件末尾进行插入（接着文件里的内容继续写），必须将第二个参数设置为true，默认不写为false，会覆盖原文件

常用方法：

　　write（int）向文件中写入一个字节的值

　　write(byte[]) 向文件中写入一个数组的数据。

　　***③ write(byte[] offset len) 将 偏移量为 offset 的索引位置的长度为 len 的数据，写入到输出流中。

代码示例：

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

public class Demo11 {

    public static void main(String[] args) throws IOException {
        File file=new File("3.txt");
        FileOutputStream fos=new FileOutputStream(file);
        
        fos.write("没有绝对的绝缘体，只有不努力的电压。".getBytes());                
    }
}

执行结果，会在本项目的根目录下生成一个3.txt 文件，并且将内容写入进去。

 

文件复制：将一个文件通过IO流复制到另一个文件中去

代码示例：

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

public class Demo12 {

    public static void main(String[] args) throws IOException {
        File file=new File("1.txt");
        FileInputStream fis=new FileInputStream(file);
        FileOutputStream fos=new FileOutputStream(new File("4.txt"));
        byte[] bt=new byte[1024];
        int count;
        while((count=fis.read(bt))!=-1) {
            fos.write(bt,0,count);
        }
        fis.close();
        fos.close();
    }
}

结果会将1.txt的内容复制到4.txt中

 

带缓冲区的字节流
1. 通过比较 read() 与 read(byte[]) 的方法复制文件的时间的长短，可以看出，带缓冲区的读写文件的速度快，
java 上提供了专门带缓冲区的字节流，用以提高读写速度。
2.BufferedInputStream /BufferedOutputStream 带缓冲区的字节输入 / 输出流
3. 结论： 带缓冲区的字节流 读取速度高于字节流
代码演示：

public class  带缓冲区的字节流 {
public static void main(String[] args) throws IOException {
/*FileInputStream fis=new FileInputStream(new File("src\\com\\ 文件复制 .java"));
// 复制操作 ：
BufferedInputStream bis=new BufferedInputStream(fis);*/
// // 读取
// BufferedInputStream bis=new BufferedInputStream(new FileInputStream(new File("src\\com\\ 文
件复制 .java")));
// // 写入
// BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(new File("1.java"))
);
// 读取
BufferedInputStream bis=new BufferedInputStream(new FileInputStream(new File("D:\\0318java 班
\\day08\\ 录屏 \\1_day08IO 流概述 .mp4")));
// 写入
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(new File("C:\\Users\\
Administrator\\Desktop\\2.mp4")));
byte[] bt=new byte[1024];
int count=0;
long start=System.currentTimeMillis();
while((count=bis.read(bt))!=-1) {
bos.write(bt, 0, count);
}
long end=System.currentTimeMillis();
System.out.println(end-start);
bis.close();
bos.close();
}
}

jdk1.6 流的异常处理
1. 异常处理方式：
① try-catch-finally 异常的捕获
② throws 异常的声明
2. 以文件复制的形式来写流的异常处理 :
在 1.7jdk 之前包括 1.6 不包含 1.7 的流的异常处理形式。
代码演示：

public class  字节流的异常处理方式 {
public static void main(String[] args) {
// 为了在 finally 里面能够使用关闭资源，提升作用域
FileInputStream fis=null;
FileOutputStream fos=null;
try {
// 输入流
fis=new FileInputStream(new File("src\\com\\ 带缓冲区的字节流 .java"));
// 输出流
fos=new FileOutputStream(new File("2.java"));
// 文件复制
byte[] bt=new byte[1024];
int count=0;
while((count=fis.read(bt))!=-1) {
fos.write(bt,0,count);
}
}catch(Exception e) {
e.printStackTrace();
}finally {
close(fis, fos);
}
}
public static void close(InputStream fis,OutputStream fos) {
// 关闭资源
try {
// 为了防止空指针，需要判断不为 null 再关闭
if (fis!=null) {
fis.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
// 为了防止空指针，需要判断不为 null 再关闭
if (fos!=null) {
fos.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

Jdk1_7 流的异常处理形式

public class Jdk1_7 流的异常处理形式 {
public static void main(String[] args) {
try(
FileInputStream fis=new FileInputStream(new File("src\\com\\ 带缓冲区的字节流 .java"));
FileOutputStream fos=new FileOutputStream(new File("3.java"));
){
/*Scanner sc=new Scanner(System.in);
sc.close();*/
byte[] bt=new byte[1024];
int count=0;
while((count=fis.read(bt))!=-1) {
fos.write(bt,0,count);
}
}catch (Exception e) {
e.printStackTrace();
}
Scanner sc1=new Scanner(System.in);
String name = sc1.nextLine();
}
}

作者：ControllerMe 

地址：https://www.cnblogs.com/ywzbky/p/10692238.html

csdn_life18
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java中的io详解.
06-26
java io 输入输出详细介绍. 从菜鸟化身为高手
Java中IO流详解
08-30
主要介绍了java中的IO流详细解读,需要的朋友可以参考下
Java IO流详解
weixin_34034670的博客
04-15 137
参考转载地址：https://blog.csdn.net/zhangliangzi/article/details/51226652 　　　　　　　http://www.cnblogs.com/ysocean/p/6870069.html 　　　　　　　https://www.cnblogs.com/jmsjh/p/7761272.html 　　　　　　　http://blog.csdn.n...
Java中的IO流详解
最新发布
Welisit的博客
03-05 823
Java NIO (New IO，Non-Blocking IO)是从Java 1.4版本开始引入的一套新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的(IO是面向流的)、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO。​ |-----FileChannel:处理本地文件。
JAVA IO流详解
u012815721的专栏
05-08 4506
一、流的概念和作用。 流是一种有顺序的，有起点和终点的字节集合，是对数据传输的总成或抽象。即数据在两设备之间的传输称之为流，流的本质是数据传输，根据数据传输的特性讲流抽象为各种类，方便更直观的进行数据操作。 二、IO流的分类。 根据数据处理类的不同分为：字符流和字节流。 根据数据流向不同分为：输入流和输出流。 三、字符流和字节流。 字符流的由来：因为数据编码的不同，而有了对字符进行高效
Java 中IO流字符流详解及实例
08-30
主要介绍了Java 中IO流字符流详解及实例的相关资料,需要的朋友可以参考下
Java中IO流 RandomAccessFile类实例详解
08-30
主要介绍了Java中IO流 RandomAccessFile类实例详解的相关资料,需要的朋友可以参考下
java IO流详解
11-14
文档是关于JAVA常用IO流的学习笔记，可以用于参考，学习。
java中的io流详解
07-15
java中的io流 有例子演示 更容易学习和掌握
Java IO流（详解）
m0_54355172的博客
12-04 968
详细介绍各种常用 IO流 的使用
java的io流详解
qq_45919926的博客
06-03 138
https://www.cnblogs.com/QQ846300233/p/6046388.html https://blog.csdn.net/KK_bluebule/article/details/79157404 https://www.jianshu.com/p/827b45b42c0c 鸣谢原作者
Java-IO流详解
mofeigege的博客
11-21 338
输入input ： 读取外部数据(磁盘，光盘等存储设备的数据)到程序(内存)中 输出output ：将程序(内存) 数据输出到磁盘，光盘等存储设备中 流的分类 ◾按操作数据单位不同 分为：字节流(8bit)，字符流(16bit) ◾按数据流的流向不同 分为：输入流，输出流 ◾按流的角色不同 分为：节点流，处理流 抽象基类 字节流 字符流 输入流 InputStream Reader 输出流 OutputStream Writer (1) java的IO流共涉及40多个类，实际上非.
Java IO流
weixin_30576827的博客
04-02 84
IO流：概述、字符流、缓冲区 一、IO流概述 概述： IO流简单来说就是Input和Output流，IO流主要是用来处理设备之间的数据传输，java对于数据的操作都是通过流实现，而java用于操作流的对象都在IO包中。 分类： 按操作数据分为：字节流和字符流。 如：Reader和InpurStream 按流向分：输入流和输出流。如：InputSt...
java io流详解
07-28
Java的IO流是用于处理输入和输出的机制。它提供了一种方便的方式来读取和写入数据，包括文件、网络连接和其他数据源。 Java的IO流分为输入流和输出流。输入流用于从数据源中读取数据，输出流用于将数据写入目标位置...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值