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()获取文件的大?。ǖノ唬鹤纸冢?/p>
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、节点流、处理流
字节文件读?。?/b>
【
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
?? 压缩流：
】
