1 IONo18
【
IO：Input Output
在程序运行的过程中，可能需要对一些设备进行数据的读取操作，比如：对磁盘进行读写操作。
IO框架就是用于对设备进行读写操作，在学习对象之前，我们首先要学习一个非常重要的类:File类
IO框架
File类
概述：用于描述存在或不存在的文件或文件夹
绝对路径：完整的路径名
相对路径：相对于当前所在的路径
IO流：
主要用于实现设备之间的数据传输
设备：内存、磁盘、网络、键盘、鼠标…….
？《在Java中，IO流的方向是相对内存而言的》
设备之间的数据传输通过流来实现
流的分类，按照流向、功能可以分为以下三种：
1：按方向分类：输入流、输出流
在java中，IO流的方向是相对内存而言的
2：按单位分类：字节流、字符流
1）在磁盘上存储数据都是以二进制的形式来保存,但是每一位只能保存两个状态，为了能够表示足够多的状态，所以我们以8位为一个单位，叫做字节，所以在内存中保存数据的最小单位是字节
在程序中数据存储的最小单位是字节(byte)
2）磁盘上保存数据都是以二进制形式，如果需要在磁盘上保存一些字符(a,b),就需要使用编码表先将子符进行编码，再将对应的编码保存在磁盘上，不同的编码表保存数据所用的字节数是不同的，通过是在1~3个字节来保存，如果以字节为单位处理数据，那么就有可能出现数据不完整和乱码的情况，所以在处理文本数据的时候建议使用字符流。
总结：如果处理的数据是文本数据，一般就用字符流，其他数据一般使用字节流(字节流也能操作文本数据)。
3：按功能分为：节点符、过滤流(处理流)
在IO框架中有四个顶层基类：
1：字符流：Reader Writer
2：字节流:InputStream OutputStream
】
自译：【1：三种文件表示形式：
File f = new File("g:/day18.txt")
File f2 = new File("g:\\prop.txt");
File f3 = new File("g:"+File.separator+"file.txt");
f3.exists()：判断文件是否存在f3.createNewFile();//创建这个对象所表示的文件f.delete();//用于删除指定的文件
】
【2：创建实际的目录
File f2 = new File("g:/practice2"); f2.mkdir();
3：生成一个生层次的目录结构：Filefolder = new File("g:/a/b/d/c/d/e/f/g"); folder.mkdirs();
】
【4：返回目录下所有的文件
File[] files = folder.listFiles();
for (File file : files) {//循环遍历这个文件数组
System.out.println(file.getPath()); //打印出每个文件的路径
Date d=newDate();
d.setTime(file.lastModified()); //最后一次修改的时间
System.out.println(file.getName()+","+d.toString());//打印每个文件的名字
}
】
5过滤某文件夹下的文件：
【
//后缀过滤器(文件过滤器)
class SuffixFilter implements FileFilter {
@Override
//是一个回调方法，在listFiles时回调
publicboolean accept(File file) {
//如果文件以.zip结尾并且不是目录
if(file.getName().endsWith(".zip") && file.isFile()) {
returntrue; //返回true,表示接受这个文件，保留下来
}
returnfalse; //返回false,表示不接受，过滤掉
}
}
调用：
File folder = new File("g:/" + File.separator +"千锋课堂软件");
//列出....下文件，过滤标准是从参数传入的后缀过滤器对象
File[]files = folder.listFiles(new SuffixFilter());
for(File f : files) { //遍历过滤后的文件数组
System.out.println(f.getName());
}
使用匿名内部类实现文件过滤：
File folder = newFile("g:"+File.separator+"手头查询文档");
File[]files = folder.listFiles(new FileFilter() {
//这个方法会在listFiles时被回调，来判断每个文件是保留还是丢弃
@Override
publicboolean accept(File file) {
//如果以"张"开头并且是文件
if(file.getName().startsWith("大话")&&file.isFile()){
returntrue; //保留
}
returnfalse; //否则过滤掉
}
});
for(File file : files) {
System.out.println(file.getName());
}
】
6：递归调用遍历文件，区分文件和目录
【
Filefolder = new File("g:"+File.separator+"a");
showAll(folder);
}
//如果是目录,显示目录中所有文件，如果是一个文件，直接打印名字
privatestatic void showAll(File file) {
if(file.isFile()){ //如果是文件
System.out.println(file.getName());//打印出名字
}else{//如果是目录
File[]files = file.listFiles(); //列出所有文件、目录
for(File f : files) {//遍历每个文件、目录
showAll(f); //对每个文件、目录再进行递归调用
}
}
}
】
7：文件的复制
【
FileInputStream fis = newFileInputStream("G:/杜维瀚-我就喜欢你这样的丫头.zip");
FileOutputStreamfos = new FileOutputStream("G:/徐杜维瀚-我就喜欢你这样的丫头.zip");
intn = 0;
while((n = fis.read()) != -1) { //每次读一个字节//从a文件中读，写到b文件中
fos.write(n);//写到另一个文件中
System.out.println("复制完成!");
fos.close();
fis.close();
}
带缓存形式复制文件
FileInputStream fis = newFileInputStream("g:/韩红-一个人.zip");
FileOutputStreamfos = new FileOutputStream("g:/有韩红-一个人.zip");
byte[]buf = new byte[1024]; //缓冲
intn= 0; //保存返回信息
//这种方式拷贝1024个字节只操作一次磁盘，效率较高
while((n=fis.read(buf))!=-1){//循环读数据到缓存中
fos.write(buf,0, n); //将缓存中有效数据写到文件中
}
fos.close();
fis.close();
】
【
//方式一
File file = newFile("g:\\demo.txt");
方式二
Filefile2 = new File("g:\\", "demo.txt");
//方式三
File dir = newFile("g:\\filetest");
File file3 = new File(dir,"demo.txt");
//File的成员字段
//路径分隔符，不同系统的路径分隔符可能不同，通过该静态常量可以获取到和系统相关的路径分隔符
System.out.println(File.pathSeparator);
System.out.println(File.pathSeparatorChar);
//名称分隔符，不同的系统名称分隔符不同
//注意：在windows下，应该使用“\”(反斜杠)，但实际正反都支持
System.out.println(File.separator);
System.out.println(File.separatorChar);
Filefile = new File("G:\\filetest");
/* //获取指定文件夹下的所有子文件(夹)的名称
String[] fileNames =file.list();
for (String fileName :fileNames) {
System.out.println(fileName);
}
//获取指定文件夹下所有的子文件(夹)的File对象
File[] files =file.listFiles();
for (File f : files) {
System.out.println(f.getAbsolutePath());
}*/
】
【
getName()获取文件名
listRoots()获取所有磁盘的根目录（静态方法）
getTotalSpace()获取当前所在磁盘的总大小（单位：字节）
《//磁盘的总大小
System.out.println(file3.getTotalSpace()/1024/1024/1024+"GB");》
getFreeSpace()获取当前所在磁盘的剩余空间（单位：字节）
lastModified()获取最后修改时间(1970到现在所经过的毫秒值)
《SimpleDateFormatsdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
System.out.println(sdf.format(file3.lastModified()));》
length()获取文件的大小（单位：字节）
getParent()获取父目录的路径
getPath()获取相对路径
getAbsolutePath()获取绝对路径
】
【
delete()删除文件或文件夹
mkdirs()创建多级目录
mkdir()创建文件夹（创建成功，返回true，否则返回false）
createNewFile()创建文件（如果文件不存在，就创建，如果存在，就不创建并返回false
】
【
isHidden()判断是否是隐藏文件
isFile()判断是否是文件
isDirectory()判断是否是目录
exists()判断是否存在
】
【
renameTo(Filedest)移动并改名
】
【
listFiles(FileFilterfilter)
listFiles(FilenameFilterfilter)
list(FilenameFilterfilter)
FilenameFilter：文件名过滤器接口
FileFilter：文件过滤器接口
《
文件名过滤器，实现接口
classMyFileNameFilter implements FilenameFilter{
/**
*文件过滤的规则
*返回值得意思就是判断指定的文件是否通过过滤
*如果是true代表通过过滤
*/
@Override
public boolean accept(File dir, Stringname) {
System.out.println(dir.getAbsolutePath());
returnname.endsWith(".txt");
}
}
File[] files =file.listFiles(new MyFileNameFilter());
System.out.println("数组内容");
for (File f : files) {
System.out.println(f.getAbsolutePath());
}
匿名内部类文件过滤器
File[] files =file.listFiles(new FileFilter() {
@Override
public booleanaccept(File file) {
System.out.println(file.getAbsolutePath());
return file.getName().endsWith(".txt");
}
});
System.out.println("数组内容");
for (File f : files) {
System.out.println(f.getAbsolutePath());
}
》
】
【
//2.输出一个文件夹（包括子目录）中的所有文件的名称（使用File和递归来实现）
public class Ex1 {
public static void main(String[] args){
File dir = newFile("g:\\anjavaworkspaseTest");
bianLi(dir);
}
/**
*遍历输出指定文件中的文件(夹)的名称
* @param dir
*/
private static void bianLi(File dir){
System.out.println(dir.getName());
//获取文件夹中的所有子文件(夹)
File[] files = dir.listFiles();
for (File f : files) {
if(f.isFile()){
System.out.println(f.getName());
}else{
bianLi(f);
}
}
}
}
递归删除文件
// 3.使用file类的delete方法和递归算法删除一个文件夹（带有内容）
public static void main(String[] args){
// TODO Auto-generated methodstub
File dir= new File("g:\\testDirFile");
deleterDir(dir);
}
//删除指定的文件（包含内容）
privatestatic void deleterDir(File dir) {
//写代码需要保证代码的健壮性
//入参检测
//删除文件中的所有内容
//如果File对象描述的是文件，调用listFiles方法后返回的是null
if(dir== null ||!dir.isDirectory()){
thrownew IllegalArgumentException("File对象不能为空，并且只能是文件");
}
File[]file = dir.listFiles();
for(File f : file) {
if(f.isFile()){
f.delete();
}else{
//如果是文件夹，就需要先删除文件中的内容，在删除文件
deleterDir(f);
}
}
//删除文件夹本身(空文件夹)
dir.delete();
}
】
【
❖ 对文件的操作：
◦publicbooleancreateNewFile()//不存在时创建此文件对象所代表的空文件
◦publicbooleandelete()//删除文件。如果是目录必须是空才能删除
◦publicbooleanmkdir()//创建此抽象路径名指定的目录
◦publicbooleanmkdirs()//创建此抽象路径名指定的目录，包括所有必需但不存在的父目录
◦publicbooleanrenameTo(File dest)//重新命名此抽象路径名表示的文件
❖ 浏览目录中的文件和子目录
◦publicString[]list()//返回此目录中的文件名和目录名的数组
◦publicFile[]listFiles()//返回此目录中的文件和目录的File实例数组
◦publicFile[]listFiles(FilenameFilter filter)//返回此目录中满足指定过滤器的文件和目录
●java.io.FilenameFilter接口：实现此接口的类实例可用于过滤文件名
】
将数据存储在磁盘上，断电不消失、程序执行完不消失(之前的大部分练习都将数据存在内存中，断电消失，程序执行完也会消失)
File 表示、描述文件、文件夹的类
构造方法: File(Stringpath)参数是文件的路径
如: "d:\\file.txt"、"d:/folder/file1.txt"
(如果要使用反斜杠，必须用转义符\\来表示;在高级的JDK版本中也可以直接用/来表示;另外File.separator可以自动根据运行的平台转换为"\\"或者"/")
注意:new一个File对象只会在内存中产生一个描述、表示某一个文件的对象，并不会创建这个文件本身
主要方法:
boolean exists()告诉我们这个对象所描述的文件究竟存不存在，存在返回true,不存在返回false
createNewFile()创建新的文件
boolean isFile()如果这个对象表示文件，返回true，否则返回false
boolean isDirectory()如果这个对象表示文件夹，返回true，否则返回false
mkdir()生成一个文件夹、目录
mkdirs()生成一个目录，如果要生成的目录的父目录不存在，会自动创建
File[] listFiles()返回一个目录中的所有文件，以文件数组的形式返回
getPath()获取文件路径
getName()获取文件名
delete()删除文件
boolean canExecute()是否可执行
boolean canRead()是否可读
boolean isHidden()是否是隐藏文件
File[]listFiles(FileFilter filter)返回目录下所有符合过滤器要求的文件的数组
FileFilter是一个接口，要使用它，就用一个类实现它并实现boolean accept(File file)方法,在这个方法里写上过滤的逻辑，符合条件要保留的就返回true，不符合条件要过滤掉的返回 false,参数里的file是要进行判断保留还是不保留的文件
然后实例化这个过滤器类，并传入listFiles()的参数，这样listFiles在列出文件时会依据这个过滤器的逻辑、标准去过滤文件
listFiles只能列一层目录
IO Input输入 Output输出
1、输入流、输出流
2、字节流、字符流
3、节点流、处理流
字节文件读取：
【
FileInputStream fis = newFileInputStream("g:/output.txt");
while(true){
intn = fis.read(); //读一个字节
if(n== -1){//如果达到文件底部
break;
}
System.out.println((char)n); //打印字节对应的字符
}
fis.close();
fis = new FileInputStream("g:/output.txt");
byte[]buf = new byte[4]; //创建长度为4的字节数组缓存
while(true){
//每次从文件中读取4个字节放入缓冲中
intn = fis.read(buf);
if(n== -1){ //读取到文件末尾了
break; //退出
}//遍历缓冲区字节数组，循环条件用n,可以将最后一次的无效数据排除
for(int i=0;i
System.out.println((char)buf[i]); //打印
}
FileInputStream fis = newFileInputStream("g:/output.txt");
byte[]buf = new byte[4]; //创建长度为4的字节数组缓冲
intn = 0;
while((n=fis.read(buf))!=-1){
for(inti=0;i
System.out.println((char)buf[i]);
}
}
fis.close();
】
InputStream抽象类，往里读信息、数据，以字节的形式
int read()：读取单个字节（返回的是int类型）
int read(byte[] buf):读取多个字节，返回的是读取的字节的个数
public intread(byte[] b, int off, int len) throws IOException
public void close()throws IOException
public intavailable() throws IOException
public skip(long n)throws IOException
字节文件输出：
【
FileOutputStream fos = newFileOutputStream("g:/output.txt");//覆盖输出
FileOutputStreamfos = new FileOutputStream("g:/output.txt",true);//追加输出
fos.write(97);
fos.write(98);
fos.write(99);
fos.write(100);
fos.write(101);
fos.close(); //文件流操作结束后，一定要关闭
byte[] buffer ={65,66,67,68,69}; //数据源
try{
FileOutputStreamfos = new FileOutputStream("g:/output.txt");
//从buffer数组中截取下标1开始的3个字节，写到文件中
fos.write(buffer,1, 3);//相比下面的，这种只有写一次磁盘
/*fos.write(66);
fos.write(67); //这种方式要写三次磁盘，要慢一点
fos.write(68);*/
fos.close();
】
OutputStream抽象类，往外写信息、数据，以字节的形式
write(int n)将指定的字节写入此输出流（写出单个字节）
write(byte[] buf,intoff,int len)将b.length个字节从指定的byte数组写入此输出流
public voidwrite(byte[] b, int off, int len) throws IOException将指定byte数组中从偏移量off开始的len个字节写入此输出流
public void flush()throws IOException刷新此输出流并强制写出所有缓冲的输出字节
刷新流的缓存
pulbic void close()throws IOException关闭此输出流并释放与此流有关的所有系统资源
FileInputStream文件输入流、FileOutputStream文件输出流，分别继承了InputStream和OutputStream，分别用来从文件中读数据和写数据
这里的输入和输出，参照物是程序、虚拟机
两个read()和两个write()是他们最重要的方法了。
构造方法FileOutputStream(String path)表示对参数路径的文件创建一个输出流，这个输出流可以用来对这个文件写数据
(如果这个文件不存在，会自动创建)
(最后一定要关闭文件流)
(FileOutputStream(Stringpath,boolean append)可以向原文件追加输出数据，不覆盖原来的信息)
write(int n)表示向输出流中写一个字节的数据
write(byte[] buf,intoff,int len)表示将buf数组中的字节从off位置开始，截取长度len的字节数据写到文件中
(buf是buffer缓冲,off是offset起点,len是length长度)
构造方法FileInputStream(String path)表示对参数路径的文件创建一个输入流，可以用这个输入流读取这个文件的信息
int read()从输入流中一个一个字节读入，如果读到了文件底部，返回-1，否则返回那个读入的字节
int read(byte[] buf)从输入流中几个几个字节读入，每次读取的字节数，由参数中的字节数组长度决定；每次读取出来的这些字节也都按顺序存放在这个字节数组中
如果读到文件底部，返回-1；否则返回实际读的有效字节数
相比无参read()，单参read()每次操作磁盘读多个字节，效率更高
在文件流处理中，关闭流的操作原则上要放在finally中，以确保执行；但是在学习过程中可以先关注重点，把这个问题暂时忽略
文件输入流读取文件：Reader
【
FileReader reader = new FileReader("g:/output.txt");
intn = 0;
while((n= reader.read())!=-1){
System.out.println((char)n);
}
reader.close();
】
文件输出流，从程序中对外写出文件：
【
FileWriter writer = newFileWriter("g:/output.txt); //覆盖的形式
FileWriterwriter = new FileWriter("g:/output.txt",true); //追加的形式
writer.write("敢做敢当，敢拼才会赢！");
writer.write("1000phone");
writer.write("1000phone".toCharArray(),0, "1000phone".toCharArray().length);
writer.close();
for (int i= 1; i <= 10; i++) {
FileInputStreamfis = new FileInputStream("G:/fos.txt");
FileOutputStreamfos = new FileOutputStream("g:/home1" + i + ".txt");
intn = 0;
byte[]buf = new byte[1024];
while((n = fis.read(buf)) != -1) {
fos.write(buf,0, n);
}
fos.close();
fis.close();
}
File folder = new File("g:/home1");
File[]files = folder.listFiles();
byte[]bytes = new byte[16];
for(File file : files) {
System.out.println(file.getName());
FileInputStreamfis = new FileInputStream(file);
intn = fis.read(bytes);
for(inti=0;i
System.out.println(bytes[i]+ " ");
}
System.out.println();
fis.close();
}
】
字符流Reader Writer
FileReader FileWriter
FileReader文件字符输入流
构造方法FileReader(String path)在path路径对应的文件上创建一个文件字符输入流
int read()读一个字符，返回-1表示读到尾部
int read(char[] cbuf)读若干个字符到字符数组缓冲中，返回-1表示读到尾部，否则返回实
际读的字符个数
Close();
FileWriter文件字符输出流
构造方法FileWriter(String path)在path路径对应的文件上创建一个文件字符输出流
write(String s)
write(String s , intoff,int len)
writer(char[] crs)
close();//关闭流，自动刷新缓存注意：一旦流被关闭后就不能再使用，会抛出异常
flush();
write(int c)写一个字符
write(char[] cbuf,intoff,int len)将参数字符缓冲从off开始截取，截取长度len的字符，写到字符输出流中
IO异常处理的注意事项
1、先创建的资源后释放
1、 释放资源的操作必须放在flnally代码块中执行
2、
【
publicint read() throws IOException读取单个字符，返回作为整数读取的字符，如果已到达流的末尾返回-1
publicint read(char[] cbuf) throws IOException 将字符读入数组，返回读取的字符数
publicabstract int read(char[] cbuf, int off, int len) throwsIOException
publicabstract void close() throws IOException 关闭该流并释放与之关联的所有资源
publiclong skip(long n) throws IOException 跳过n个字符。
】
【
public voidwrite(int c) throws IOException写入单个字符
public voidwrite(char[] cbuf) throws IOException写入字符数组
public abstract voidwrite(char[] cbuf, int off, int len) throws IOException写入字符数组的某一部分
public voidwrite(String str) throws IOException写入字符串
public voidwrite(String str, int off, int len) throws IOException写字符串的某一部分
public abstract voidclose() throws IOException关闭此流，但要先刷新它
public abstract voidflush() throws IOException刷新该流的缓冲，将缓冲的数据全写到目的地
还提供了一个FileWriter(String fileName,boolean append)构造方法来指定是否使用追加模式
】
总结：
【
❖ File类
❖ Java流类的分类
◦ 输入流和输出流、字节流和字符流、节点流和过滤(处理)流
❖ 文件流
◦ FileInputStream/FileOutputStream
◦ FileReader/FileWriter
❖ 缓冲流
◦ BufferedInputStream/BufferedOutputStream
◦ BufferedReader/BufferedWriter
❖ 转换流：InputStreamReader/OutputStreamWriter
❖ 数据流：DataInputStream/DataOutputStream
❖ 压缩流：
】
