黑马程序员——java基础知识之IO流（三）

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
（一）、File类
1、什么是File类？
File类：文件和目录路径名的抽象表现形式

2、file类的主要方法：

部分方法演示：
例子程序：

        sop("path:"+f.getPath());
        sop("abspath:"+f.getAbsolutePath());
        sop("parent:"+f.getParent());//该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。
//如果相对路径中有上一层目录那么该目录就是返回结果。

        //记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在。
        //通过exists判断。
        sop("dir:"+f.isDirectory());
        sop("file:"+f.isFile());
//文件是否是绝对路径
        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");
    boolean mkdirs();//创建多级文件夹
        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());

    }

总结：File类主要方法说明：
①创建
booleancreateNewFile();
//在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立就创建文件。而且文件已经存在，会覆盖。
boolean mkdir();//创建文件夹，只能创建一级文件夹
例：
File dir=new File(“abc”);
dir.mkdir();//创建abc这个文件夹
boolean mkdirs();//创建多级文件夹

②删除
boolean delete();
//删除文件或目录。文件存在，返回true；文件不存在或者正在被执行，返回false。
void deleteOnExit();//在程序退出时删除指定文件

③判断
boolean canExecute();//是否是可执行文件
boolean exists();//文件是否存在
boolean isFile();//是否是文件
boolean isDirectory();//是否是文件夹
boolean isHidden();//是否是隐藏文件
boolean isAbsolute();//文件是否是绝对路径
记住：在判断文件对象是否是文件或者目录时，必须要判断该文件对象封装的内容是否存在。通过exists判断。

④获取信息
String getName();//获取文件名
String getPath();
//获取文件的相对路径（即创建的对象传入的参数是什么就获取到什么）
String getParent();
//获取文件父目录。返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。如果相对路径中有上一层目录，那么该目录就是返回结果。
String getAbsolutePath();//获取文件的绝对路径
long lastModified();//返回文件最后一次被修改的时间
long length();//返回文件长度

3、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对象
    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.separator表示目录分隔符，可以跨平台使用。
        File f4 = new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");
    }

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

增加知识点：File类中一个列出文件和过滤文件的方法：
static File[] listRoots();//列出可用的文件系统根目录，即系统盘符

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

String[]list(FilenameFilter filter);
//返回一个字符串数组，获取目录中满足指定过滤器的文件或目录。

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

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

演示： String[] list()的方法和 File.listRoots()方法

    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);
        }
    }
}

演示 File[] listFiles()和 File[] ListFiles(FilenameFilterfilter)的方法

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:\\java1223\\day18");
  //返回一个字符串数组，获取目录中满足指定过滤器的文件或目录。
        String[] arr = dir.list(new FilenameFilter()
        {
            public boolean accept(File dir,String name)
            {

                return name.endsWith(".bmp");
            }
        });

4、递归
①什么是递归
当函数内每一次循环还可以调用本功能来实现，也就是函数自身调用自身。这种表现形式，或者编程手法，称为递归。

②递归要注意的条件
1，限定条件。
2，要注意递归的次数。尽量避免内存溢出。

③用例子一说明：

/*列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容。
思路分析：
因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现的还是目录的话，还可以再次调用本功能。
也就是函数自身调用自身。
这种表现形式，或者编程手法，称为递归。
*/
import java.io.*;  
class  RecursionDemo  
{  
    public static void main(String[] args)   
    {  
        //关联指定路径  
        File dir=new File("e:\\Java Study\\Practice");            
        //列出关联路径中所有的.java文件  
        allFileList(dir,0);  
    }  

    //列出指定目录下的所以内容  
    public static void allFileList(File dir,int level)  
    {  
        //有层次的输出  
        System.out.println(getLevel(level)+dir);  
        level++;  
        File[] fileArr=dir.listFiles();//获取本目录下的所以文件和目录的抽象路径  

        //遍历  
        for (File file : fileArr)  
        {  
            if(file.isDirectory())  
            {  
                //如果目录下还是目录，则继续调用本函数  
                allFileList(file,level);  
            }  
            else  
                System.out.println(getLevel(level)+file);//显示（列出）文件  
        }     
    }  

    //带层次的列表  
    public static String getLevel(int level)  
    {  
        StringBuilder sb=new StringBuilder();  
        sb.append("|--");  
        //每多一级目录，就多输出指定字符  
        for (int x=level;x>0 ; x--)  
        {  
            //sb.append("|--");  
            sb.insert(0,"|  ");  
        }  
        return sb.toString();  
    }  
}  

④用例子程序二说明
删除一个带内容的目录。
删除原理：
在windows中，删除目录从里面往外面删除的。
既然是从里往外删除。就需要用到递归。

class RemoveDir   
{  
    public static void main(String[] args)   
    {  
        //指定目录  
        File dir=new File("e:\\1");  
        //删除目录  
        removeDir(dir);  

    }  

    //删除传入目录  
    public static void removeDir(File dir)  
    {  //列出目录下的所以文件和文件夹  
        File[] files=dir.listFiles();
        //遍历  
        for (File file : files )  
        {  
            //如果还是目录且非隐藏  
            if(!file.isHidden()&&file.isDirectory())  
            //继续删除目录里的内容 
                removeDir(file); 
            else  
            //删除文件
                System.out.println(file.toString()+":-file-:"+file.delete());  
        }  
        //删除目录  
        System.out.println(dir+":::dir:::"+dir.delete());//
    }  
}  

⑤用例子三说明递归
练习
将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。
建立一个java文件列表文件。

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

import java.util.*;  
import java.io.*;  

class  JavaFileList  
{  
    public static void main(String[] args)   
    {  
        //指定目录  
        File dir=new File("e:/Java Study/Practice");  

        //定义一个List集合，用于存储.java文件的File对象  
        List<File> list =new ArrayList<File>();  

        //调用获取文件路径方法  
        fileToList(dir,list);  

        //指定写入文件  
        File file=new File(dir,"javafilelist.txt");  
        //调用写入文件方法  
        writeToFile(list,file);  

    }  
    //获取指定文件夹内的所有java文件的绝对路径，并存入集合中  
    public static void fileToList(File dir,List<File> list)  
    {  //列出dir路径下的所以文件和目录，  
        File[] files=dir.listFiles();
        //遍历  
        for (File file : files)  
        {  
            //如果是目录，则继续获取  
            if(file.isDirectory())  
            {  //把父目录路径也存入  
                list.add(file.getAbsoluteFile());
                fileToList(file,list);  
            }  
            //将是.java文件的绝对路径存入  
            else if(file.getName().endsWith(".java"))  
                list.add(file);  
        }  
    }  

    //将集合中元素写入到一个文本文件中  
    public static void writeToFile(List<File> list,File file)  
    {  

        BufferedWriter bw=null;  

        try  
        {   //使用字符流缓冲区对象关联写入的文件  
            bw=new BufferedWriter(new FileWriter(file));  
            for (File file0 : list )  
            {  
                bw.write(file0.getAbsolutePath());//写入  
                bw.newLine();//换行  
                bw.flush();//刷新  
            }  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("写入文件失败");  
        }  
        finally  
        {  
            try  
            {  
                if(bw!=null)  
                    bw.close();//关流  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("流资源关闭失败");  
            }  
        }  
    }  
}  

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

2、Properties类主要特点：
①可用于键值对形式的配置文件
②在加载时，需要数据有固定的格式，常用的是：键=值

3、Properties类的主要方法：
①、设置
Object setProperty(String key,String value);
//设置键和值，调用Hashtable的方法put

②获取
String getProperty(String key);
//指定key搜索value

Set stringPropertyName();
//返回属性列表的键集，存入Set集合

③加载流和存入流
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属性列表的描述。

例子程序：
练习：限制程序运行次数。当运行次数到达5次时，给出，请您注册的提示。并不再让该程序执行。

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

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

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

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

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

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

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

配置文件可以实现应用程序数据的共享。
*/
package cn.dhjIo;

import java.io.*;
import java.util.*;

public class Text04 {
    public static void main(String[] args) throws IOException{
        //创建集合对象
        Properties prop = new Properties();
        //将文件对象进行封装
        File file = new File("count.ini");
        //判断文件是否存在
        if(!file.exists()){
            file.createNewFile();
        }
        //将文件与读取流相关联
        FileInputStream in = new FileInputStream(file);
        //将流中的文件数据以键值对的形式放入集合中
        prop.load(in);
        //定义计数器
        int count=0;
        String value = prop.getProperty("time");
        if(value!=null){
            count = Integer.parseInt(value);
            if(count>=5){
                System.out.println("使用的次数已到，请充钱");
                return;
            }
        }
        count++;
        //将数据以键值对的形式存放在集合中
        prop.setProperty("time", count+"");
        //定义输入流
        FileOutputStream out = new FileOutputStream(file);
        //将集合中的键值对信息通过流写到硬盘中
        prop.store(out, "");
        //关闭流资源
        in.close();
        out.close();
    }
}

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

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

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

例子程序：

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.flush();
        }
        out.close();
        bufr.close();
    }   
}

（四）、序列流
1、重要知识点
①SequenceInputStream对多个流进行合并。也被称为合并流。
②常用构造函数
SequenceInputStream(Enumeration

import java.util.*;  
import java.io.*;  

class  SequenceInputStreamDemo  
{  
    public static void main(String[] args)throws IOException  
    {  //创建vector集合，并添加相关流对象  
        Vector<InputStream> ve=new Vector<InputStream>();
        ve.add(new FileInputStream("1.txt"));  
        ve.add(new FileInputStream("2.txt"));  
        ve.add(new FileInputStream("3.txt"));  
  //创建枚举对象  
        Enumeration<InputStream> en=ve.elements();
        //合并流  
        SequenceInputStream sis=new SequenceInputStream(en);

        FileOutputStream fos=new FileOutputStream("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文件按1M大小切割成几部分 ，然后再将这些封开的几个部分合成一个文件
1、使用文件字节流关联mp3文件
2、定义一个容器存储1M大小的数据，当存储满时，写入一个新文件中

import java.util.*;  
import java.io.*;  

class  SplitFile  
{  
    public static void main(String[] args) throws IOException  
    {  
        //指定要切割的文件  
        File file=new File("C:\\Users\\asus\\Desktop\\速度与激情.mp3");  
        //将指定文件进行切割  
        splitFile(file);  

        //指定要合并到的文件  
        File file1=new File("E:\\Java Study\\Practice\\day20\\splitFile\\速度与激情.mp3");  
        //将部分文件进行合并指定文件中  
        merge(file1);  

    }  
    //接收一个文件，将其按1M大小进行切割  
    public static void splitFile(File file)throws IOException  
    {  
        //关联要切割的文件  
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream(file));  

        BufferedOutputStream bos=null;  

        //定义1M大小存储容器  
        byte[] buf=new byte[1024*1024];  
        int len=0,x=0;  
        while ((len=bis.read(buf))!=-1)  
        {  
            //每满1M就写入一个新文件中  
            bos=new BufferedOutputStream(new FileOutputStream("E:\\Java Study\\Practice\\day20\\splitFile\\"+(++x)+".part"));  
            bos.write(buf,0,len);  
            bos.close();//没写完一个文件要记得关流  
        }  
        //关流  
        bis.close();  
    }    
    //将部分文件合并为一个可执行文件  
    public static void merge(File file)throws IOException  
    {  
        //定义一个集合存储这些部分文件关联路径数据  
        ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();  

        for (int x=1;x<=6 ; x++)  
        {  
            al.add(new FileInputStream("E:\\Java Study\\Practice\\day20\\splitFile\\"+x+".part"));  
        }  

        //因为Enumeration是Vector特有的迭代方法，所以这里创建一个Enumeration类型的匿名内部类  
        final  ListIterator<FileInputStream> it=al.listIterator();  
        Enumeration<FileInputStream> en=new Enumeration<FileInputStream>()  
        {  
            public boolean hasMoreElements()  
            {  
                return it.hasNext();  
            }  

            public FileInputStream nextElement()  
            {  
                return it.next();  
            }  
        };  

        //关联枚举对象  
        SequenceInputStream sis=new SequenceInputStream(en);  

        //将合并的文件数据写入指定文件中  
        FileOutputStream fos=new FileOutputStream(file);  

        //定义临时存储数据的数组  
        byte[] buf=new byte[1024];  
        int len=0;  
        while((len=sis.read(buf))!=-1)  
        {  
            fos.write(buf,0,len);//写数据  
        }    
        //关流  
        fos.close();  
        sis.close();   
    }    
}  

（五）、对象的序列化
1、什么是对象的序列化？
对象的序列化就是把对象的信息存储到硬盘上，而且能够从硬盘上把对象的信息读取出来，而且可以使用读取出来的对象

2、例子程序

import java.io.*;

class ObjectStreamDemo 
{
    public static void main(String[] args) throws Exception
    {
        //writeObj();
        readObj();
    }
    public static void readObj()throws Exception
    {//定义对象的读入的流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));

        Person p = (Person)ois.readObject();

        System.out.println(p);
        ois.close();
    }

    public static void writeObj()throws IOException
    {//定义对象的写出流对象
        ObjectOutputStream oos = 
            new ObjectOutputStream(new FileOutputStream("obj.txt"));
//写到硬盘上指定的文件夹
        oos.writeObject(new Person("lisi0",399,"kr"));
//关闭流对象
        oos.close();
    }
}

（六）、管道流
管道流不用通过缓冲区，将IO流的读写直接连起来。它是通过多线程实现的。

例子程序实现原理：

import java.io.*;
//利用两个线程，一个是读的线程，一个是写的线程
class Read implements Runnable
{
    private PipedInputStream in;
    Read(PipedInputStream in)
    {
        this.in = in;
    }
    public void run()
    {
        try
        {
            byte[] buf = new byte[1024];

            System.out.println("读取前。。没有数据阻塞");
            int len = in.read(buf);
            System.out.println("读到数据。。阻塞结束");

            String s= new String(buf,0,len);

            System.out.println(s);

            in.close();

        }
        catch (IOException e)
        {
            throw new RuntimeException("管道读取流失败");
        }
    }
}

class Write implements Runnable
{
    private PipedOutputStream out;
    Write(PipedOutputStream out)
    {
        this.out = out;
    }
    public void run()
    {
        try
        {
            System.out.println("开始写入数据，等待6秒后。");
            Thread.sleep(6000);
            out.write("piped lai la".getBytes());
            out.close();
        }
        catch (Exception e)
        {
            throw new RuntimeException("管道输出流失败");
        }
    }
}

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

        PipedInputStream in = new PipedInputStream();
        PipedOutputStream out = new PipedOutputStream();
        in.connect(out);

        Read r = new Read(in);
        Write w = new Write(out);
        new Thread(r).start();
        new Thread(w).start();
    }
}