java文件与流_Java文件与流

文件

文件管理通过java.io包下.file类

作用：

1、文件属性

2、文件检查

3、文件删除

4、不包含对其文件内容的处理

File类的构造

语法：

File f =new File(String path)

path:选中文件路径

例如：

先在E盘中创建一 .txt文件,

创建FileDome类

File f =new File("E:/iodemo.txt");

方法

例如：

创建新文件

File f =new File("E:/iodemo01.txt");

try {

boolean b=f.createNewFile();

System.out.println(b);

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

盘中对应路径查看：

常用方法：

f.exists()判断文件是否存在

f.delete()删除文件，不可恢复性删除

流

概念： 流(Stream)代表程序中数据的流通

数据流：是一串连续不断的数据的集合

java中分为

1、输入流：流入 到计算机内存数据

2、输出流：流出 计算机内存数据

1、按照处理单位分为：

1、字节流

2、字符流

2、按照功能分为：

1、节点流(低级流)

2、处理流(高级流)

速度不同：低级流 < 高级流

文件读取

字节流

创建FileInput类,读取上面iodemo.txt文件

iodemo.txt内容

helo word!

my name is wangjilong

tell: 210-455214

创建FileInput类

public static void main(String[] args) {

read1();

}

//通过java io读取文件数据

public static void read1() {

//找到文件

File f= new File("E:/iodemo.txt");

//文件字节输入流

FileInputStream fis=null;

try {

//搭建管道

fis = new FileInputStream(f);

//读取数据

System.out.print((char)fis.read());//char强行转换类型，不然读取的是accii表 h对应值104

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

输出：

h

读取了一次，所以只有 h

修改读取数据部分代码，循环读取

//读取数据

for (int i = 0; i < f.length(); i++) {

System.out.print((char)fis.read());

}

或者：

while (true) {

int s=0;

if ((s=fis.read())!=-1) {

System.out.print((char)s);

} else {

break;

}

}

输出：

helo word!

my name is wangjilong

tell: 210-455214

注意：

该方法无法读取 汉字 ；

read()方法：

此方法输入流中读取一个数据字节，如果已经达到文件末尾，则返回-1(表示读取完成)

容器创建

为了减少内存处理负担，可以先将文件读取到缓存器内，然后一次性读出，避免单个字节的吞吐。

在上面的代码上添加read2方法

public static void read2() {

File f= new File("E:/iodemo.txt");

//文件字节输入流

FileInputStream fis;

try {

fis=new FileInputStream(f);

//创建容器

byte[] b= new byte[1024];

//读入容器

int length=fis.read(b);

System.out.println(length);//返回读取文件内容的个数

System.out.println(new String(b,0,length));//string构造

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

输出

54

helo word!

my name is wangjilong

tell: 210-455214

关于上述代码中的String构造解释：

public String(byte[] bytes,int offset,int length)

byte[] bytes：原数组 字符的数字形式 需要转成字符串

int offset：初始位置 在byte的那个下标位置开始截取

int length：截取的长度

同理这时候可以对文件中的 汉字进行读取，在.txt文件中添加汉字试一试读取

当前代码读取量只有1024，面对更大 的文件需要去循环多次读取

修改后

public static void read2() {

File f= new File("E:/iodemo.txt");

//文件字节输入流

FileInputStream fis;

try {

fis=new FileInputStream(f);

//创建容器

byte[] b= new byte[1024];

while ((fis.read(b))!=-1) {

//读完返回-1

System.out.println(new String(b));

}

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

注意：

如果汉字出现乱码，需要修改编码格式为ANSI格式

文件拷贝和复制

拷贝和文件需要用 流 来完成

(生动形象的图解一下)

创建俩个txt文件，一个为空文件即可

我这里创建了 少年闰土.txt(作源文件)和 少年闰土copy.txt(目标文件空文件)

public static void main(String[] args) {

//文件拷贝

File f1=new File("E:/少年闰土.txt");//源文件

File f2=new File("D:/少年闰土copy.txt");//目标文件

//字节输入流

FileInputStream fis=null;

//字节输出流

FileOutputStream fos=null;

try {

fis =new FileInputStream(f1);

fos =new FileOutputStream(f2);

byte[] b=new byte[1024];

int length=0;

while ((length=fis.read(b))!=-1) {

fos.write(b, 0,length);

}

System.out.println("拷贝成功");

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

} catch (IOException e) {

// TODO Auto-generated catch block

}finally {

try {

fos.close();//关闭流

} catch (Exception e2) {

// TODO: handle exception

}

}

运行，在目标文件中查看拷贝后的文件内容

注意：当 write 方式没有写入时无法完成，则强制写入

fos.flush()

向文件中添加内容

向iodemo01.txt文件中写入内容

File f= new File("E:/iodemo01.txt");

FileOutputStream fos;

try {

fos=new FileOutputStream(f);

byte[] b=new byte[100];

//写入内容

String str ="今年我想买个劳";

//将字符串转换成byte数组

b=str.getBytes();

fos.write(b);

System.out.println("输入完成");

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

运行，在路径中找到该文件查看。

如果需要继续添加内容，不覆盖以前的内容，在 f， 后加true就行

fos=new FileOutputStream(f,true);

字符流

2字节 ，字符输入流Reader, 字符输出流 writer

File f=new File("E:/iodemo02.txt");

FileWriter fw = null ;

try {

fw =new FileWriter(f,true);

String str = "我还想买个红旗";

fw.write(str);

System.out.println("完成");

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}finally {

try {

fw.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

字符流的拷贝

选定一个文件先完成读取，然后再写入到另一个文件，就完成了一个拷贝

File f1=new File("E:/iodemo02.txt");

File f2 =new File("E:/iodemo02copy.txt");

FileWriter fw = null ;

FileReader fr=null;

try {

fr =new FileReader(f1);

fw =new FileWriter(f2);

char[] c= new char[1024];

int length=0;

while ((length=fr.read(c))!=-1) {

fw.write(c,0,length);

}

System.out.println("完成");

}

catch (FileNotFoundException e1) {

// TODO Auto-generated catch block

e1.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}finally {

try {

fw.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

关于高级流和处理流

高级流的使用需要先创建低级流，高级流可以更快的完成操作，节约时间

public static void main(String[] args) {

File f1=new File("E:/iodemo01.txt");//源文件

File f2=new File("E:/iodemo011.txt");//目标文件

//低级字节输入流

FileInputStream fis=null;

//高级字节输入流

BufferedInputStream bis=null;

//低级字节输出流

FileOutputStream fos =null;

//高级字节输出流

BufferedOutputStream bos=null;

try {

fis = new FileInputStream(f1);

bis =new BufferedInputStream(fis);

fos =new FileOutputStream(f2);

bos =new BufferedOutputStream(fos);

byte[] b =new byte[2048];

int length=0;

while ((length=bis.read(b))!=-1) {

bos.write(b,0,length);

bos.flush();

}

System.out.println("ok!!!!!");

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}finally {

try {

bis.close();

bos.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

高级流和低级流放在同一类下，我们来作一个对比

public class BufferFileCopy {

public static void main(String[] args) {

//记录开始时间

long begin =System.currentTimeMillis();

// Files();

buff();

long end = System.currentTimeMillis();

double time = (end-begin)/1000;

System.out.println("执行过程时间为"+time);

}

//高级流文件拷贝

public static void buff() {

File f1=new File("E:/02.JavaSE核心技术/D-参考资料/01.zip");//源文件

File f2=new File("E:/02.JavaSE核心技术/D-参考资料/01高级.zip");//目标文件

//低级字节输入流

FileInputStream fis=null;

//高级字节输入流

BufferedInputStream bis=null;

//低级字节输出流

FileOutputStream fos =null;

//高级字节输出流

BufferedOutputStream bos=null;

try {

fis = new FileInputStream(f1);

bis =new BufferedInputStream(fis);

fos =new FileOutputStream(f2);

bos =new BufferedOutputStream(fos);

byte[] b =new byte[2048];

int length=0;

while ((length=bis.read(b))!=-1) {

bos.write(b,0,length);

bos.flush();

}

System.out.println("ok!!!!!");

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}finally {

try {

bis.close();

bos.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

//低级流文件拷贝

public static void Files() {

File f1=new File("E:/02.JavaSE核心技术/D-参考资料/01.zip");//源文件

File f2=new File("E:/02.JavaSE核心技术/D-参考资料/01低级.zip");//目标文件

//字节输入流

FileInputStream fis=null;

//字节输出流

FileOutputStream fos=null;

try {

fis =new FileInputStream(f1);

fos =new FileOutputStream(f2);

byte[] b=new byte[1024];

int length=0;

while ((length=fis.read(b))!=-1) {

fos.write(b, 0,length);

}

System.out.println("拷贝成功");

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

} catch (IOException e) {

// TODO Auto-generated catch block

}finally {

try {

fos.close();//关闭流

} catch (Exception e2) {

// TODO: handle exception

}

}

}

}

这里需要一个大一点的文件，我这里用的文件大小为389,952kb、

先执行低级流

再执行高级流

可以看出高级流的耗时明显小于低级流耗时