Java基础 IO流 File Properties PrintWriter 序列流SequenceInputStream

File类

• 用来将文件或者文件夹封装成对象
• 方便对文件与文件夹进行操作
• File对象可以作为参数传递给流的构造函数
• 了解File类中的常用方法

文件过滤

import java.io.*;
class FileDemo2
{
    public static void main(String[] args)
    {
        File dir = new File("d:\\");
        FilenameFilter ff=new FilenameFilter(){
            ///dir代表指定的目录,name 代表目录内的文件或文件夹名    
            public boolean accept(File dir,String name)
            {
                /* if((name.indexOf("txt"))!=-1)
                    return true;
                return false; */
                return name.endsWith(".txt");
            }
        };
        String[] arr=dir.list(ff);
        System.out.println("len:"+arr.length);
        for(String name : arr)
        {
            System.out.println(name);
        }
    }
}

递归

import java.io.*;
class FileDemo3
{
    public static void main(String[] args)
    {
        File dir = new File("d:\\test");
        showDir(dir);
    }
    public static void showDir(File dir)
    {
        System.out.println(dir);
        File[] files = dir.listFiles();

        for(int x=0;x<files.length;x++)
        {
            if(files[x].isDirectory())
                showDir(files[x]);
            else
                System.out.println(files[x]);
        }

    }
}

Properties 简述

dom4j 工具更简便。

Properties 是 hashtable的子类
也就是说它具备了map集合的特点。而且它里边存储的键值对都是字符串。
是集合中和IO技术相结合的集合容器

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

Properties存取

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

class PropertiesDemo
{
    public static void main(String[] args)
    {
        setAndGet();
    }
    public static void setAndGet()
    {
        Properties pro=new Properties();
        pro.setProperty("文本颜色","黑色");
        pro.setProperty("文本字体","仿宋");

        //System.out.println(pro);
        String value=pro.getProperty("文本颜色");
        for(String s:pro.stringPropertyNames())
        {
            System.out.println(s+":"+pro.getProperty(s));
        }
    }
}

Properties 存取配置文件

    //将info.txt中键值数据存到集合中进行操作.
    public static void loadDemo() throws IOException
    {
        Properties prop=new Properties();
        FileInputStream fis=new FileInputStream("d:\\sysinfo.txt");

        prop.load(fis);
        prop.list(System.out);
        prop.setProperty("user.timezone","zh");
        //System.out.println(prop);
        FileOutputStream fos=new FileOutputStream("d:\\sysinfo.txt");
        prop.store(fos,"comments");
        fis.close();
        fos.close();
    }

PrintStream PrintWriter

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

• 构造函数可以接受的参数类型：

  1. file对象 File
  2. 字符串路径 String
  3. 字节输出流 OutputStream

• 字符打印流

• PrintWriter
  
  1. file对象
  2. 字符串路径
  3. 字节输出流
  4. 字符输出流

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(System.out,true);
        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("d:\\tmp.txt")),true);
        String line=null;
        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            out.println(line.toUpperCase());
            //out.flush();
        }
        bufr.close();
        out.close();
    }
}

序列流SequenceInputStream

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

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("d:\\1.txt"));
        v.add(new FileInputStream("d:\\2.txt"));
        v.add(new FileInputStream("d:\\3.txt"));

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

        SequenceInputStream sis = new SequenceInputStream(en);

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