文件
文件管理通过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、
先执行低级流
再执行高级流
可以看出高级流的耗时明显小于低级流耗时
