本文详细介绍了Java IO流的概念、分类及应用，包括字节流与字符流的区别、常见IO流类的使用方法，并通过多个案例演示了如何使用FileOutputStream和FileInputStream进行文件的读写与复制。
IO流概述及其分类
A:IO流概述
IO流用来处理设备之间的数据传输
Java对数据的操作是通过流的方式
Java用于操作流的对象都在IO包中
B:IO流分类
a:按照数据流向
输入流 读入数据
输出流 写出数据
b:按照数据类型
字节流 可以读写任何类型的文件 比如音频 视频 文本文件
字符流 只能读写文本文件
什么情况下使用哪种流呢?
如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流。其他用字节流。
如果你什么都不知道，就用字节流
IO流基类概述和FileOutputStream的构造方法
A:IO流基类概述
a:字节流的抽象基类：
InputStream ，OutputStream。
b:字符流的抽象基类：
Reader ， Writer。
注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream。
如：Reader的子类FileReader。
B:FileOutputStream的构造方法
由一个案例引出使用IO流写数据，由于字节流先出现就先学习字节输出流基类OutputStream，
使用具体子类FileOutputStream
Io流的分类:
-
(1): 按照流向进行划分
输入流
输出流 -
(2): 按照操作的数据类型进行划分
- 字节流
字节输入流 InputStream 读
字节输出流 OutputStream 写 - 字符流
字符输入流 Reader 读
字符输出流 Writer 写
- 字节流
-
需求: 往一个文本文件中写一串数据 Hello,IO
分析:
a: 我们现在操作的是文本文件,所有按照我们的想法,我们优先现在字符流,但是字节流是优先于字符流. 所以先使用字节流
b: 因为我们要写数据,所以我们应该使用字节流中输出流 OutputStream
我们发现OutputStream是一个抽象类,我们不能对其进行直接实例化,而我们需要使用子类对其进行实例化.那么选择哪个子类呢?
我们现在操作的是文件所以我们选择的是FileOutputStream
案例一：
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class MyTest {
public static void main(String[] args) throws IOException {
//IO:用来进行设备之间的一个数据传输
//按照读写文件的类型分为 字节流和字符流
//字节流可以读写任意类型的文件（音频，视频，文本，等等）
//字符流只能读写文本文件
//字节流的命名规律是，末尾会叫Stream
//文件输入输出流
//文件输出流 FileOutPutStream
//文件输出流是用于将数据写入 File
//FileOutputStream(File file)
//创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
//
//FileOutputStream(String name)
//创建一个向具有指定名称的文件中写入数据的输出文件流。
File file = new File("a.txt");
// file.createNewFile();
//输出流所关联的文件，如果不存在，会帮你自动创建
FileOutputStream out = new FileOutputStream(file);
System.out.println("--------------------------------");
FileOutputStream out2 = new FileOutputStream("b.txt");//传入一个具体的文件路径字符串
}
}
FileOutputStream写出数据
A: 构造方法
FileOutputStream(File file)
FileOutputStream(String name)
B:案例演示
FileOutputStream写出数据
注意事项：
创建字节输出流对象了做了几件事情?
a:调用系统资源创建a.txt文件
b:创建了一个fos对象
c:把fos对象指向这个文件
为什么一定要close()?
a: 通知系统释放关于管理a.txt文件的资源
b: 让Io流对象变成垃圾,等待垃圾回收器对其回收
案例一：
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class MyTest2 {
public static void main(String[] args) throws IOException {
FileOutputStream out = new FileOutputStream("a.txt");
//向文件中写入数据
out.write(97); //一次写入一个字节,超过一个字节会丢弃掉多余字节
out.write(98);
out.write(99);
System.out.println("------------------");
out.write(new byte[]{100, 101, 102});
String------byte[]
String str = "今天天气有点闷热";
byte[] bytes = str.getBytes();
out.write(bytes);
String str2 = "于是于是于是爱恨纠缠人憔悴";
//GBK编码一个汉字占两个字节，UTF-8 编码一个汉字占3个字节
out.write(str2.getBytes(), 0, 18);//一次写入字节数组的一部分，从0开始写18个字节
//流使用完毕之后记得要释放资源
out.close();
}
}
案例二：
import java.io.FileOutputStream;
import java.io.IOException;
public class MyTest3 {
public static void main(String[] args) throws IOException {
FileOutputStream out = new FileOutputStream("a.txt");
out.write("aa".getBytes());
//流使用完毕之后要关闭
out.close();
//创建字节输出流对象了做了几件事情 ?
// a : 调用系统资源创建a.txt文件
//b:
//创建了一个out对象
//c:
//把out对象指向这个文件
//为什么一定要close() ?
//
// a : 通知系统释放关于管理a.txt文件的资源
//b:
//让Io流对象变成垃圾, 等待垃圾回收器对其回收
}
}
FileOutputStream的三个write()方法
A:FileOutputStream的三个write()方法
public void write(int b):写一个字节 超过一个字节 砍掉前面的字节
public void write(byte[] b):写一个字节数组
public void write(byte[] b,int off,int len):写一个字节数组的一部分
B:案例演示: FileOutputStream的三个write()方法
案例一：
import javax.crypto.Mac;
import java.io.FileOutputStream;
import java.io.IOException;
public class MyTest4 {
public static void main(String[] args) throws IOException {
//windows下的换行符只用是 \r\n
//Linux \n
//Mac \r
FileOutputStream out = new FileOutputStream("b.txt");
out.write("换行符换行符".getBytes());
out.write("\r\n".getBytes());//写入一个换行符
out.write("黑板上老师的粉笔还在叽叽喳喳写个不停".getBytes());
out.write("\r\n".getBytes());//写入一个换行符
out.write("等待着下课，等待着放学，等待游戏的童年".getBytes());
out.write("\r\n".getBytes());//写入一个换行符
//释放资源
out.close();
}
}
FileOutputStream写出数据实现换行和追加写入true
A:案例演示: FileOutputStream写出数据如何实现数据的换行
windows下的换行符只用是 \r\n
Linux \n
Mac \r
eclipse/IDEA 中的记事本软件以及editplus这样的第三种软件都做了平台的兼容
B:案例演示: FileOutputStream写出数据如何实现数据的追加写入
案例一：
import java.io.FileOutputStream;
import java.io.IOException;
public class MyTest5 {
public static void main(String[] args) throws IOException {
//FileOutputStream(File file, boolean append)
//创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
//
//FileOutputStream(String name, boolean append)
//创建一个向具有指定 name 的文件中写入数据的输出文件流。
//参数2：代表是否追加写入，true 追加写入 false 不追加
FileOutputStream out = new FileOutputStream("c.txt",true);
out.write("池塘边的榕树上知了在声声的叫着夏天".getBytes());
out.write("\r\n".getBytes());//写入一个换行符
out.write("黑板上老师的粉笔还在叽叽喳喳写个不停".getBytes());
out.write("\r\n".getBytes());//写入一个换行符
out.write("等待着下课，等待着放学，等待游戏的童年".getBytes());
out.write("\r\n".getBytes());//写入一个换行符
//释放资源
out.close();
}
}
FileOutputStream写出数据加入异常处理
A:案例演示:FileOutputStream写出数据加入异常处理
案例一：
import java.io.FileOutputStream;
import java.io.IOException;
public class MyTest {
public static void main(String[] args) {
//流的异常处理
FileOutputStream out = null;
try {
out = new FileOutputStream("d.txt");
out.write(100);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (out != null) {
out.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
FileInputStream读取数据一次一个字节
A:案例演示: int read():一次读取一个字节
如果没有数据返回的就是-1
案例一：
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class MyTest {
public static void main(String[] args) throws IOException {
//FileInputStream(File file)
//通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
//
//FileInputStream(String name)
//通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
//输入流所关联的文件，如果不存在，就报错了
FileInputStream in = new FileInputStream(new File("e.txt"));
//读取文件中的数据
int len = in.read(); //一次读取一个字节，如果读取不到数据，返回的是 -1 我们要拿 -1 做判断看文件是否读取完了
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
len = in.read(); //一次读取一个字节
System.out.println(len);
//释放资源
in.close();
}
}
案例二:
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class MyTest2 {
public static void main(String[] args) throws IOException {
FileInputStream in = new FileInputStream("e.txt");
//创建一个字节数组，充当容器
byte[] bytes = new byte[1024];
int len = in.read(bytes); //把文件中的数据，读取到容器中，返回值是，读取到的有效字节个数
System.out.println(len);
//for (byte b : bytes) {
// System.out.println(b);
//}
//把字节数组转成字符串
//byte[] bytes1 = "str".getBytes();
String s = new String(bytes, 0, len);
System.out.println(s);
in.close();
}
}
案例三：
import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils;
import java.io.FileInputStream;
import java.io.IOException;
public class MyTest3 {
public static void main(String[] args) throws IOException {
FileInputStream in = new FileInputStream("e.txt");
byte[] bytes = new byte[1024];
int len = in.read(bytes, 0, 4);//一次从文件中读取一部分字节，放到容器中 从0开始读取四个
System.out.println(len);
String s = new String(bytes, 0, len);
System.out.println(s);
in.close();
}
}
字节流复制文本文件
A:案例演示: 字节流一次读写一个字节复制文本文件
分析:
a: 创建字节输入流对象和字节输出流对象
b: 频繁的读写操作
c: 释放资源
案例：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFile {
public static void main(String[] args) throws IOException {
//使用文件输入输出流进行文件的复制
//ctrl+alt+空格 手动提示键
//关联源文件
FileInputStream in = new FileInputStream("MyTest2.java");
//关联目标文件
FileOutputStream out = new FileOutputStream("E:\\MyTest2.java");
//复制逻辑：读取一个字节，写入一个字节
//循环的读写
int len=0;
while ((len=in.read())!=-1){
out.write(len);
out.flush();//刷新
}
//释放资源
in.close();
out.close();
}
}
字节流复制MP3
A:案例演示: 字节流一次读写一个字节复制MP3
案例一：
import java.io.*;
public class CopyFile2 {
public static void main(String[] args) throws IOException {
//我们读取一个字节，写入一个字节，来复制音频文件
FileInputStream in = new FileInputStream("领悟1.mp3");
FileOutputStream out = new FileOutputStream("E:\\领悟-辛晓琪-词李宗盛.mp3");
int len=0;//定义一个变量，记录读取到的字节
//循环读写
while ((len=in.read())!=-1){
out.write(len);
out.flush();
}
//释放资源
in.close();
out.close();
}
}
FileInputStream读取数据一次一个字节数组
A:案例演示: int read(byte[] b):一次读取一个字节数组
返回的int类型的值表示的意思是读取到的字节的个数,如果没有数据了就返回-1
案例一：
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFile3 {
public static void main(String[] args) throws IOException {
//很显然 一次读写一个字节来复制文件，太慢了
//所以我们一次多复制一些字节
FileInputStream in = new FileInputStream("领悟1.mp3");
FileOutputStream out = new FileOutputStream("领悟1234.mp3");
//引入缓冲区的思想
byte[] bytes = new byte[1024*8]; //创建一个缓冲区
int len=0;//定义一个变量，记录每次读取到的有效字节个数
//循环的读写操作
while ((len=in.read(bytes))!=-1){
out.write(bytes,0,len);
out.flush();
}
//释放资源
in.close();
out.close();
}
}
BufferedOutputStream写出数据
A:缓冲思想
字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，
这是加入了数组这样的缓冲区效果，java本身在设计的时候，
也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流
B:BufferedOutputStream的构造方法
查看API
BufferedOutputStream(OutputStream out)
C:案例演示
BufferedOutputStream写出数据
案例一：
import java.io.*;
public class MyTest {
public static void main(String[] args) throws IOException {
long start = System.currentTimeMillis();
// copy1();
// copy2();
//耗时:
//15214 毫秒
long end = System.currentTimeMillis();
System.out.println("耗时:" + (end - start) + "毫秒"); //204
}
private static void copy2() throws IOException {
FileInputStream in = new FileInputStream("领悟1.mp3");
FileOutputStream out = new FileOutputStream("领悟11111.mp3");
byte[] bytes = new byte[1024 * 8];
int len = 0;
while ((len = in.read(bytes)) != -1) {
out.write(bytes, 0, len);
}
in.close();
out.close();
}
private static void copy1() throws IOException {
//高效的字节输入输出流
//这对流，底层加入了缓冲区
// BufferedInputStream
// BufferedOutputStream 该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。
//BufferedInputStream(InputStream in)
//创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
//BufferedInputStream(InputStream in, int size)
//创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
BufferedInputStream in = new BufferedInputStream(new FileInputStream("领悟1.mp3"));
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("领悟11111.mp3"));
byte[] bytes = new byte[1024 * 8];
int len = 0;
while ((len = in.read(bytes)) != -1) {
out.write(bytes, 0, len);
}
in.close();
out.close();
}
}
基本流FileOutputStream和FileInputStream 高效流BufferedInputStream和BufferedOutputStream
字节流两种方式种方式复制MP3并测试效率，一般的高效的
案例：
import java.io.*;
public class MyTest {
public static void main(String[] args) throws IOException {
long start = System.currentTimeMillis();
copy1();
//copy2();
//耗时:
//15214 毫秒
long end = System.currentTimeMillis();
System.out.println("耗时:" + (end - start) + "毫秒"); //耗时:17506毫秒 耗时:17929毫秒
}
private static void copy2() throws IOException {
FileInputStream in = new FileInputStream("E:\\疯狂动物城.mp4");
FileOutputStream out = new FileOutputStream("D:\\疯狂动物城.mp4");
BufferedInputStream bfi = new BufferedInputStream(in);
BufferedOutputStream bfw = new BufferedOutputStream(out);
byte[] bytes = new byte[1024 *1024];
int len = 0;
while ((len = bfi.read(bytes)) != -1) {
bfw.write(bytes, 0, len);
bfw.flush();
}
bfi.close();
bfw.close();
}
private static void copy1() throws IOException {
FileInputStream in = new FileInputStream("E:\\疯狂动物城.mp4");
FileOutputStream out = new FileOutputStream("D:\\疯狂动物城.mp4");
byte[] bytes = new byte[1024 *1024];
int len=0;
while ((len=in.read(bytes))!=-1){
out.write(bytes,0,len);
out.flush();
}
in.close();
out.close();
}
}
扫一扫
363
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
