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();
}
}
}
}