Java之IO（一） FileInputStream、FileOutputStream、BufferedInputStream、BufferedOutputStream

package com.shuhuadream.file;

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

/*
File类: 用于描述一个文件或者文件夹的。

通过File对象我们可以读取文件或者文件夹的属性数据，如果我们需要读取文件的内容数据，那么我们需要使用IO流技术。

IO流（Input Output）

IO流解决问题： 解决设备与设备之间的数据传输问题。  内存--->硬盘   硬盘--->内存

IO流技术：

IO流分类：
如果是按照数据的流向划分：

输入流

输出流

如果按照处理的单位划分：

字节流: 字节流读取得都是文件中二进制数据，读取到二进制数据不会经过任何的处理。

字符流： 字符流读取的数据是以字符为单位的 。 字符流也是读取文件中的二进制数据，不过会把这些二进制数据转换成我们能 识别的字符。
字符流 = 字节流 + 解码

输入字节流：
--------| InputStream 所有输入字节流的基类  抽象类
------------| FileInputStream  读取文件数据的输入字节流

使用FileInputStream读取文件数据的步骤：
1. 找到目标文件
2. 建立数据的输入通道。
3. 读取文件中的数据。
4. 关闭 资源.

*/
public class Demo01 {
public static void main(String[] args) {
readTest04();
}

//方式四  使用缓冲数组配合循环一起使用
/*************推荐使用******************/
public static void readTest04(){
//找到目标文件
File file = new File("d:\\demo\\a.txt");
FileInputStream fis = null;
//建立缓冲数组配合循环读取文件的数据
byte[] buf = new byte[1024];
try {
//建立数据的输入通道
fis = new FileInputStream(file);
int length = 0;//定义变量，保存实际读取到的字节数
while((length=fis.read(buf))!=-1){//read方法返回的是下一个字节，如果读到了文件的末尾，那么会返回-1表示
System.out.println(new String(buf,0,length));
//String(byte[] byte,int offset,int length)   offset:要解码的第一个byte的索引 length:需要解码的byte数
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

//方式三  无法完整读取一个文件的数据
public static void readTest03(){
//找到目标文件
File file = new File("d:\\demo\\a.txt");
FileInputStream fis = null;
byte[] buf = new byte[1024];
try {
fis = new FileInputStream(file);
int length = fis.read(buf);
String content = new String(buf,0,length);// 如果使用read读取数据传入字节数组，那么数据是存储到字节数组中的，而这时候read方法的返回值是表示的是本次读取了几个字节数据到字节数组中。
System.out.println(content);
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}

}

//读取方式二：使用循环读取文件的数据
public static void readTest02(){
//找到目标文件啊
File file = new File("d:\\demo\\a.txt");
FileInputStream fis = null;
try {
//建立数据的输入通道
fis = new FileInputStream(file);
//读取文件中的数据
int content = 0;//声明变量用于存储读取到的数据
while((content = fis.read())!=-1){
System.out.println((char)content);
}

} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
//关闭资源
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

//读取方式一：无法读取完整的一个文件数据
public static void readTest01(){
//找到目标文件啊
File file = new File("d:\\demo\\a.txt");
FileInputStream fis = null;
try {
//建立数据的输入通道
fis = new FileInputStream(file);
//读取文件中的数据
int read = fis.read();//read() 读取一个字节的数据
System.out.println(read);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
//关闭资源
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

package com.shuhuadream.file;

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

/**
* ------------|OutputStream	是所有输出字节流的父类。 抽象类
* --------------|FileOutputStream   向文件输出数据的输出字节流
*
* FileOutputStream 如何使用？
* */
public class Demo02 {
public static void main(String[] args) {
writeTest01();
}

public static void writeTest01(){
//找到目标文件
File file = new File("d:\\demo\\a.txt");
FileOutputStream fos = null;
String str = "\r\n大河向东流";

byte[] data = str.getBytes();
try {
fos = new FileOutputStream(file,true);
fos.write(data,0,data.length);
fos.flush();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

package com.shuhuadream.file;

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

public class Test01 {
public static void main(String[] args) {
//找到目标文件
File file1 = new File("d:\\demo\\1.jpg");
File file2 = new File("d:\\demo\\2.jpg");

FileInputStream fis = null;
FileOutputStream fos = null;

int length = 0;
byte[] buf = new byte[1024];//缓冲数组
try {
//建立数据的输入输出通道
fis = new FileInputStream(file1);
fos = new FileOutputStream(file2);
//边读边写
while((length=fis.read(buf))!=-1){
fos.write(buf,0,length);
}
} catch (FileNotFoundException e) {
//e.printStackTrace();
throw new RuntimeException(e);
} catch (IOException e) {
//e.printStackTrace();
throw new RuntimeException(e);
}finally{
try {
if(fos!=null){
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}finally{
if(fis!=null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

}

}

}

package com.shuhuadream.buffer;

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

/*
* 文件数据使用缓冲数组读取效率更高，sun也知道使用缓冲数组读取效率更高，那么
* 这时候sun给我们提供了一个---------缓冲输入字节流对象，让我们可以更高效率读取文件
*
* 输入字节流体系：
--------| InputStream 所有输入字节流的基类  抽象类
------------| FileInputStream  读取文件数据的输入字节流
------------| BufferedInputStream  缓冲输入字节流 缓冲输入字节流的出现主要是为了提高读取文件数据的效率

注意：凡是缓冲流都不具备读写文件的能力

其实该类内部只不过是维护了一个8kb的字节数组

使用BufferedInputStream的步骤：
1.找到目标文件

*/
public class Demo01 {
public static void main(String[] args) {
bis();
}

public static void bis(){
//找到目标文件
File file = new File("d:\\demo\\a.txt");
FileInputStream fis = null;
BufferedInputStream bis = null;
try {
//建立数据的输入通道
fis = new FileInputStream(file);
//建立缓冲输入字节流
bis = new BufferedInputStream(fis);
int content = 0;
//读入文件数据
while((content=bis.read())!=-1){
System.out.print((char)content);
}
} catch (IOException e) {
e.printStackTrace();
}finally{
if(bis!=null){
try {
//关闭资源
bis.close();//调用bis的close方法实际上关闭的是fis
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}

package com.shuhuadream.buffer;

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

/**
* ------------|OutputStream	是所有输出字节流的父类。 抽象类
* --------------|FileOutputStream   向文件输出数据的输出字节流
* --------------|BufferedOutputStream 缓冲输出字节流 BufferedOutputStream出现的目的是为了提高写数据的效率
* 									      内部也是维护了一个8kb的字节数组
*
*
* BufferedOutputStream要注意的细节
* 		1.使用BufferedOutputStream写数据的时候，它的write方法是先把数据写到它的内部维护的数组中
* 		2.如果需要把数据真正写到硬盘上面，需要调用flush方法或者close方法，或者是内部维护的字节数组已经填满的时候
* */
public class Demo02 {
public static void main(String[] args) {
//找到目标文件
File file = new File("d:\\demo\\a.txt");
FileOutputStream fos1 = null;
BufferedOutputStream bos = null;

try {
//建立数据的输出通道
fos1 = new FileOutputStream(file);
//建立缓冲输出字节流对象
bos = new BufferedOutputStream(fos1);
//准备数据源
String str = "hello world";
byte[] data = str.getBytes();
//写数据
bos.write(data);
//刷新流
bos.flush();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
//关闭流
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

package com.shuhuadream.buffer;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

//使用缓冲输入输出字节流拷贝一个图片
public class Test01 {
public static void main(String[] args) {
//找到目标文件
File file1 = new File("d:\\demo\\1.jpg");
File file2 = new File("d:\\demo\\3.jpg");

BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//建立输入输出通道
bis = new BufferedInputStream(new FileInputStream(file1));
bos = new BufferedOutputStream(new FileOutputStream(file2));
int content = 0;
//int length = bufferedInputStream.read(buf);如果传入了缓冲数组，内容是存储到缓冲数组中，返回值是存储到缓冲数组的字节个数
//边读边写
while((content = bis.read())!=-1){//如果使用read方法没有传入缓冲数组，那么返回值是读取到的内容
bos.write(content);
//bos.flush(); //不用写这句，数组满了8kb自动会刷新流，就算是最后没满8kb，close也会自动刷出去
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
//关闭流
bos.close();
bis.close();
} catch (IOException e) {
e.printStackTrace();
}

}
}
}