黑马程序员--IO流中的File类和Properties类、其他流

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
注：视频来源，毕向东老师的 JAVA 基础视频。

第一部分 File类

1）File 类（操作系统中的各种文件或文件夹，如txt文件，文件夹）

1、用来将文件或者文件夹封装成对象。

2、方便对文件与文件夹的属性信息进行操作。

3、File 对象可以作为参数传递给流的构造函数。

4、了解 File 类中的常用方法。

关于流的特性：只能操作数据。

2）File 类的常见方法：

1、创建。

boolean createNewFile()：在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。

boolean mkdir()：创建一级文件夹。

boolean mkdirs()：创建多级文件夹。

2、删除。

boolean f.delete();删除失败时返回false。

void f.deleteOnExit();在程序退出时删除指定文件。

3、判断。

boolean f.canExceute：文件是否可执行。.java文件可以执行，.txt文件就不行了。

boolean exists()：文件是否存在。【重点】

boolean isDirectory()：判断是否是目录

boolean isFile()：判断是否是文件

boolean isHidden()：判断文件是否是隐藏文件

boolean isAbsolute()：判断是否是绝对路径

4、获取信息。

String getName()：获取名称。

String getPath()：相对路径。

String getParent()：获得父目录。

String getAbsolutePath()：绝对路径。

long lastModified()：返回时间。

long length()：返回长度。

File.pathSeparator: 返回当前系统的路径分隔符，默认为 “；”。

File.Separator：返回当前系统的目录分隔符，windows默认为 “\”。

5、重命名

boolean renameTo(File dest)：可以实现移动的效果。剪切+重命名。

3）File 的使用注意点：

1、初始化一个文件对象，但是该对象并未被创建，创建的方法应该对象.createNewFile()。

2、在判断文件对象是否是文件或者目录的时候，必须要先判断该文件对象封装的内容是否存在。

3、File.separator目录分隔符，起到跨平台的作用，因为 windows 下的转义符 “ \ ” 可能在 linux 下就无法正常读取。

4、使用File 的方式删除（delete()）。该方法不可随便乱删。这个方法删除文件是直接清除，并非放回收站。

Demo：

package fuxi2;import java.io.File;import java.io.IOException;/** *  *@author XiaLei */public class Day20Test {    public static void main(String[] args) throws IOException {           method_5 ();          }             public static void method_5(){              File f1 = new File("D:\\username1.txt");              File f2 = new File("D:\\username2.txt");              sop("rename："+f1.renameTo(f2));          }          public static void method_4(){              //初始化一个文件对象，但是该对象并未被创建（createNewFile）              File f = new File("D:\\username2.txt");              sop("path:"+f.getPath());       //返回的是              sop("absPath:"+f.getAbsolutePath());              //该方法返回的是绝对路径中的父目录。              //如果获取的是相对路径，则返回null。              //如果相对路径中有上一层目录那么该目录就是返回结果。              sop("parent:"+f.getParent());          }          //重点————————————          public static void method_3() throws IOException{              //初始化一个文件对象，但是该对象并未被创建（createNewFile）              File f = new File("D:\\username2.txt");              //f.createNewFile();              //f.mkdir();创建了【file002.txt】文件夹。。。。。              //记住，在判断文件对象是否是文件或者目录的时候，必须要先判断该文件对象封装的内容是否存在。              //通过 exists 判断              sop("dir:"+f.isDirectory());              sop("file:"+f.isFile());              //文件的隐藏属性              sop(f.isHidden());              //判断是否是绝对路径              sop(f.isAbsolute());          }          public static void consMethod(){              //File 方法封装的只是路径，并不能代表什么              //方法1：将 a.txt 封装成 file 对象。可以将已有的和未出现的文件或者文件夹封装成对象，              File f1 = new File("a.txt");              //方法2：          文件目录            文件名                       File f2 = new File("D:\\","XX.txt");              //方法3：              File d = new File("D:\\");              File f3 = new File(d,"xx.txt");              sop("f1:"+f1);              sop("f2:"+f2);              //目录分隔符，起到跨平台的作用，因为 windows 下的转义符 “ \ ” 可能在 linux 下就无法正常读取              //所以 File.separator 就起到了这个作用。              File f4 = new File("D:"+File.separator+"username2"+File.separator);          }          public static void method_1() throws IOException{              //初始化一个文件对象（并未创建）              File f = new File("D:\\username1.txt");              //告诉虚拟机，等你退出的时候，帮我把它删了              f.deleteOnExit();              //createNewFile()：对初始化的文件对象进行创建文件              sop("create:"+f.createNewFile());              //sop("delete:"+f.delete());          }          public static void method_2(){              File f = new File("D:\\IOStudyTest\\file1.txt");              sop("execute:"+f.canExecute());              //创建文件夹,mkdir只能创建一级目录              File mkdir = new File("D:\\IOS");              sop("mkdir:"+mkdir.mkdir());          }      public static void removeDir(File dir){              File[] files = dir.listFiles();              for(int x = 0;x<files.length;x++){                  //删除非隐藏文件                  if(!files[x].isHidden()&&files[x].isDirectory()){                      removeDir(files[x]);                  }                  System.out.println(files[x].toString()+"-files-"+files[x].delete());              }              System.out.println(dir+"-dir-"+dir.delete());      }          public static void sop(Object obj){              System.out.println(obj);          }      }

4）FileList

1、注意：调用 list 方法的 file 对象必须是封装了一个目录。该目录还必须是存在的。

2、FilenameFilter：文件过滤器。重写 FilenameFilter 接口中的accept 方法创建一个字符串数组，用来存储文件地址中的文件的名称。用匿名内部类的使用方式，用来过滤文件。

Demo：

package fuxi2;import java.io.File;import java.io.FilenameFilter;/** *  *@author XiaLei */public class Day20Test1 {    public static void main(String[] args) {        File dir = new File("d:\\JAVA\\day20");        String[] names = dir.list(new FilenameFilter(){//list方法返回的是名称，包括隐藏文件            //FilenameFilter是一个接口，内部只有一个accept方法，所以采用匿名内部类创建子类对象传入list（）方法中，起到了对文件过滤的作用。            public boolean accept(File dir,String name){                return name.endsWith(".java");            }        });        for(String name : names){            System.out.println(name);        }        File dirs = new File("D:\\");        File[] files = dirs.listFiles();//listFiles返回的是文件对象        for(File file : files){            if(file.length()==0)                file.delete();//对文件经行操作，如果是空文件就删除            System.out.println(file.getName());        }    }}

3、dir.listFiles()：列出指定目录下的文件或者文件夹，包含子目录中的内容。也就是列出指定目录下的所有内容。因为目录中还有目录，只要使用同一个列出目录功能的函数，即可。

4、递归 ：在列出过程中出现的还是目录的话，可以再次调用本功能，也就是函数自身调用自身，这种表现形式（编程手发）称为递归。

Demo 1：

package fuxi2;import java.io.File;/** * 需求：列出指定目录下所有内容。 *@author XiaLei */public class Day20Test2 {    public static void main(String[] args) {        File dir = new File("D:\\Demo");        diGuiFile(dir);    }    public static void diGuiFile(File dir){        System.out.println(dir);        File[] files = dir.listFiles();            for(File file : files){                if(file.isDirectory())                    diGuiFile(file);//递归，即函数自己调用自己。注意：1.限定条件；2.注意递归次数，小心内存溢出。                else if(file.getName().endsWith(".java"))                    System.out.println(file.getName()); //打印所有后缀名为".java"的文件。                                               }       }}

Demo 2：

package fuxi2;import java.io.File;/** * 需求：删除一个带内容的目录。 * 原理：windows删除文件是从里外删，所以要用到递归。 *@author XiaLei */public class Day20Test3 {    public static void main(String[] args) {        File dir = new File("D:\\Demo");        deleteDir(dir);    }    public static void deleteDir(File dir){        File[] files = dir.listFiles();        for (File file : files){            if(file.isDirectory())                deleteDir(file);            file.delete();        }        dir.delete();//删除文件夹。    }}

5、FileList练习：将一个指定目录下的java 文件的绝对路径，存到一个文本文件中。建立一个 java 文件列表。

package fuxi2;import java.io.BufferedWriter;import java.io.File;import java.io.FileWriter;import java.io.IOException;import java.util.ArrayList;import java.util.List;/** * 需求：将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。即建立一个java文件列表。 * 思路：1.对指定目录进行递归； * 2.递归过程中获取文件的绝对路径； * 3.将这些路径存储到集合中； * 4.将集合中的数据写入文件中。 *@author XiaLei */public class Day20Test4 {    public static void main(String[] args) throws IOException {        List<String> list =new ArrayList<String>();        File dir = new File("D:\\Demo");        diGuiFile(dir,list);        BufferedWriter bufw = new BufferedWriter(new FileWriter("D:\\javaliebiao.txt"));        for (String l : list){            bufw.write(l);            bufw.newLine();            bufw.flush();        }        bufw.close();           }    public static List<String> diGuiFile(File dir,List<String> list){        File[] files = dir.listFiles();            for(File file : files){                if(file.isDirectory())                    diGuiFile(file,list);//递归，即函数自己调用自己。注意：1.限定条件；2.注意递归次数，小心内存溢出。                else if(file.getName().endsWith(".java"))                    list.add(file.getAbsolutePath());   //打印所有后缀名为".java"的文件。                                               }               return list;    }}

第二部分 Properties类

1、Properties 是 hashTable 的子类。也就是说它具备 map 集合的特点，而且它里面存储的键值对都是字符串。是集合和IO技术相结合的集合容器。那么 map + IO 就是 Properties。

2、该对象的特点：可以用于键值对形式的配置文件。那么在加载数据时候，需要数据有固定格式：键=值。

3、优点：配置文件可以实现应用程序数据的共享。该配置文件使用键值对的形式，这样便于阅读与操作数据。

4、练习：

package fuxi2;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.util.Properties;/** * 需求：定义一个计数器程序，当达到指定使用次数，该程序无法运行。 * 思路：计数器定义在程序内无法实现功能，必须要保存到文件中。 * 考虑到用键值对形式保存比较便于阅读，则需要用到Map集合， * 那么跟Map集合和IO流相结合的Property类就是需要用到的对象。 *@author XiaLei */public class Day20Test7 {    public static void main(String[] args)throws IOException {        run();    }    private static void run() throws IOException {        Properties prop = new Properties();        //把配置文件封装在 File 文件对象中，方便对文件的判断是否存在等。        File file = new File("D:\\info.txt");            if(!file.exists())                //判断文件是否存在。                file.createNewFile();            //因为流无法对判断配置文件是否存在。            FileInputStream fis = new FileInputStream(file);            prop.load(fis); //从输入字节流中读取属性列表（键和元素对）。又称将流中的数据加载进集合。            int count = 0;            String value = prop.getProperty("time");            if(value!=null){                count = Integer.parseInt(value);                if(count==5){                    System.out.println("请付费");                    return;                }                else                System.out.println("欢迎使用");            }            count++;                prop.setProperty("time", count+"");//将次数记录住集合               FileOutputStream fos = new FileOutputStream(file);            prop.store(fos, "hehe");//将数据存储到流中。            fis.close();            fos.close();    }}

第三部分 IO中的其它流

1、打印流：该流提供了打印方法，可以将各种数据类型的数据原样打印。

2、字节打印流：PrintStream

构造函数可以接收的参数类型：

1）file 对象。File

2）字符串路径。String

3）字节输出流。OutputStream

3、字符打印流：PrintWriter

构造函数可以接收的参数类型：

1）file 对象。File

2）字符串路径。String

3）字节输出流。OutputStream

4）字符输出流。Writer

4、合并流：SequenceStream，用于多个文件流的合并。

5、管道流：PipedInputStream 和 PipedOutputStream。输入输出可以直接进行连接，通过结合线程使用。

6、对象流 ObjectInputStream 和 ObjectOutputStream

持久化：就是将对象保存到硬盘中

没有方法的接口：通常称为标记接口

序列化 {@link Serializable}静态的成员变量是不能被序列化的。如果非静态变量也不想被序列化，就加 Transient。保证了成员变量只能在堆内存中存在，不能再文本中存在。

使用了 ObjectInputStream 存储，只能使用 ObjectOutputStream 才能读取出来。

7、RandomAccessFile随机访问文件

1、RandomAccessFile：随机访问文件。该类不算是 IO 体系中的子类。而是直接继承自 Object。但是它是 IO 包中的成员，因为它具备读和写的功能。内部封装了一个数组，而且通过指针对数组的元素进行操作。可以通过 getFilePointer 获取指针位置，同时可以通过 seek 改变指针的位置。

2、其实，完成读写的原理就是内部封装了字节流的输入和输出流。通过构造函数可以看出，该类只能操作文件。而且操作文件还有模式：只读 r ，读写 rw 等。如果模式为只读 r 。不会创建文件，回去读取一个已经存在的文件，如果该文件不存在，则会出现异常。如果模式为读写 rw 。那么操作的文件不存在，则会自动创建，如果存在则不会覆盖。

RandomAccessFile可以用来实现多线程的下载,随机读写访问。IO 中，只有它可以实现多线程的读写。

练习：

package fuxi2;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;import java.util.TreeSet;/** * 需求：有5个学生，每个学生有3门课成绩，从键盘上输入以上数据（包括姓名，3门课成绩） * 输入的格式如：zhangsan，67，87，89 计算出总成绩，并把学生的姓名和3门课总成绩 * 按高低顺序放入到指定文件中。 * 思路:1.创建学生对象，具备需求属性，即计算总成绩，并具备比较性。 *  2. 先建立键盘读取流，按照“，”分割将数据读取出来。 *  3.因为要排序，创建TreeSet集合，存储数据。 *  4.创建打印流将数据放入指定目录。 *  *@author XiaLei */public class Day20Test8 {    public static void main(String[] args) throws IOException {        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));        TreeSet<Student> ts = new TreeSet<Student>();        String line = null;        Student stu = null;        while((line = bufr.readLine())!=null){            int sum = 0;            if("over".equals(line))                break;            String[] str = line.split(",");            String name = str[0];            for(int x = 1;x<str.length;x++){                sum+=Integer.parseInt(str[x]);            }            stu = new Student(name,sum);            ts.add(stu);        }        PrintWriter pw = new PrintWriter("D:\\Student.txt");        for(Student str : ts){            pw.println(str);        }        bufr.close();        pw.close();    }}class Student implements Comparable<Student>{    private String name;    private int sum;    public Student(String name, int sum) {        super();        this.name = name;        this.sum = sum;    }    public int compareTo(Student s) {        int x = s.sum-this.sum;        if(sum==0)            return s.name.compareTo(this.name);        return x;    }    public String toString(){        return name+"="+sum+"";    }}

第四部分 编码

1、ASCII：美国标准信息交换码。用一个字节的7位可以表示。

2、ISO8859-1：拉丁码表，欧洲码表。用一个字节的。

3、GB2312：中国的中文编码。

4、GBK：中国的中文编码表升级，融合了更多的中文文字字符。

5、Unicode：国际标准码。融合了多种文字。所有文字都用两个字节来表示，java 语言使用的就是 Unicode。

6、UTF-8：最多用三个字节来表示一个字符。

7、特殊汉字：联通。原因是UTF-8编码带有头字符标记。