Java-IO（字节流）
1. 字节输出流
步骤：
- 1.创建字节输出流对象
- 2.调用 write() 方法写入数据
- 3.释放资源
写入数据的三种方式
- public void write(int b)
- public void write(byte[] b)
- public void write(byte[] b,int off,int len)
代码如下：
public class FileOutputStreamDemo2 {
public static void main(String[] args) throws IOException {
//创建字节输出流对象
FileOutputStream fileOutputStream = new FileOutputStream("D:\\o.txt");
//public void write(int b) 写入的是数字，输出的是数字对应的Assic码
// fileOutputStream.write(99);
// fileOutputStream.write(96);
// fileOutputStream.write(35);
// fileOutputStream.write(56);
// public void write(byte[] b) 写入数组
byte[] bytes = {33,56,87,57,22,57,14,89,22};
// fileOutputStream.write(bytes);
//public void write(byte[] b,int off,int len)
fileOutputStream.write(bytes, 2, 3);
fileOutputStream.close();
}
}
注意事项：
换行问题：
- 1、没有换行，如何实现换行呢？
为什么上一个代码中没有进行换行呢？
因为我们在写数据的时候，只写了字节，没有写入换行符
如何实现呢？
理论上，我们每写完一部分的时候，就写一个换行符进行换行
注意，每一个系统对应的换行不大一样
Windows：\r\n
Mac： \r
Linux： \n
追加问题
- 2、每次运行写入的时候，会把上一次运行的数据进行覆盖，如何实现追加写入呢？
追加：在原有的文件内容上继续添加一些新的内容
覆盖：将原有的文件内容删掉，再添加一些新的内容
FileOutputStream(String name, boolean append) 创建文件输出流以指定的名称写入文件。
public class FileOutputStreamDemo3 {
public static void main(String[] args) throws IOException {
//创建字节输出流对象
//如果不添加后面的 append 参数的话。 默认的是 FALSE ，不追加写入
FileOutputStream fileOutputStream = new FileOutputStream("D:\\p.txt",true);
//调用 write 方法写入数据
for (int i = 0; i < 5; i++) {
fileOutputStream.write(("大数据，yyds"+i).getBytes());
fileOutputStream.write("sdfasdf".getBytes());
//添加换行操作
fileOutputStream.write("\r\n".getBytes());
}
fileOutputStream.close();
}
}
2. 字节输入流
步骤
字节输入流：ImputStream
子类：FileInputStream
- 1、创建字节输入流对象
- 2、调用方法读取数据
- 3、释放资源
FileInputStream的构造方法：
- FileInputStream(File file)
- FileInputStream(String name)
字节输入流读取对象读取数据的两种方式：
- public int read()
- public int read(byte[] b)
上代码
public class FileInputStreamDemo1 {
public static void main(String[] args) throws IOException {
//创建字节输入流对象
// File file = new File("D:\\a.txt");
// FileInputStream fileInputStream = new FileInputStream(file);
FileInputStream fileInputStream = new FileInputStream("D:\\a.txt");
// public int read()读取
// System.out.println((char)fileInputStream.read());
// System.out.println((char)fileInputStream.read());
// System.out.println((char)fileInputStream.read());
// System.out.println((char)fileInputStream.read());
/*
//我们发现，当文件的内容过多的时候，一个字节一个字节去读取，发现很麻烦，而且语句都是一样
//使用循环改进，使用哪一种循环呢？
//因为我们不知道要循环多少次才能读到文件的末尾，所以采用while循环
//使用while循环，就得有一个循环条件
//想一下，这个循环条件是不是就是读到了末尾就不读
//如何使用代码表示读到文件末尾呢？如果达到文件的末尾， -1 。
//一次读取一个字节
*/
int len = 0;
while ((len = fileInputStream.read()) != -1){
System.out.println((char)len);
}
fileInputStream.close();
}
}
字节输入流读取数据的第二种方法，一次读取一个数组
public class FileInputStreamDemo2 {
public static void main(String[] args) throws IOException {
//创建字节输入对象
FileInputStream fileInputStream = new FileInputStream("D:\\b.txt");
//创建字节数组，依据大小来读取
byte[] bytes = new byte[4];
int len = 0;
while ((len = fileInputStream.read(bytes)) != -1){
System.out.println(new String(bytes, 0, len));
}
}
}
3 字节缓冲流
字节缓冲输出流：BufferedOutputStream
- 构造方法：
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
public class BufferedOutputStreamDemo1 {
public static void main(String[] args) throws IOException {
// FileOutputStream fos = new FileOutputStream("out5.txt");
// //创建一个字节缓冲流对象
// BufferedOutputStream bos = new BufferedOutputStream(fos);
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("out5.txt"));
//调用方法写数据
bos.write("大数据，yyds".getBytes());
//释放资源
bos.close();
// fos.close();
}
}
字节缓冲输入流：BufferedInputStream
- 构造方法：
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使
public class BufferedInputStreamDemo1 {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("a.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
//调用方法，读取数据
//一次读取一个字节
// int b = 0;
// while ((b=bis.read())!=-1){
// System.out.print((char) b);
// }
System.out.println("=================================");
//一次读取一个字节数组
int length = 0;
byte[] bytes = new byte[10];
while ((length=bis.read(bytes))!=-1){
String s = new String(bytes, 0, length);
System.out.print(s);
}
}
}
各种流读取快慢测试
- 单个字节读取与字节数组比较
- 缓冲流与非缓冲流速度比较
package com.bigdat.java.day25;
import java.io.*;
/*
测试
单个字节和字节数组读取时间
非缓冲与带缓冲的读取时间
*/
public class CopyDemo2 {
public static void main(String[] args) {
// oneTest(); 单个字节读取视屏的时间为2107904毫秒
// shuZuTest(); 数组读取视屏的时间为2392毫秒
// OneBufferText(); 缓冲单字节读取视屏的时间为：9503毫秒
// shuzuBufferText(); 缓冲字节数组读取视屏的时间为：547毫秒
}
//测试单个字符读取一段视屏的时间
public static void oneTest(){
//创建读取对象
FileInputStream fileInputStream = null;
//创建写出对象
FileOutputStream fileOutputStream = null;
try {
fileInputStream = new FileInputStream("D:\\我被改名了\\17day24 字节流速度对比，编码表 2.mp4");
fileOutputStream = new FileOutputStream("D:\\我被改名了\\copy1.mp4");
Long start = System.currentTimeMillis();
//开始读取
int len = 0;
while((len = fileInputStream.read()) != -1){
fileOutputStream.write(len);
}
long end = System.currentTimeMillis();
System.out.println("单个字节读取视屏的时间为"+(end-start)+"毫秒");
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fileOutputStream.close();
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//测试字节数组copy视屏的时间
public static void shuZuTest(){
//创建读取对象
FileInputStream fileInputStream = null;
//创建写出对象
FileOutputStream fileOutputStream = null;
try {
fileInputStream = new FileInputStream("D:\\我被改名了\\17day24 字节流速度对比，编码表 2.mp4");
fileOutputStream = new FileOutputStream("D:\\我被改名了\\copy2.mp4");
Long start = System.currentTimeMillis();
//开始读取
int len = 0;
byte[] bytes = new byte[1024];
while((len = fileInputStream.read(bytes)) != -1){
fileOutputStream.write(bytes, 0, len);
}
long end = System.currentTimeMillis();
System.out.println("数组读取视屏的时间为"+(end-start)+"毫秒");
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fileOutputStream.close();
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//缓冲流单个字节读取视屏测试时间
public static void OneBufferText(){
//创建读入字节的对象
BufferedInputStream bufferedInputStream = null;
BufferedOutputStream bufferedOutputStream = null;
try {
bufferedInputStream = new BufferedInputStream(new FileInputStream("D:\\我被改名了\\17day24 字节流速度对比，编码表 2.mp4"));
bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("D:\\我被改名了\\copy3.mp4"));
//开始时间
long start = System.currentTimeMillis();
//开始写入到程序中
int len = 0;
while((len = bufferedInputStream.read()) != -1){
bufferedOutputStream.write(len);
}
long end = System.currentTimeMillis();
System.out.println("缓冲单字节读取视屏的时间为："+(end-start));
} catch (IOException e) {
e.printStackTrace();
}
finally {
try {
bufferedOutputStream.close();
bufferedInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void shuzuBufferText(){
//创建读入字节的对象
BufferedInputStream bufferedInputStream = null;
BufferedOutputStream bufferedOutputStream = null;
try {
bufferedInputStream = new BufferedInputStream(new FileInputStream("D:\\我被改名了\\17day24 字节流速度对比，编码表 2.mp4"));
bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("D:\\我被改名了\\copy4.mp4"));
//开始时间
long start = System.currentTimeMillis();
//开始写入到程序中
int len = 0;
byte[] bytes = new byte[1024];
while((len = bufferedInputStream.read(bytes)) != -1){
bufferedOutputStream.write(bytes, 0, len);
}
long end = System.currentTimeMillis();
System.out.println("缓冲字节数组读取视屏的时间为："+(end-start)+"毫秒");
} catch (IOException e) {
e.printStackTrace();
}
finally {
try {
bufferedOutputStream.close();
bufferedInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
