java IO流 File类，Properties--20

File类

用来将文件或者文件夹封装成对象
方便对文件与文件夹的属性信息进行操作
File对象可以作为参数传递给流的构造函数

File类中的常见方法：
1，创建
boolean createNewFile();
在指定位置创建文件，如果文件已经存在，返回false，不创建文件
和输出流不一样，输出流对象一建立就会创建文件，而且如果文件已经存在，会覆盖

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

2，删除
boolean delete();删除失败返回false
void deleteOnExit();在程序退出时删除指定文件

3，判断
boolean exists();文件是否存在
boolean canExecute();文件是否能执行

boolean isFile();是否是文件
boolean isDirectory();是否是目录
boolean isHidden();是否是隐藏文件

4，获取信息
getName();返回由此抽象路径名表示的文件或目录的名称。
getPath();将此抽象路径名转换为一个路径名字符串。
getParent();返回此抽象路径名绝对父目录的路径名字符串；如果此路径名没有绝对父目录，则返回 null。
如果是相对路径，也返回null

getAbsolutePath();返回此抽象路径名的绝对路径名字符串，拿到的都是绝对路径
long lastModified(); 返回此抽象路径名表示的文件最后一次被修改的时间。
long length();返回文件大小

import java.io.*;
class FileDemo
{
    public static void main(String[] args)throws IOException
    {
        method_5();
    }

    public static void method_1()throws IOException
    {
        File f = new File("file.txt");
        //f.deleteOnExit();
        //sop("create:"+f.createNewFile());//创建文件
        sop("delete:"+f.delete());

    }

    public static void method_2()
    {
        File f = new File("file.txt");

        //sop("exists:"+f.exists());

        //sop("execute:"+f.canExecute());


        //创建文件夹
        File dir = new File("abc\\a\\d\\gf\\gh\\cdf");

        sop("mkdirs:"+dir.mkdirs());
    }

    public static void method_4()
    {
        File f = new File("a.txt");

        sop("path:"+f.getPath());
        sop("Abpath:"+f.getAbsolutePath());
    }

    public static void method_5()
    {
        File f1 = new File("c:\\a.txt");
        File f2 = new File("d:\\b.txt");

        //sop("rename:"+f1.renameTo(f2));
        sop(f2.length());
    }



    //创建File对象
    public static void consMethod()
    {
        //将a.txt封装成file对象。可以将已有的和未出现的文件或者文件夹封装成对象
        File f1 = new File("a.txt");

        File f2 = new File("c:\\abc","b.txt");

        File d = new File("c:\\abc");
        File f3 = new File(d,"c.txt");

        sop("f1:"+f1);
        sop("f2:"+f2);
        sop("f3:"+f3);

        File f4 = new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");
        //File.separator与\\作用相同，但是前者可以跨平台
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

}

import java.io.*;

class FileDemo2
{
    public static void main(String[] args)
    {
        File dir = new File("c:\\");


        File[] files = dir.listFiles();

        for(File f:files)
        {
            System.out.println(f.getName()+"..."+f.length());
        }

    }

    public static void listDemo_2()
    {
        File dir = new File("d:\\java0217\\day18");

        String[] arr = dir.list(new FilenameFilter()
        {
            public boolean accept(File dir,String name)
            {
                return name.endsWith(".java");
            }
        });

        System.out.println("len:"+arr.length);

        for(String name :arr)
        {
            System.out.println(name);
        }
    }



    public static void listDemo()
    {
        File f = new File("c:\\");//调用list方法的file对象必须是封装了一个目录，该目录还必须存在

        String[] names = f.list();//列出f目录下的所有文件，包含隐藏文件
        for(String name:names)
        {
            System.out.println(name);
        }
    }

    public static void listRootsDemo()
    {
        File[] files = File.listRoots();

        for(File f:files)
        {
            System.out.println(f);
        }
    }
}

列出指定目录下的文件或者文件夹,包含子目录中的内容–递归

package day20;

import java.io.File;

public class FileDemo3 {

    /**
     * 列出指定目录下的文件或者文件夹,包含子目录中的内容
     * 也就是列出指定目录下的所有内容。
     * 
     *
     * 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
     * 在列出过程中出现的还是目录的话，还可以再次调用本功能。
     * 也就是函数自身调用自身，这种表现形式，或者编程手法，成为递归。
     * 
     * 递归要注意：
     * 1，限定条件。
     * 2，要注意递归的次数，避免内存溢出。
     * 
     */
    public static void main(String[] args) {
        //
        File dir = new File("D:\\java0217");
        showDir(dir);
    }

    public static void showDir(File dir){
        System.out.println("---------------------------------");
        System.out.println(dir);
        File[] files = dir.listFiles();
        for(File f:files){
            if(f.isDirectory())
                showDir(f);
            else
                System.out.println(f);
        }
    }

}

删除带内容的目录–递归

package day20;

import java.io.File;

public class RemoveDir {

    /**
     * 删除一个带内容的目录
     * 删除原理：
     * 在windows中，删除目录是从里面往外删除的
     * 
     * 既然是从里往外删除，就需要用到递归。
     * 
     */
    public static void main(String[] args) {
        File dir = new File("D:\\创新项目");
        removeDir(dir);

    }

    public static void removeDir(File dir){
        File[] files = dir.listFiles();
        for(File f : files){
            if(f.isDirectory())
                removeDir(f);
            else
                System.out.println(f+"files"+f.delete());
        }
        //每一个文件夹内的文件删除完毕，最后把该文件夹删除
        System.out.println(dir+"dir"+dir.delete());
    }
}

练习

将一个指定目录下的java文件的绝对路径，存储到文本文件中。
建立一个java文件列表文件。

思路：
1，对指定的目录进行递归
2，获取递归过程中所有的java文件路径
3，将这些路径存到集合中。
4，将集合中的数据写入到一个文件中。

package day20;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class JavaFileList {


    public static void main(String[] args) {
        File dir = new File("D:\\java0217");
        List<File> list = new ArrayList<File>();
        fileToList(dir,list);

        //System.out.println(list.size());

        File javaListFile = new File(dir,"javaListFile.txt");
        writeToFile(list,javaListFile);
    }

    public static void fileToList(File dir,List<File> list){
        File[] files = dir.listFiles();
        for(File file:files){
            if(file.isDirectory())
                fileToList(file, list);
            else{
                if(file.getName().endsWith(".java"))
                    list.add(file);
            }
        }
    }

    public static void writeToFile(List<File> list,File javaListFile){
        BufferedWriter bufw = null;
        try {
                bufw = new BufferedWriter(new FileWriter(javaListFile));
                for(File f:list){
                    String path = f.getAbsolutePath();
                    bufw.write(path);
                    bufw.newLine();
                    bufw.flush();
                }
        } catch (IOException e) {
            throw new RuntimeException("写入失败");
        }
        finally{
            try {
                if(bufw!=null)
                    bufw.close();
            } catch (IOException e) {
                throw new RuntimeException("写入失败");
            }
        }
    }

}

Properties类

Properties是hashtable的子类
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串，不需要泛型。

是集合中和IO技术相结合的集合容器。

该对象的特点，可以用于键值对形式的配置文件。

那么在加载数据时，需要数据有固定的格式：键=值

package day20;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class PropertiesDemo {


    public static void main(String[] args) {
        //setAndGet();
        //method_1();
        loadDemo();

    }

    /**
     * loadDemo是method_1在java内的封装表现，
     * 也就是说，method_1是loadDemo的原理
     * 
     */
    public static void loadDemo(){
        Properties prop = new Properties();
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("D:\\Eclipse Java SE_work space\\java0623\\src\\day20\\info.txt");
//          将流中的数据加载进集合
            prop.load(fis);
            prop.setProperty("lisi", "32");
//          fos的位置会影响输出结果。
//          更改集合中的内容，并把更改后的内容存储到info.txt中
            fos = new FileOutputStream("D:\\Eclipse Java SE_work space\\java0623\\src\\day20\\info.txt");
            prop.store(fos, "zhushi");
        } catch (IOException e) {

            throw new RuntimeException("导入失败");
        }
        finally{
            try {
                if(fis!=null)
                    fis.close();
            } catch (IOException e) {
                throw new RuntimeException("读取流关闭失败");
            }
            try {
                if(fos!=null)
                    fos.close();
            } catch (IOException e) {
                throw new RuntimeException("输出流关闭失败");
            }
        }



        //System.out.println(prop);
        prop.list(System.out);
    }

    /**
     * 演示：
     * 如何将流中的数据存储到集合中。
     * 想要将info.txt文件中键值数据存储到集合中操作。
     * 
     * 思路：
     * 1，用一个流和info.txt文件关联。
     * 2，读取一行数据，将该行数据用“=”进行切割。
     * 3，等号左边为键，等号右边为值，存入到Properties集合中即可。
     * 
     */
    public static void method_1(){
        BufferedReader bufr = null;
        String line = null;
        Properties prop = new Properties();
        try {
            bufr = new BufferedReader(new FileReader("D:\\Eclipse Java SE_work space\\java0623\\src\\day20\\info.txt"));

            while((line=bufr.readLine())!=null){
//              在等号处分割,并存入数组，等号左边是arr[0],等号右边是arr[1]
                String[] arr = line.split("=");
//              System.out.println(arr[0]+"....."+arr[1]);
                prop.setProperty(arr[0],arr[1]);
            }

            System.out.println(prop);

        } catch (IOException e) {
            throw new RuntimeException("读取失败");
        }
        finally{
            try {
                if(bufr!=null)
                    bufr.close();
            } catch (IOException e) {
                throw new RuntimeException("读取失败");
            }
        }
    }


    //设置和获取元素
    public static void setAndGet(){
        Properties prop = new Properties();
        prop.setProperty("zhangsan","30");
        prop.setProperty("lisi","39");

        System.out.println(prop);

        String value = prop.getProperty("lisi");
        System.out.println(value);

        prop.setProperty("lisi", 100+"");

        Set<String> names = prop.stringPropertyNames();
        for(String s:names){
            System.out.println(s+":"+prop.getProperty(s));
        }
    }
}

setAndGet()演示图片

method_1()演示图片

loadDemo()演示图片

练习：制作注册提示信息

用于记录应用程序运行次数
如果使用次数已到，那么给出注册提示。

很容易想到的是计数器，
该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增
可是随着该应用程序的退出，该计数器也在内存中消失了。
下一次在启动该程序，又重新开始从零计数。
这样不是我们想要的

我们希望的是程序即使结束，该计数器的值也存在，
下次程序启动会先加载该计数器的值，并加一后重新存储起来。

所以要建立一个配置文件，用于记录该软件的使用次数。

该配置文件使用键值对的形式
这样便于阅读并操作数据

键值对数据是Map集合
数据是以文件形式存储，使用IO技术
那么IO+Map———>properties

配置文件可以实现应用程序数据的共享

dom4j是常用的配置文件创建工具（dom for java）

package day20;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class RunCount {

    public static void main(String[] args) {
        Properties prop = new Properties();

        File file = new File("count.ini");

        FileInputStream fis = null;
        FileOutputStream fos = null;

        int count = 0;

        try {
            if(!file.exists())
                file.createNewFile();

            fis = new FileInputStream(file);

            prop.load(fis);

            String value = prop.getProperty("time");
            if(value!=null){
                count = Integer.parseInt(value);
                if(count>=5){
                    System.out.println("使用次数到达上限，请注册后继续使用");
//                  加入return语句使count到达5次后不继续增加，而是返回。
//                  没有return语句count会一直增加。
                    return;
                }
            }


            count++;
            prop.setProperty("time", count+"");
            fos = new FileOutputStream(file);

            prop.store(fos,"zhushixinxi");

        } catch (IOException e) {
            throw new RuntimeException("文件创建失败");
        }
        finally{
            try {
                if(fis!=null)
                    fis.close();
            } catch (IOException e) {
                throw new RuntimeException("读取流关闭失败");
            }
            try {
                if(fos!=null)
                    fos.close();
            } catch (IOException e) {
                throw new RuntimeException("打印流关闭失败");
            }
        }

    }

}

打印流

打印流：
PrintStream和PrintWriter
可以直接操作输入流和文件

该流提供了打印方法，可以将各种数据都原样打印。

字节打印流：PrintStream
构造函数可以接收的参数类型：
1，File对象 File
2，字符串路径 String
3，字节输出流 OutputStream

字符打印流：PrintWriter
构造函数可以接收的参数类型：
1，File对象 File
2，字符串路径 String
3，字节输出流 OutputStream
4，字符输出流 Writer

package day20;

import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class PrintStreamDemo {


    public static void main(String[] args) throws IOException{
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

        PrintWriter pw = new PrintWriter(System.out,true);
//      true前面必须是流，刷新只对于流而言。如果不是流，可以封装成流对象。
//      PrintWriter pw = new PrintWriter(new FileWriter("a.txt"),true);

        String line = null;
        while((line = bufr.readLine())!=null){
            if("over".equals(line))
                break;
//          println带有换行标记，可以 通过(System.out,true)来进行刷新，没有换行标记不能通过 true刷新
            pw.println(line.toUpperCase());
//          pw.flush();
        }

        pw.close();
        bufr.close();
    }

}

序列流

将多个读取流合并成一个读取流
Sequence没有OutputStream，只有InputStream

package day20;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class SequenceDemo {

    public static void main(String[] args)throws IOException {

        Vector<FileInputStream> v = new  Vector<FileInputStream>();

        v.add(new FileInputStream("c:\\1.txt"));
        v.add(new FileInputStream("c:\\2.txt"));
        v.add(new FileInputStream("c:\\3.txt"));

        Enumeration<FileInputStream> en = v.elements();

        SequenceInputStream sis = new SequenceInputStream(en);

        FileOutputStream fos = new FileOutputStream("c:\\4.txt");

        byte[] buf = new byte[1024];

        int len = 0;
        while((len=sis.read(buf))!=-1){
            fos.write(buf,0,len);
        }

        fos.close();
        sis.close();
    }

}

文件的切割与合并

将MP3文件切割（splite）成part文件，再合并（merge）成一个新的MP3文件

package day20;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;

public class SpliteFile {

    public static void main(String[] args) {
        spliteFile();
        merge();
    }


    public static void merge(){
        ArrayList<FileInputStream> al = null;

        FileOutputStream fos = null;

        SequenceInputStream sis = null;

        byte[] buf = new byte[1024];
        int len = 0;

        try {
            al = new ArrayList<FileInputStream>();

            for(int x =1;x<5;x++){
                al.add(new FileInputStream("c:\\splitefiles\\"+x+".part"));
            }
            final Iterator<FileInputStream> it = al.iterator();

            Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){
                public boolean hasMoreElements(){
                    return it.hasNext();
                }
                public FileInputStream nextElement(){
                    return it.next();
                }
            };

            sis = new SequenceInputStream(en);

            fos = new FileOutputStream("c:\\splitefiles\\2.mp3");
            while((len = sis.read(buf))!=-1){
                fos.write(buf,0,len);
            }




        } catch (IOException e) {
            throw new RuntimeException("文件合并失败");
        }

        finally{
            try {
                if(sis!=null)
                    sis.close();
            } catch (IOException e) {
                throw new RuntimeException("序列流关闭失败");
            }
            try {
                if(fos!=null)
                    fos.close();
            } catch (IOException e) {
                throw new RuntimeException("输出流关闭失败");
            }
        }



    }


    public static void spliteFile() {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        byte[] buf = new byte[1024 * 1024];
        int len = 0;
        int count = 1;

        try {
            fis = new FileInputStream("c:\\1.mp3");

            while ((len = fis.read(buf)) != -1) {
//              count++第一次出现时不自增，代表count的值
                fos = new FileOutputStream("c:\\splitefiles\\"+(count++)+".part");

                fos.write(buf, 0, len);
            }

        } catch (IOException e) {
            throw new RuntimeException("文件切割失败");
        }

        finally {
            try {
                if (fis != null)
                    fis.close();
            } catch (IOException e) {
                throw new RuntimeException("读取流关闭失败");
            }
            try {
                if (fos != null)
                    fos.close();
            } catch (IOException e) {
                throw new RuntimeException("输出流关闭失败");
            }
        }
    }
}