黑马程序员——Java基础---IO(三)--File类、Properties类、打印流、序列流（合并流）

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------　　

　　　　　　　　　　　　　　　　　　　File类

一、概述

1、File类：文件和目录路径名的抽象表现形式

2、特点：

        1）用来将文件或文件夹封装成对象

        2）方便于对文件与文件夹的属性信息进行操作，因此是对流操作的一种补充

        3）File类的实例是不可变的；也就是说，一旦创建，File 对象表示的抽象路径名将永不改变

        4）File对象可以作为参数传递给流的构造函数

二、File对象创建

方式一：      

             File f =new File("a.txt");

        将a.txt封装成File对象。可以将已有的和未出现的文件或者文件夹封装成对象。

 方式二：

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

        将文件所在目录路径和文件一起传入，指定文件路径。

 方式三：

            File d=new File("c:\abc");

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

        将文件目录路径封装成对象。再创建文件对象。降低了文件于父目录的关联性。

小知识：

        File.separator表示目录分隔符，可以跨平台使用。相当于路径中的“”（双斜杠\在windows中表示表示转义后的分隔符，但是在linux系统中就不是）。

三、File类的常见方法

import java.io.*;
/*

File 类常见方法
1    创建    
        boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回 false.
                                    和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
        boolean mkdir():创建文件夹。
        boolean mkdirs(): 创建多级文件夹。

2    删除
        boolean delete():删除失败返回false。如果文件正在被使用，则删除不了 返回 false 、
        void deleteOnExit()  ：  在程序退出时删除  指定文件。

3    判断。
        boolean exists():文件是否存在
        isFile();  检查文件名是否为正常文件
        isDirectory()：  是否是路径（目录）
        f.canExecute()    判断文件是否 可执行
        isHidden();        是否为隐藏文件
        isAbsolute():    是否有  绝对路径（目录）

4    获取信息
        getName();//获取文件名

        getpath(): //获取文件的相对路径（即创建的对象传入的参数是什么就获取到什么）

        getParent();   //获取文件父目录。返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。
                      //如果相对路径中有上一层目录，那么该目录就是返回结果。

        getAbsolutePath://获取文件的绝对路径  

        long lastModified()        //返回的是    最后一次修改时间

        long length//返回文件长度
*/
class FileDemo
{
    public static void main(String[] args)throws IOException
    {
        consMethod();
    }
    public static void method_5()
    {
        File f1=new File("file.txt");

        File f2=new File("c:\haha.java");

        sop("rename:"+f1.renameTo(f2));
    }
    public static void method_4()
    {
        File f=new File("file4.txt");
        sop("path:"+f.getPath());//获取相对路径
        sop("abspath"+f.getAbsolutePath());//获取绝对路径
        sop("parent:"+f.getParent());//该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null
                                    //如果相对路径中有上一层目录那么该目录就是返回结果
    }
    public static void method_3()throws IOException
    {
        File f =new File("d:\javalianxi\day20\file2.txt");
        f.createNewFile();//创建文件
        f.mkdir();//创建一级目录
        //记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在。
        //通过exists判断
        sop("dir:"+f.isDirectory());//返回是否是 文件夹
        sop("file:"+f.isFile());  //返回是否是文件
        sop("执行："+f.canExecute());//返回是否可执行
        sop(f.isAbsolute());//返回是否是绝对路径
    }
    public static void method_2()
    {
        File f=new File("file.txt");
        sop("exists:"+f.exists());
        sop("execute:"+f.canExecute());
        //创建文件夹
        File dir=new File("abc\kkk\a\a\dd\ee\qq\aaa");
        sop("mkdir:"+dir.mkdirs());//创建多级目录
    }
    public static void method_1()throws IOException
    {
        File f=new File("file.txt");
        
        //sop("create:"+f.createNewFile());
        //sop("delete:"+f.delete());
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    //创建File对象
    public static void consMethod()throws IOException
    {
        //将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");
        new File("c:\abc").mkdir();
        f2.createNewFile();//创建新文件
        
        sop("f1:"+f1);
        sop("f2:"+f2);
        
        File f4 = new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator/*为跨平台目录符号*/+"a.txt");
        sop("f3:"+f4);
    }
}

5、列出文件及文件过滤

        static File[] listRoots();//列出可用的文件系统根目录，即系统盘符

        String[] list();

        //列出当前目录下所有文件，包括隐藏。调用list方法的file对象必须是封装了一个目录。该目录还必须存在。

        String[]list(FilenameFilter filter);

        //返回一个字符串数组，获取目录中满足指定过滤器的文件或目录。

        //FilenameFilter：文件名过滤器，是一个接口，其中包含一个方法，accept(Filedir,String name)，返回的是boolean型，对不符合条件的文件过滤掉。

        File[] listFiles();//返回一个抽象路径名数组，获取当前文件夹下的所有文件和文件夹

        File[] ListFiles(FilenameFilterfilter);//返回抽象路径名数组，获取目录中满足指定过滤器的文件或目录。

import java.io.*;
class FileDemo2
{
    public static void main(String[] args)
    {
    listRootsDemo();
    }
    public static void listDemo_1()//建立文件dir关联C盘  之后将C盘文件遍历获取名字和长度
    {
        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()//获取一个目录下所有的.java文件方法  
    {
        File dir = new File("d:\javalianxi\day19");
        String[] arr=dir.list(new FilenameFilter()//建立匿名内部类，取出末尾为。java的文件
        {
            public boolean accept(File dir,String name)      
            {
                //System.out.println("dir:"+dir+".....name::"+name);
                /*
                if(name.endsWith(".java"))
                return true;
                else
                return false;*/
                return  name.endsWith(".java");//判断文件名是否是以.java结尾
                
            }

        });
        System.out.println("len:"+arr.length);
        for(String name:arr)  //遍历数组 
        {
            System.out.println(name);
        }
    }
    public static void listDemo()
    {
        File f=new File("c:\abc.txt");
        String[]names =f.list();//调用list方法的file对象必须是封装了一个目录。该目录还必须存在
        for(String name : names)
        {
            System.out.println(name);
        }
    }
    public static void listRootsDemo()
    {
        File[]files =File.listRoots();//列出可用的文件系统根目录，即系统盘符
        for(File f:files)
        {
            System.out.println(f);
        }
    }
}

四、递归

import java.io.*;
/*
列出指定目录下文件或者文件夹，包括子目录中的内容
也就是列出指定目录下所有内容。

因为目录中还有目录，只要使用同一个列出目录功能的函数完成既可。、
在列出过程中出现的还是目录的话，还可以再次调用本功能，
也就是函数自身调用自身。
这种表现形式，或者编程手法，称为递归

递归要注意：
1    限定条件
2    要注意递归的次数，尽量避免内存溢出。因为每次调用自身的时候都会先执行下一次调用自己的方法，
    所以会不断在栈内存中开辟新空间，次数过多，会导致内存溢出。


*/
class FileDemo3
{
    public static void main(String[] args)
    {
        File dir=new File("d:\javalianxi\day18");//关联指定路径
        list(dir,0);
    }
    public static String getLevel(int level)//获取目录为几级目录，目录名前添加"   "，显示出层次感
    {
        StringBuilder sb=new StringBuilder();//建立字符串缓冲区，用来存储空格
        while(level>0){
        sb.append("   ");
        level--;}
        return sb.toString();//返回大量空格
    }
    public static void list(File dir,int level)
    {
        level++;//定义目录等级，多调用一次，目录等级加1
        File files[]=dir.listFiles();////获取本目录下的所以文件和目录的抽象路径
        for(int x=0;x<files.length;x++)
        {
            if(files[x].isDirectory())//判断是否是目录
                list(files[x],level);//是目录，则继续遍历文件
            else
                System.out.println(getLevel(level)+files[x]);//打印出文件名
        }
    }
}

/*
删除一个带内容的目录
删除原理
在windows中，删除目录从里面往外删除的

既然是从里往外删除。就需要用到递归
*/
import java.io.*;
class RemoveDir
{
    public static void main(String[] args)
    {
        File dir=new File("D:\javalianxi\day20\abc - 副本");//关联目录
        removedir(dir);//将目录传入
    }
    public static void removedir(File dir)//删除目录方法
    {
        File[] files=dir.listFiles();//列出目录下的所以文件和文件夹
        for(int x=0;x<files.length;x++)
        {
            if(files[x].isDirectory())//如果文件是目录
                removedir(files[x]);//继续调用本方法
            else
                System.out.println(files[x].toString()+":-file-:"+files[x].delete());//打印文件名，并删除文件，删除成功返回true
        }
        System.out.println(dir+"::dir::"+dir.delete());//删除目录
    }
}

3.将一个指定目录下的java文件的绝对路径，存储到一个文本文件中

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

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

*/
import java.io.*;
import java.util.*;
class  JavaFileList
{
    public static void main(String[] args) throws IOException
    {
        File dir=new File("d:\javalianxi\day19");//关联指定目录
        List <File>list=new ArrayList<File>();//定义一个List集合，用于存储.java文件的File对象 
        fileToList(dir,list);//调用获取文件路径方法 
        File file=new File(dir,"javapath.txt");//指定写入文件
        writeToFile(list,file.toString()); //调用写入文件方法，将集合和文件名传入
        
    }
    public static void fileToList(File dir,List<File> list)//获取指定文件夹内的所有java文件的绝对路径，并存入集合中  
    {
        File files[]=dir.listFiles();//列出dir路径下的所以文件和目录
        for(File file:files)  //遍历 
        {
            if(file.isDirectory())//如果是目录，则继续调用本函数
                fileToList(file,list);
            else
            {
                if(file.getName().endsWith(".java"))//判断是否是java文件
                    list.add(file);//是，将文件存入集合中
            }
        }
        
    }

    public static void writeToFile(List<File> list,String javaListFile)throws IOException
    {
        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 e;
        }
        finally
        {
            try
            {
                if(bufw!=null)
                    bufw.close();
            }
            catch (IOException e)
            {
                throw e;
            }
        }
    }
}

Properties类

一、概述

1、Properties是Hashtable的子类，它具备Map集合的特点。而且它里面还有存储的键值对，都是字符串，无泛型定义。是集合中和IO技术相结合的集合容器。

2、特点：

        1）可用于键值对形式的配置文件

        2）在加载时，需要数据有固定的格式，常用的是：键=值

二、特有方法

1、设置

        Object setProperty(String key,String value);

        //设置键和值，调用Hashtable的方法put

2、获取

        String getProperty(String key);

        //指定key搜索value

        Set<String> stringPropertyName();

        //返回属性列表的键集，存入Set集合

3、加载流和存入流

        void load(InputStream ism);

        //从输入字节流中读取属性列表（键和元素对）。又称将流中的数据加载进集合。

        void load(Readerreader);

        //从输入字符流中读取属性列表（键和元素对）。又称将流中的数据加载进集合。

        voidlist(PrintStream out);//将属性列表输出到指定的输出流

        void store(OutputStreamout,String comments);

        //对应load(InputStream )将属性列表（键值对）写入输出流。comments属性列表的描述。

        void store(Writerwriter, String comments);

        //对应load(Reader)将属性列表（键值对）写入输出流。comments属性列表的描述。

示例:

import java.io.*;
import java.util.*;
class lianxi2
{
    public static void main(String[] args)throws IOException
    {
        //setAndGet();
        //method_1();
        loadDemo();
    }
    public static void method_1()throws IOException
    {//演示，如何将流中的数据存储到集合中。
    //想要将info.txt中键值数据存到集合中进行操作。
    /*
        1,用一个流和info.txt文件关联。
        2，读取一行数据，将该行数据用"="进行切割。
        3，等号左边作为键，右边作为值。存入到Properties集合中即可。

    */
        BufferedReader bufr=new BufferedReader(new FileReader("info.txt"));//文件字符流读取方式关联文本文件，将其放入字符流缓冲区
        String line=null;//设置字符串
        Properties prop=new Properties();//设置集合。存储键值对

        while((line=bufr.readLine())!=null)//将缓冲区中文件存入字符串中，字符串不为空时
        {
            String[] arr=line.split("=");//以'='切割字符串
            prop.setProperty(arr[0],arr[1]);//将键和值存入集合
        }
        bufr.close();//关闭流
        System.out.println(prop);
    }
    public static void setAndGet()
    {//    设置和获取元素。
        Properties prop=new Properties();//新建存储键值对的集合
        prop.setProperty("zhangsan","39");//存入新的   键和值
        prop.setProperty("lisi","54");
        System.out.println(prop);
        

        //String value=prop.getProperty("lisi"); //通过键，获取键对应的值
        //System.out.println(value);
        prop.setProperty("lisi","44");
        //System.out.println(prop);
        Set<String> names = prop.stringPropertyNames();//获取prop中所有 键  的集合
        for(String s:names)//遍历集合
        {
            System.out.println(s+":"+prop.getProperty(s));//打印所有键的名称和  打印 用键名获取到对应的值
        }

    }
    public static void loadDemo()throws IOException
    {
        Properties prop = new Properties();//新建用于存储键值对的集合
        FileInputStream fis = new FileInputStream("info.txt");//将文件与文件读取流关联

        
        prop.load(fis);//将流中的数据加载进集合。

        prop.setProperty("wangwu","39");//添加新的键值对

        FileOutputStream fos = new FileOutputStream("info.txt");//用文件输出流关联文件

        prop.store(fos,"haha");//属性列表（键值对）写入输出流,haha 为属性列表的描述

    //    System.out.println(prop);
        prop.list(System.out); //将信息输出到文件

        fos.close();//关流
        fis.close();
    }
}

练习：

/*
用于记录应用程序运行次数。那么给出注册提示。

很容易想到的是计数器
可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。
可是随着该应用程序的退出，该计数器也在内存中消失了

下一次在启动该程序，又重新开始从0计数。
这样不是我们需要的

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

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

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

键值对数据是map集合。
数据是以文件形式存储，使用io技术。
那么map+io--->properties

配置文件可以实现应用程序数据的共享。*/
import java.io.*;
import java.util.*;
class RunCount
{
    public static void main(String[] args)throws IOException
    {
        Properties prop=new Properties();//新建集合，用于存储键值对形式的数据
        File file=new File("count.ini");//关联文件名为"count.ini"的文件
        if(!file.exists())//如果文件不存在，创建文件
            file.createNewFile();
        FileInputStream fis=new FileInputStream(file);//文件输入流关联file文件
        prop.load(fis);//将流中的数据加载进集合
        int count=0;//定义计数器
        String value=prop.getProperty("time");//将time作为键  value作为值，通过time键获取对应的值
        if(value!=null)
        {
            count=Integer.parseInt(value);//将值 转换成int类型
            if(count>=5)
            {
                System.out.println("您好，使用次数已到，拿钱!");
                return ;
            }
        }
        count++;
        prop.setProperty("time",count+""); //将键和值存入集合中，存在增加或者覆盖
        FileOutputStream fos=new FileOutputStream(file);//将文件输出流与文件相关联
        prop.store(fos,"");//将缓冲区中的数据存入硬盘文件中
        fos.close();//关闭流
        fis.close();
    }
}

   打印流

/*

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

字节打印流：
PrintStream

构造函数 可以接受的参数类型
1    file对象。File
2    字符串对象、String
3    字节输出流。OutputStream



字符打印流
printWriter
构造函数可以接受的参数类型：
1    file对象。File
2    字符串对象：String
3    字节输出流;OutputStream
4    字符输出流：Writer
*/
import java.io.*;
class PrintStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));//键盘录入的标准写法
        PrintWriter out=new PrintWriter(new FileWriter("a.txt"),true);//文件写入流关联文件，创建打印流，将其放入
        String line=null;                                            //当该文件不存在时，创建。存在时，续写，而不会覆盖
        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))//定义结束字符
                break;
            out.println(line.toUpperCase());
        }
    
        out.close();//关流
        bufr.close();

    }    
}

序列流

一、概述

1、SequenceInputStream对多个流进行合并。也被称为合并流。

2、常用构造函数

        SequenceInputStream(Enumeration<?extends FileInputStream> e)

二、常见合并多个流文件步骤

        1、创建集合，并将流对象添加进集合

        2、创建Enumeration对象，将集合元素加入。

        3、创建SequenceInputStream对象，合并流对象

        4、创建写入流对象，FileOutputStream关联写入文件

        5、利用SequenceInputStream对象和FileOutputStream对象读数据进行反复读写操作。

示例：

import java.io.*;
import java.util.*;
class SequenceDemo
{
    public static void main(String[] args)throws IOException
    {
        Vector<FileInputStream> v = new Vector<FileInputStream>();//创建容器  类型限定为 文件读取流

        v.add(new FileInputStream("c:\1.txt"));//文件读取流关联文本文件，添加进 Vector容器中
        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();


    }
}

示例2：

/* 
切割文件 
需求：将一个mp3文件按1M大小切割成几部分 
思路：1、使用文件字节流关联mp3文件 
      2、定义一个容器存储1M大小的数据，当存储满时，写入一个新文件中 
 
*/  
import java.util.*;
import java.io.*;
class SplitFile
{
    public static void main(String[] args)throws IOException
    {
        add();
    }
    public static void add()throws IOException//文件合流
    {
        /*ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
        for(int x=0;x<5;x++)
        {
            al.add(new FileInputStream("c:\splitfiles\"+x+".part"));
        }
        //因为Enumeration是Vector特有的迭代方法，所以这里创建一个Enumeration类型的匿名内部类 
        final Iterator <FileInputStream>it=al.Iterator();
        Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()
        {
            public boolean hasMoreElements()
            {
                return it.hasNext();
            }
            public FileInputStream nextElement()
            {
                return it.next();
            }
        };
        */
        
        Vector<FileInputStream>  v=new Vector<FileInputStream> ();//创建Vector容器，元素限定为 文件输入流
        for(int x=0;x<5;x++)//文件输入流  关联文件，并添加至Vector容器中
        {
            v.add(new FileInputStream("c:\splitfiles\"+x+".part"));
        }

        
        Enumeration <FileInputStream> en=v.elements();//创建枚举对象
        SequenceInputStream sis=new SequenceInputStream(en);//合并流
        FileOutputStream fos=new FileOutputStream("c:\splitfiles\0.mp3");//关联写入文件
        byte buf[]=new byte[1024*1024];//定义第三方缓冲区容器
        int len=0;
        while((len=sis.read(buf))!=-1)//反复读写操作
        {
            fos.write(buf,0,len);    
        }
        fos.close();
        sis.close();
    }
    public static void splitFile()throws IOException//文件切割
    {
        FileInputStream fis=new FileInputStream("c:\1.mp3");
        FileOutputStream fos=null;

        byte buf[]=new byte[1024*1024];//定义中间缓冲区容器，因为mp3文件有近5M，所以按每兆来划分一部分
        int len=0;
        int count=0;//定义量词   用于命名 即第几部分
        while((len=fis.read(buf))!=-1)//读写操作
        {
            
            fos=new FileOutputStream("c:\splitfiles\"+count+++".part");
            fos.write(buf);//写入
            fos.close();//关闭输出流资源
            
        }
        fis.close();//关闭输入流资源
    }
}

ps：将图片文件切割成多部分时，如果将其保存成图片格式，查看时显示文件损坏。

　　将音乐文件切割成多部分时，如果将其保存成图片格式，点击依旧可以听到部分截取的音乐