JAVASE----15----IO流_2

File类
·用来将文件或文件夹封装成对象
·方便对文件与文件夹的属性信息进行操作。

·File对象可以作为参数传递给流的构造函数

package IO2;

import java.io.File;
import java.io.IOException;

public class FileDemo {

	/**
	 * File 类的常见方法
	 * 1，创建。
	 * boolean  createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
	 * 和输出流不一样，输出流一建立创建文件，而且文件已经存在，会覆盖。
	 * boolean mkdir() 创建文件夹
	 * boolean mkdis() 创建多级文件夹
	 *
	 *2，删除
	 *boolean  delete()  删除失败返回假
	 *void   deleteOnExit(); 在程序退出时删除指定文件
	 *
	 *3，判断
	 *boolean exists():文件是否存在
	 *isFile();
	 *isDirectory();
	 *isHidden(); //测试是否为隐藏文件
	 *
	 *4,获取信息
	 *getName();
	 *getPath();
	 *getParent();
	 *getAbsolutePath()
	 *lastModified()  //文件最后一次修改的时间
	 *length()
	 *
	 */
	public static void main(String[] args) throws IOException {
		method_4();

	}
	//创建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");
		//跨平台
		File f4=new File("c:"+File.separator+"abc"+File.separator+"a.txt");
	}
	
	public static void method() throws IOException
	{
		File f1=new File("FileDemo.java");
	  System.out.println(f1.createNewFile()); //第一次调用true
                                                //第二次调用false
		
		System.out.println(f1.exists());  
		//f1.deleteOnExit(); 
		
	}
	
	public static void method_2() throws IOException
	{
	//创建文件夹
		File dir=new File("abc");
		
		 System.out.println(dir.mkdir());
	}
	
	public static void method_3() throws IOException
	{
		File f=new File("abc.txt");
		f.createNewFile();
		 System.out.println(f.isFile());  //true
	}
	
	public static void method_4() throws IOException
	{
		File f=new File("abc.txt");
		//f.createNewFile();
		 System.out.println("path:"+f.getPath());  //abc.txt
		 System.out.println("abspath:"+f.getAbsolutePath());  //D:\Android\workspace\File\abc.txt
		 System.out.println("parent:"+f.getParent()); //null 
		 //该方法是返回绝对路径中的父目录。
		 //如果想对路径中有上一层目录那么该目录就是返回结果
	}

}

package IO2;

import java.io.File;
import java.io.FilenameFilter;

public class FileDemo2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		File dir=new 	File("D:\\photo");
		//过滤
		File[] files=dir.listFiles(new FilenameFilter() {
			
			@Override
			public boolean accept(File arg0, String arg1) {
				// TODO Auto-generated method stub
				return arg1.endsWith(".jpg");
			}
		});
	 for(File name : files)
	 {
		 System.out.println(name);
	 }
		

	}

	public static void  listRootsDemo(){
		
		File[] files=File.listRoots();
		for(File f: files)
		{
			System.out.println(f);
			//C:\
			//D:\
			//E:\
			//F:\
			//G:\
		}
	}
	
	public static void listDemo()
	{
		File f=new File("c:\\"); //调用list方法的file对象必须是封装了一个目录。该目录必须存在。
		String []names=f.list();
		for(String name : names)
		{
			System.out.println(name);
		}
		//把C盘的文件和文件夹打印
		
	}
	
}

package IO2;

import java.io.File;

public class FileDemo3 {

	/**
	 * 列出指定目录下文件或者文件夹，包含子目录中的类容。
	 * 也就是列出指定目录下的所有类容
	 * 
	 * 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
	 * 在列出过程中出现的还是目录的话，还可以再次调用本功能，也就是函数自身调用自身。
	 * 这种表现形式，或者变成手法，称为递归。
	 */
	
	
	public static void main(String[] args) {
		File dir=new File("e:\\");
		//showDir(dir);
		toBin(6); //110
		System.out.println(getSum(6)); //21

	}
	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]);
		}
	}
	
	//递归演示： 修改以前的2进制方法，
	public static void toBin(int num)
	{
		if(num>0)
		{
			toBin(num/2);
			System.out.println(num%2);
		}
	}
	
	//求和,数字太大会产生内存溢出
	public static int getSum(int n)
	{
		if(n==1)
			return 1;
		return n+getSum(n-1);
	}
	//递归要注意：1 限制条件 2，递归的次数，尽量避免内存溢出。

}

删除目录：

package IO2;

import java.io.File;

public class RemoveDir {

	/**
	 *删除一个带内容的目录
	 *删除原理：在windows中，删除目录从里面往外删除的。
	 *既然是从里往外删除，就需要用到递归。
	 */
	public static void main(String[] args) {
		File f=new File("C:\\haha");
		removedir(f);
		//C:\haha\haha.mp3::true
		//C:\haha\nihao\asdasd::true
		//C:\haha\nihaodir::true
		//C:\hahadir::true

	}
	public static void  removedir(File dir)
	{
		File []files=dir.listFiles();
		for(int x=0;x<files.length;x++)
		{
			if((!files[x].isHidden())&&files[x].isDirectory())
			{
				removedir(files[x]);
			}
			else
				System.out.println(files[x].toString()+"::"+files[x].delete());
			
		}
		System.out.println(dir+"dir::"+dir.delete());
	}

}

建立一个JAVA文件列表文件：

/*建立一个JAVA文件列表文件。
思路：
1,对指定的目录进行递归
2，获取递归过程所有的java文件路径
3，将这些路径存储到集合中
4，将集合中的数据存储到文件中
*/
package IO2;

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

public class JavaFileList {
	public static void main(String[] args) {
	
      File  dir=new File("C:\\Documents and Settings\\Administrator\\桌面\\文档\\JAVA\\代码");
      List<File> list=new ArrayList<File>();
      fileToList(dir,list);
      System.out.print(list.size());//48
      File file=new File(dir,"javalist.txt");
      writeToFile(list,file.toString()); //成功copy
	}
	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)
				{
					String path=f.getAbsolutePath();
					bufw.write(path);
					bufw.newLine();
					bufw.flush(); 
				}
				
			} catch (IOException e) {
				
				e.printStackTrace();
			}
			finally
			{
				try{
					if(bufw!=null)
						bufw.close();
				}
				 catch (IOException e) {
						
						e.printStackTrace();
					}
			}
	}

}

下面再说下properties

properties是hashtable的子类。也就是说他具备map集合的特点。而且它里面存储的兼职都是字符串

是集合中和IO技术相结合的容器，该对象的特点：可以用于键值对形式的配置文件。在加载数据时，
需要数据有固定格式：健=值

package IO2;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class propertiesDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		setAndGet(); 
		//zhangsan:20
		//lisi:80
		
		method();	
		//{zhangsan=20, lisi=50, wangwu=80}
		loadDemo();
		//-- listing properties --
		//zhangsan=20
		//lisi=50
		//wangwu=80

	}
	//设置和获取元素
	public static void setAndGet()
	{
		Properties prop=new Properties();
		prop.setProperty("zhangsan", "20");
		prop.setProperty("lisi", "21");
		
		String value=prop.getProperty("zhangsan");
		//System.out.println(value);
		prop.setProperty("lisi","80");
		Set<String> name =prop.stringPropertyNames();
		for(String na:name)
		{
			System.out.println(na+":"+prop.getProperty(na));
		}
	}
	
	/*如何将流中的数据存储到集合中。
	 * 想要将info.txt中键值数据存到集合中进行操作。
	 * 1，用一个流和info.txt文件关联。
	 * 2，读取一行数据，将该行数据用“=”进行切割
	 * 3，等号左边作为建，右边作为值，存入到Properties 集合中即可
	 */
	public static void method() throws IOException
	{
		BufferedReader buf=new BufferedReader(new FileReader("info.txt"));
		String line=null;
		Properties prop=new Properties();
		while((line=buf.readLine())!=null)
		{
			String []arr=line.split("=");
			System.out.println(line);
			prop.setProperty(arr[0], arr[1]);
		}
		buf.close();
		System.out.println(prop);
	}
	
	//其实内部已经封装完了上面的方法load
	
	public static void loadDemo() throws IOException
	{
		Properties prop=new Properties();
		FileInputStream fis=new FileInputStream("info.txt");
		prop.load(fis);
		prop.setProperty("zhangsan", "88");
		FileOutputStream fos=new FileOutputStream("info.txt");
		prop.store(fos, "haha"); //添加注释信息。 # 开头
		prop.list(System.out);
		fos.close();
		fis.close();
		
	}


}

package IO2;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class RunCount {

	/**
	 *需求：用于记录应用程序运行次数，如果使用次数已到，那么给出注册提示。
	 *很容易想到是：计数器。
	 *可是计数器在定义在程序中，随着程序的运行而在内存中存在，并进行自增。
	 *可是随着该应用程序的退出，该技术器也在内存中消失了。下一次再启动该程序，
	 *下一次启动改程序，又重新开始从0计数。
	 *程序即使计数，该计数器的值也存在，下次程序启动会先加载该计数器的值，并加1后重新存储起来。
	 *
	 *所以要建立一个配置文件，用于记录该软件的配置信息。
	 *该配置文件使用键值对形式，这样便于阅读数据，并操作数据。
	 *键值对数据是map集合，数据是以文件形式存储，使用io技术，那么
	 *map+io-->properties
	 *配置文件可以实现应用程序的共享。
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
	
    Properties prop=new Properties();
    File file=new File("count.ini");
    if(!(file.exists()))
    	file.createNewFile();
    
    FileInputStream fis=new FileInputStream(file);
    prop.load(fis);
    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  fos=new FileOutputStream(file);
    prop.store(fos, "次数");
    fos.close();
    fis.close();
	}

}

/*
 打印流：可以直接操作输入流和文件
 PrintStream  
 构造函数可以接受的参数类型：
 1，file对象。File
 2，字符串路径。 String
 3，字节输出流。OutputStream
 
  字符打印流：
  PrintWriter
  构造函数可以接受的参数类型：
  1，file对象。File
 2，字符串路径。 String
 3，字节输出流。OutputStream
 4，字符数输出流  Writer。
 */

package IO2;

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

public class PrintStreamDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws IOException {
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
		//PrintWriter out=new PrintWriter(System.out,true);//加true ln会自动刷新
		PrintWriter out=new PrintWriter(new FileWriter("fsdf.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();

	}

}

//序列流：合并流
package IO2;

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

public class SequenceDemo {

	public static void main(String[] args) throws Exception {
		Vector<FileInputStream> v = new Vector<FileInputStream>();
		v.add(new FileInputStream("c:\\1.txt"));
		v.add(new FileInputStream("c:\\2.txt"));
		v.add(new FileInputStream("c:\\3.txt"));
		
		Enumeration<FileInputStream> en=v.elements();
		SequenceInputStream  sis=new SequenceInputStream(en);
		FileOutputStream fos=new FileOutputStream("c:\\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();
	}

}

package IO2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;

public class SpliteFile {

	/**
	 * 文件切割
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//splitfile();
		 merge();
	}
	//切割
	public static void splitfile() throws IOException
	{
		FileInputStream fis=new FileInputStream("c:\\haha.mp3");
		FileOutputStream fos=null;
		byte[]buf=new byte[1024*1024];
		int len=0;
		int count=1;
		while(((len=fis.read(buf))!=-1))
		{
			fos=new FileOutputStream("c:\\"+(count++)+".part");
			fos.write(buf,0,len);
			fos.close();
		}
		fis.close();
	}
	//合并
	public static void  merge() throws IOException
	{
		ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
		for(int x=1;x<=6;x++)
		{
			al.add(new FileInputStream("c:\\"+x+".part"));
		}
		final Iterator<FileInputStream> it=al.iterator();
		Enumeration<FileInputStream> en= new Enumeration<FileInputStream>() {
			
			@Override
			public FileInputStream nextElement() {
				
				return  it.next();
			}
			
			@Override
			public boolean hasMoreElements() {
				// TODO Auto-generated method stub
				return  it.hasNext();
			}
		};
		SequenceInputStream  sis=new SequenceInputStream(en);
		FileOutputStream fos=new FileOutputStream("c:\\0.mp3");
		byte[] buf=new byte[1024];
		int len=0;
		while((len=sis.read(buf))!=-1)
		{
			fos.write(buf, 0, len);
		}
		fos.close();
		sis.close();
	}
	

}

 至此，IO流讲述完毕