Java基础——IO（2）

File类

1.列出文件及文件过滤

/**
 * 练习：用String[] list(FilenameFilter filter)方法获取一个目录下所有的.java文件，
 * 其他文件不要。 
思路：1、FilenameFilter是一个过滤器接口，用匿名内部类传入filter对象 
          2、复写FilenameFilter接口的accept(File file,String name)方法，
          并判断name是否是java文件 
          3、遍历String类型数组 

 */
import java.io.File;
import java.io.FilenameFilter;

public class Test1 {

    public static void main(String[] args) {
        File file = new File("F:\\java");
        getJavaList(file);

    }

    private static void getJavaList(File file) {
        //传入FilenameFilter匿名内部类子类对象，并复写accept方法  
        String s[] = file.list(new FilenameFilter() {

            @Override
            public boolean accept(File dir, String name) {
                //判断文件名是否是以.java结尾  
                return name.endsWith(".java");
            }
        });
        System.out.println("文件长度："+file.length());
        for(String ss : s ){
            System.out.println(ss);
        }
    }
}

2.获取信息

3.创建

递归

练习一：

/*
需求：列出指定目录下文件或文件夹，包含子目录，即列出指定目录下所有内容（带层次的）。

分析，因为目录中还有目录，只有使用同一个列出目录功能的函数完成即可，
在列出过程中出现的还是目录的话，还可以再调用本功能，这就是利用递归原理。

*/
import java.io.*;
public class  RecursionDemo
{
    public static void main(String[] args) 
    {
        //关联指定路径
        File dir=new File("F:\\java");

        //列出关联路径中所有的.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)
        {
            //isDirectory() ：测试此抽象路径名表示的文件是否是一个目录。
            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中，删除目录从里面往外面删除的。
既然是从里往外删除。就需要用到递归。

*/
import java.io.*;
public class RemoveDir 
{
    public static void main(String[] args) 
    {
        //指定目录
        File dir=new File("f:\\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.*;

public class  JavaFileList
{
    public static void main(String[] args) 
    {
        //指定目录
        File dir=new File("F:\\java");

        //定义一个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)
    {
        File[] files=dir.listFiles();//列出dir路径下的所以文件和目录，
        //遍历
        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类

概述：

他是一个键值对形式，常用作配置文件。

最有特点的方法：

可以直接将键值对放到输入输出流之中

还可以放置到XML文件中

练习1:

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

    */
        //将文件数据存储进Properties集合方法
public class Test2{
    public static void main(String[] args) throws IOException {
        method();
    }
    public static void method()throws IOException
    {
        //使用字符读取缓冲流关联文件
        BufferedReader bufr = new BufferedReader(new FileReader("d:\\info.txt"));

        String line = null;
        //定义Properties集合
        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);
    }
}

打印流

一、概述

    1、打印流包括：PrintStream和PrintWriter

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

二、字节打印流：PrintStream

构造方法中可接收的参数类型：

    1、File对象。File

    2、字符串路径：String

    3、字符输出流：OutputStream

三、字符串打印流：PrintWriter

构造方法中可接受的参数类型

    1、File对象：File

    2、字符串路径：String

    3、字节输出流：OutputStream

    4、字符输出流：Writer

序列流

一、概述

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

SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。 

2、常用构造函数

    SequenceInputStream(Enumeration<?extends FileInputStream> e)

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

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

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

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

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

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

P.S

import java.io.*;

import java.util.*;

public class SequenceInputStreamDemo {
    public static void main(String[] args) throws Exception {

        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
        for (int x = 1; x <= 3; x++) {
            al.add(new FileInputStream("d:\\IO\\"+x + ".txt"));
        }

        final Iterator<FileInputStream> it = al.iterator();

        Enumeration<FileInputStream> en = Collections.enumeration(al);
        /*
         * //Collections工具类的enumeration方法核心代码：
         *  Enumeration<FileInputStream> en =
         * new Enumeration<FileInputStream>(){ public boolean hasMoreElements(){
         * return it.hasMoreElements(); 
         * }
         * 
         * public FileInputStream nextElement(){ return it.next(); } 
         * };
         */

        SequenceInputStream sis = new SequenceInputStream(en);

        FileOutputStream fos = new FileOutputStream("d:\\IO\\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();
    }
}

Serializable序列化接口

主要用于类的流操作

例：
将一个常规的类对象序列化的obj.object文件对象中去

public class ObjectStreamDemo {

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

        writeObj();
        readObj();
    }

    public static void readObj() throws IOException, ClassNotFoundException {

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\obj.object"));
        //对象的反序列化。 
        Person p = (Person)ois.readObject();

        System.out.println(p.getName()+":"+p.getAge());

        ois.close();

    }

    public static void writeObj() throws IOException, IOException {

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:\\obj.object"));
        //对象序列化。  被序列化的对象必须实现Serializable接口。 
        oos.writeObject(new Person("小强",30));

        oos.close();

    }

}