IO流3（File类、Properties、递归、打印流、序列流）

一、File类

         1.概述

                  文件和目录路径名的抽象表示形式，该类将文件或者文件夹封装成对象，方便对文件与文件夹的属性信息进行操作，File                     对象可以作为参数传递给流的构造函数（流只操作数据）； 

         2.构造方法

                 可以将已有的和未出现的文件夹或者文件封装成对象；

                 File(String pathname);通过将指定路径名字符串转换为抽象路径名来创建一个新file示例，pathname-文件路径名（字符串） 
                        例：File f1=new File(“a.txt”);

                 File(String parent,String child);parent-路径名字符串，child-parent路径下的文件； 
                       例：File d=new File(“c:\abc”,”b.txt”);

                File(File parent,String child);根据parent抽象路径名和child路径名字符串创建一个新File实例；parent-父抽象路径名；child-                     子路径名字符串； 
                       例：File f=new File(“c:\abc”)；File f1=new File(f,”c.txt”);

         3.常用方法

                 1）创建
               boolean createNewFile();在指定位置创建文件，如果该文件已经存在，则不创建，返回false.
        和输出流不一样，输出流对象一建立创建文件，而且文件已经存在，会覆盖，
               boolean mkdik():创建文件夹。
               boolean mkdirs():创建多级文件夹。
                 2）删除。
               boolean delete(); 删除失败返回false。
               void deleteOnExit(); 在程序退出时删除指定文件。
                 3）判断。
               boolean exists():文件是否存在。
               isFile();是否是文件
               isDirectory();是否是目录
               isHidden();是否是隐藏文件
                      isAbsolute();是否为绝对路径名
                 4）获取信息。
               getName();返回文件或目录的名称
               getPath();返回路径名字符串
               getParent();返回父目录路径名
               getAbsolutePath();返回路径名的绝对路径名字符串
               lastModified();返回文件最后一次修改的时间
               length();返回文件的长度

class FileDmeo
{
	public static void main(String[] args) throws IOException
	{
		method_4();
		//consMethod();
	}
	public static void method_4()
	{
		File f = new File("e:\\java\\a.txt");

		sop("path:"+f.getPath());
		sop("abspath:"+f.getAbsolutePath());
		sop("parent:"+f.getParent());//该方法返回的是绝对路径中的父目录。如果获取的是相对路径，则返回null。
									//如果相对路径中有上一层目录，那么该目录就是返回结果。
	}
	public static void method_3()
	{
		File f = new File("file.txt");
		
		//记住在判断文件对象是否是文件或者目录时，必须要先判断该文件对象封装的内容是否存在。
		//通过exists判断。
		sop("dir:"+f.isDirectory());
		sop("file:"+f.isFile());
	}
	public static void method_2()
	{
		File f = new File("file.txt");
		sop("exists:"+f.exists());

		//创建文件夹
		File dir = new File("e:\\java\\ab");

		sop("mkdir:"+dir.mkdir());
	}
	
	public static void method_1() throws IOException
	{
		File f = new File("e:\\java\\file.txt");

		//sop("create:"+f.createNewFile());
		sop("delete:"+f.delete());
	}
	//创建File对象
	public static void consMethod()
	{
		//将a.txt封装成file对象。可以将已有的和未出现的文件或者文件夹封装成对象。
		File f1 = new File("e:\\java\\a.txt");

		File f2 = new File("e:\\java","b.txt");
		
		File d = new File("e:\\java");
		File f3 = new File(d,"c.txt");

		sop("f1:"+f1);
		
		sop("f2:"+f2);
		
		sop("f3:"+f3);

		File f4 = new File("c:"+File.separator+"java"+File.separator+"zzz"+File.separator+"a.txt");//可以实现跨平台
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);		
	}
}

FilenameFilter

             FilenameFilter是一个接口，用于抽象路径名的过滤器，该接口仅有一个方法： 

             accept(File dir,String name)；dir-文件所在目录，name-文件的名称 
             当且仅当该名称包含在文件列表中时返回true，否则返回false实际应用中复写该方法，例：

//列出a目录下的所有.bmp文件；
File dir=new File("d:\\java10\\a");
String[] arr=dir.list(new FilenameFilter()
{
    public boolean accept(File dir,String name)
    {
        return name.endsWith(".bmp");
    }
});//匿名内部类创建FilenameFilter对象并复写accept方法过滤.bmp文件；

二、递归

            

              函数自身直接或者间接的调用到了自身。
              一个功能在被重复使用，并每次使用时，参与运算的结果和上一次调用有关。这时可以用递归来解决问题。
              P.S.
             1.递归一定明确条件，否则容易栈溢出。
             2.注意一下递归的次数。

需求：对指定目录进行所有内容的列出（包含子目录中的内容），也可以理解为深度遍历。

import java.io.File;

public class FileListDemo{
	public static void main(String[] args){
			File dir = new File("D:\\Java\\jdk1.6.0_02\\include" );
			listAll(dir,0);
	}

	public static void listAll(File dir, int level){
			System.out.println(getSpace(level) + "dir:" +
			dir.getAbsolutePath());
			// 获取指定目录下当前的所有文件夹或者文件对象
			level++;
			File[] files = dir.listFiles();

			for (int x = 0; x < files.length; x++){
				if (files[x].isDirectory()){
					listAll(files[x],level);
				}
				System.out.println(getSpace(level) + "file:" +files[x].getAbsolutePath());
			}
	}

	private static String getSpace( int level){
			StringBuilder sb = new StringBuilder();

			sb.append( "|--" );
			for (int x = 0; x < level; x++){
				sb.append( "| " );
			}
			return sb.toString();
	}
 }

需求：利用递归求1到10的和。

public class DiGuiDemo{
	public static void main(String[] args){
			int sum = getSum(10);
			System.out.println(sum);
	}

	public static int getSum(int num){
			if(num == 1)
				return 1;
			return num + getSum(num - 1);
	}
 }

 Properties集合

         Map
                |--Hashtable
                |--Properties
         特点：
                1. 该集合中的键和值都是字符串类型。
                2. 集合中的数据可以保存到流中，或者从流中获取。
                3. 通常该集合用于操作以键值对形式存在的配置文件。

示例：Properties集合的存和取。

import java.util.Properties;
import java.util.Set;

public class PropertiesDemo{
	   public static void main(String[] args){
		      propertiesDemo();
		}

		public static void propertiesDemo(){
			  //创建一个Properties集合
			  Properties prop = new Properties();

			  //存储元素
			  prop.setProperty( "zhangsan","10" );
			  prop.setProperty( "lisi","20" );
			  prop.setProperty( "wangwu","30" );
			  prop.setProperty( "zhaoliu","40" );
 
			  //修改元素
			  prop.setProperty( "wangwu","26" );

			  //取出所有元素
			  Set<String> names = prop.stringPropertyNames();

			  for(String name : names){
					String value = prop.getProperty(name);
					System.out.println(name + ":" + value);
			  }
		 }
}

需求：获取指定目录下，指定扩展名的文件（包含子目录中的），并且将这些文件的绝对路径写入到一个文本文件中。
简单说：就是建立一个指定扩展名的文件的列表。

           思路：
                  1. 必须进行深度遍历。
                  2. 要在遍历的过程中进行过滤，将符合条件的内容都存储到容器中。
                  3. 对容器中的内容进行遍历并将绝对路径写入到文件中。

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class Test{
	public static void main(String[] args) throws IOException {
		File dir = new File("d:\\code" );
		FilenameFilter filter = new FilenameFilter(){
			public boolean accept(File dir,String name){
				return name.endsWith(".java" );
			}
		};

		List<File> list = new ArrayList<File>();
		getFiles(dir,filter,list);
		File destFile = new File(dir,"javalist.txt" );
		write2File(list,destFile);
	}
 /*
  对指定目录中的内容进行深度遍历，并按照指定过滤器，进行过滤。
  将过滤后的内容存储到指定容器 List 中。
  */
		public static void getFiles(File dir,FilenameFilter filter,List<File>
list){
			File[] files = dir.listFiles();
 
			for(File file : files){
			// 递归
				if(file.isDirectory()){
					getFiles(file,filter,list);
				} else{
			// 对便利到的文件进行过滤器的过滤。将符合条件 File 对象，存储到List 集合中
					if(filter.accept(dir,file.getName())){
						list.add(file);
					}
				}
		}
 }

  public static void write2File(List<File> list,File destFile) throws IOException{
			BufferedWriter bufw = null;
			try{
					bufw = new BufferedWriter(new FileWriter(destFile));
 
					for(File file : list){
						bufw.write(file.getAbsolutePath());
						bufw.newLine();
						bufw.flush();
					}
				} finally{
						if(bufw!=null)
							try{
									bufw.close();
								} catch(IOException e){
										throw new RuntimeException(" 关闭失败 ");
								}
						}
				 }
  }

IO流中的其他流

       

         打印流
                        PrintWriter与PrintStream：可以直接操作输入流和文件。
                        

                       PrintStream为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。
                       与其他输出流不同，PrintStream永远不会抛出IOException。
                       PrintStream打印的所有字符都使用平台的默认字符编码转换为字节。
                       在需要写入字符而不是写入字节的情况下，应该使用PrintWriter类。
            

                       PrintStream:
                               1. 提供了打印方法可以对多种数据类型值进行打印，并保持数据的表示形式
                               2. 它不抛IOException
                       构造函数，接收三种类型的值：
                              1. 字符串路径
                              2. File对象

                              3. 字节输出流

示例：

import java.io.PrintStream;

public class PrintStreamDemo{
	public static void main(String[] args) throws Exception {
		PrintStream out = new PrintStream("print.txt" );
 
		//write(int b)方法只写最低8位
		out.write(97); //a
		//print方法将97先变成字符串保持原样将数据打印到目的地
		out.print(97); //97
		out.close();
	}
}

                      PrintWriter：字符打印流
                      

                      构造函数参数：
                             1. 字符串路径
                             2. File对象
                             3. 字节输出流
                             4. 字符输出流

示例：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.IOException;

public class PrintWriterDemo{
	public static void main(String[] args) throws IOException {
		BufferedReader bufr = new BufferedReader(new
		InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(System.out);

		String line = null;
		while((line = bufr.readLine()) != null){
			if("over" .equals(line))
					 break;
			out.println(line.toUpperCase());
			out.flush();
		}

		out.close();
		bufr.close();
	}
}

                 

序列流
        SequenceInputStream：对多个流进行合并。

需求：将1.txt、2.txt、3、txt文件中的数据合并到一个文件中。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class SequenceInputStreamDemo{
	public static void main(String[] args) throws Exception {
		Vector<FileInputStream> v = new Vector<FileInputStream>();

		v.add( new FileInputStream("1.txt" ));
		v.add( new FileInputStream("2.txt" ));
		v.add( new FileInputStream("3.txt" ));

		Enumeration<FileInputStream> en = v.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();
	}
}