IO流总结（二）

一、File类

   File类是IO包中唯一代表磁盘文件本身信息的类，而不是代表文件中的内容。java中的目录被当作一种特殊的文件使用，用list()方法返回一个字符串数组，表示目录中的所有子目录和文件名。
   File类的常见方法：
1，创建
boolean createNewFile();在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
2，删除。
boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。
void deleteOnExit();在程序退出时删除指定文件。
3，判断。
boolean exists() :文件是否存在.
isFile():
isDirectory();
isHidden();
isAbsolute();
4，获取信息。
File.listRoots();获取根
file.getFreeSpace()容量
getName():
getPath():
getParent():

getAbsolutePath() 
long lastModified() 
long length() 

递归
函数自身直接或者间接的调用到了自身。
一个功能在被重复使用，并每次使用时，参与运算的结果和上一次调用有关。这时可以用递归来解决问题。因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。在列出过程中出现的还是目录的话，还可以再次调用本功能。也就是函数自身调用自身。
这种表现形式，或者编程手法，称为递归。
P.S.
1、递归一定明确条件，否则容易栈溢出。
2、注意一下递归的次数。
需求：对指定目录进行所有内容的列出（包含子目录中的内容），也可以理解为深度遍历。
练习：将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。
建立一个java文件列表文件。

/*
思路：
1，对指定的目录进行递归。
2，获取递归过程所以的java文件的路径。
3，将这些路径存储到集合中。
4，将集合中的数据写入到一个文件中。
*/
import java.io.*;
import java.util.*;
class JavaFileList 
{
    public static void main(String[] args) 
    {
        File dir = new File("E:\\java");
        List<File> list = new ArrayList<File>();
        fileToList(dir,list);
        //System.out.println(list.size());          
        writeToFile(list,"E:\\java\\javaListFile.txt");
    }
    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,String javaListFile)
    {
        BufferedWriter bufw = null;
        try
        {
            bufw = new BufferedWriter(new FileWriter(javaListFile));
            for(File f : list)
            {
                bufw.write(f.getAbsolutePath());
                bufw.newLine();
                bufw.flush();
            }
        }
        catch (IOException e)
        {
            throw new RuntimeException();
        }
        finally
        {
            try
            {
                if(bufw!=null)
                    bufw.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException();
            }
        }
    }
}

二、与IO流相关联的一个集合中的类Properties类
1.Properties是hashtable的子类。
2.该集合中的键和值都是字符串类型。
3.是集合中和IO技术相结合的集合容器。
4.那么在加载数据时，需要数据有固定格式：键=值。
5.集合中的数据可以保存到流中，或者从流中获取。
6.通常该集合用于操作以键值对形式存在的配置文件。

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

import java.io.*;
import java.util.*;
class PropertiesDemo 
{
    public static void main(String[] args) throws IOException
    {
        //setAndGet();
        //method_1();
        loadDemo();
    }
    //设置和获取元素。
    public static void setAndGet()
    {
        Properties prop = new Properties();
        prop.setProperty("zhangsan","30");
        prop.setProperty("lisi",89+"35");

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

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

    //演示，如何将流中的数据存储到集合中。
    //想要将info.txt中键值数据存到集合中进行操作。
    /*
        1,用一个流和info.txt文件关联。
        2，读取一行数据，将该行数据用"="进行切割。
        3，等号左边作为键，右边作为值。存入到Properties集合中即可。

    */
    public static void loadDemo() throws IOException
    {
        Properties prop = new Properties();
        FileInputStream fis = new FileInputStream("info.txt");
        //将流中的数据加载进集合。
        prop.load(fis);
        prop.setProperty("lisi","100");

        FileOutputStream fos = new FileOutputStream("info.txt");
        prop.store(fos,"haah");
        //System.out.println(prop);
        prop.list(System.out);
    }
    public static void method_1() throws IOException
    {
        BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));
        String line=null;
        Properties prop = new Properties();
        while((line=bufr.readLine())!=null)
        {
            String[] arr = line.split("=");
            //System.out.println(arr[0]+"...."+arr[1]);
            prop.setProperty(arr[0],arr[1]);
        }
        bufr.close();
        System.out.println(prop);
    }
}

三、IO包中的其他类

*RandomAccessFile：*
该类不是算是IO体系中子类。
而是直接继承自Object。

但是它是IO包中成员。因为它具备读和写功能。
内部封装了一个数组，而且通过指针对数组的元素进行操作。
可以通过getFilePointer获取指针位置，
同时可以通过seek改变指针的位置。


其实完成读写的原理就是内部封装了字节输入流和输出流。

通过构造函数可以看出，该类只能操作文件。
而且操作文件还有模式：只读r，，读写rw等。

如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。
如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。

*PipedStream*
PipedInputStream和PipedOutputStream用于在应用程序中创建管道通信。
一个PipedInputStream实例对象必须和一个PipedOutputStream实例对象进行连接来产生一个通信管道。主要用来完成线程之间的通信。
PipedReader和PipedWriter用来创建字符文本的管道通信。

使用管道流类，可以实现各个程序模块之间的松耦合通信。

*ByteArrayStream*
ByteArrayInputStream和ByteArrayOutputStream用于以IO流的方式来完成对字节数组内容的读写，来实现类似内存虚拟文件或者内存映像文件的功能。 关闭字节数组输出输出流无效，因为它们没有调用底层资源，所有的操作都是在内存中完成的。
ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。

ByteArrayOutputStream： 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。
这就是数据目的地。

因为这两个流对象都操作的数组，并没有使用系统资源。
所以，不用进行close关闭。

*ObjectStream*
  操作对象
    ObjectInputStream与ObjectOutputStream
    P.S.
    被操作的对象需要实现Serializable。
*DataStream*
  操作基本数据类型
    DataInputStream与DataOutputStream