Java文件操作与配置文件管理-优快云博客

* File类常见方法:

* 1.创建
* boolean creatNewFlie()：在指定位置创建文件，如果文件已经存在，则不创建，返回false
* 和输出流不一样，输出流对象一建立创建文件，而且文件已经存在，会覆盖
* boolean mkdir():创建文件夹
* boolean mkdirs()：创建多级文件夹
* 2.删除
* boolean delete(); 删除失败返回false,如果文件正在被使用，则删除不了返回false
* void deleteOnExit();程序退出时删除指定文件
*
* 3.判断
* boolean execute 是否可执行
* boolean exists 文件是否存在
* isHidden()
* isFile()
* isDirectory()
* 4.获取信息

package cn.baidu.com;
import java.io.*;

public class FileDemo {

	public static void main(String[] args) throws IOException {
		method_4();

	}
	public static void method_2()
	{
		File f=new File("D:\\new.txt");
		sop("execute:"+f.canExecute());
	}
	public static void method_1() throws IOException
	{
		File f=new File("D:\\new.txt");
		sop("Create:"+f.createNewFile());
		if(f.exists())
		{
			sop("delete:"+f.delete());
		}
	}
	public static void method_3()
	{
		File dir=new File("D:\\isFile");
		sop("mkdir:"+dir.mkdir());
	}
	public static void method_4()
	{
		File f=new File("D:\\isFile");
		if(f.exists())
		{
			sop("dir:"+f.isDirectory());
			sop("file:"+f.isFile());
			sop("是否为绝对路径："+f.isAbsolute());
		}
	}
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

1.创建

package cn.baidu.com;
import java.io.*;
/*
 * File类常见方法:
 * 1.创建
 */
public class FileDemo2 {

	public static void main(String[] args) {
		Demo1();
	}
	public static void method_1() 
	{
		File[] files=File.listRoots();
		for(File f:files)//列出电脑有效盘符
		{
			System.out.println(f);
		}
	}
	public static void method_2() 
	{
		File f=new File("C:\\");//调用list方法的file对象必须是一个文件目录，该目录必须存在
		String[] names=f.list();//列出当前目录下所有文件
		for(String name:names)
		{
			System.out.println(name);
		}
	}
	public static void Demo1()
	{
		File dir=new File("D:\\360Downloads");
		String arr[]=dir.list(new FilenameFilter()//使用匿名内部类
		{
			public boolean accept(File dir,String name)
			{
				return name.endsWith(".txt");
			}
		});
		System.out.println("len:"+arr.length);
		for(String name:arr)
		{
			System.out.println(name);
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

/*
* 2.删除原理:
* 在window中，删除目录从里面往外删除的
*
* 既然从里往外删除，就要用到递归
*
*/

package cn.baidu.com;
import java.io.*;

public class FileDemo3 {

	public static void main(String[] args)  {
		File dir=new File("D:\\360Downloads");
		removeDir(dir);
	}
	public static void removeDir(File dir)
	{
		File[] files =dir.listFiles();
		for(int x=0;x<files.length;x++)
		{
			if(files[x].isDirectory()&&files[x].isHidden())
			{
				removeDir(files[x]);
			}
			else
			{
				System.out.println(files[x].toString()+":file:"+files[x].delete());
			}
		}
		System.out.println(dir+":dir:"+dir.delete());
	}
	

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

/*
* 列出指定目录下文件或者文件夹，包含子目录中的内容
*
* 因为目录中还有目录，只要使用同一个列出目录的功能的函数完成即可
* 在列出过程中出现的还是目录的话，还可以再次调用本功能
* 也就是函数自身调用自身，即递归
*
* 递归：1.递归限定条件
* 2.注意：递归的次数，尽量避免内存溢出

package cn.baidu.com;
import java.io.*;
public class FileDemo4 {

	public static void main(String[] args)  {
		File dir=new File("D:\\360Downloads");
		ShowDir(dir,0);
		
		//int n=getSum(3);
		//System.out.println("n="+n);
		
	}
//	public static int getSum(int n)
//	{
//		if(n==1)
//		{
//			return 1;
//		}
//		return n+getSum(n-1);
//	}
	public static String getLevel(int level)
	{
		StringBuilder sb=new StringBuilder();
		sb.append("+--");
		for(int x=0;x<level;x++)
		{
			sb.insert(0, "|  ");
		}
		return sb.toString();
	}
	
	public static void ShowDir(File dir,int level)
	{
		System.out.println(getLevel(level)+dir.getName());
		level++;
		File[] files=dir.listFiles();//获取当前目录下所有文件
		for(int x=0;x<files.length;x++)
		{
			if(files[x].isDirectory())//判断其是不是文件夹
				ShowDir(files[x],level);
			else
				System.out.println(getLevel(level)+files[x]);
		}
	}
	public static void method_1() 
	{
		File[] files=File.listRoots();
		for(File f:files)//列出电脑有效盘符
		{
			System.out.println(f);
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

* Properties是hashtable的子类
* 也就是说它具备map集合的特点，而且它里面存储的键值对都是字符串
*
* 是集合中和IO技术相结合的集合容器
* 该对象的特点，可以用于键值对形式的配置文件

package cn.baidu.com;
import java.io.*;
import java.util.*;

public class FileDemo5 {

	public static void main(String[] args) throws IOException {
		File dir=new File("D:\\Media");
		List<File> list=new ArrayList<File>();
		fileToList(dir,list);
		
		File file=new File(dir,"D:\\javalist.txt");
		writeToFile(list,file.toString());

	}
	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(".rmvb"))
					list.add(file);
			}
		}
	}
	public static void writeToFile(List<File> list,String javaListFile) throws IOException
	{
		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 e1)
		{
			throw e1;
		}
		finally
		{
			try
			{
				if(bufw!=null)
					bufw.close();
			}
			catch(IOException e)
			{
				throw e;
			}
		}
	}

}

package cn.baidu.com;
import java.io.*;
import java.util.*;

public class PropertiesDemo {

	public static void main(String[] args) throws IOException {
		setAndGet();
		//method_1();

	}
	//如何将流中的数据存储到集合中
	public static void loadDemo() throws IOException
	{
		Properties prop =new Properties();
		FileInputStream fis=new FileInputStream("info.txt");
		//将流中的数据加载进集合
		prop.load(fis);
		System.out.println(prop);
	}
	//将流中的数据存储到集合中
	//1.用一个流和info.txt文件关联
	//2.读取一行数据，将该行数据用“=”进行切割
	//等号左边作为键，右边为值，存入到Properties集合中即可
	public static void method_1() throws IOException
	{
		BufferedReader bufr=new BufferedReader(new FileReader("D:\\info.txt"));
		String line=null;
		Properties prop=new Properties();
		while((line=bufr.readLine())!=null)
		{
			String[] arr=line.split("=");
			//System.out.println(line);
			prop.setProperty(arr[0],arr[1]);
		}
		bufr.close();
		System.out.println(prop);
	}
	//设置和获取元素
	public static void setAndGet()
	{
		Properties prop=new Properties();
		
		prop.setProperty("zhangshan", "30");
		prop.setProperty("lishi", "39");
		prop.setProperty("zhangshan", "30");

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

/*小练习：
* 写一个程序，用于记录应用程序运行次数

* 如果使用次数已到，那么给出注册提示

* 思路：

* 很容易想到的是：计数器
* 可是计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增
* 可是随着该应用程序的退出，该计数器也在内存中消失了
* 下一次再启动该程序，又重新开始从0计数，这不符合我们的设计要求
* 程序即使结束，该计数器的值也存在
* 下次程序启动在会先加载该计数器的值并加一后再重新存储起来
* 考虑要建立一个配置文件，用于记录该软件的使用次数
* 该配置文件使用键值对的形式，map集合，这样便于阅读数据，并操作数据
* 数据是以文件形式存储，使用IO技术
* 那么map+io-->propertise
* 配置文件可以实现应用程序数据的共享
*/

package cn.baidu.com;
import java.io.*;
import java.util.Properties;


public class Runcount {

	public static void main(String[] args) throws Exception {
		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("用户您好，试用次数已到，请购买！");
			}
		}
		count++;
		prop.setProperty("time", count+"");//设置time的次数
		
		FileOutputStream fos=new FileOutputStream(file);
		
		prop.store(fos, "");
		
		fos.close();
		fis.close();
	}



}

/*
* 打印流
* 该流提供了打印方法，可以将各种数据类型的数据都原样打印
*
* 字节打印流：
* PrintStream
* 构造函数可以接收的参数类型：
* file对象、字符串路径、字节输出流
*
* 字符打印流：
* PrintWriter
* 构造函数可以接收的参数类型：
* file对象、字符串路径、字节输出流、字符输出流
*/

package cn.baidu.com;
import java.io.*;

public class PrintStreamDemo {

	public static void main(String[] args) throws IOException {
		BufferedReader bufr=
				new BufferedReader(new InputStreamReader(System.in));
		
		PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter("a.txt")),true);
		
		String line=null;
		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
				break;
			out.println(line.toUpperCase());
			
		}
		out.close();
		bufr.close();

	}

}

序列流

package cn.baidu.com;
/*
 * 序列流
 * 合并流
 */
import java.io.*;
import java.util.*;
public class SequenceDemo {

	public static void main(String[] args) throws IOException {
		Vector<FileInputStream> v=new Vector<FileInputStream>();
		
		v.add(new FileInputStream("F:\\Demo1.txt"));//添加到流中
		v.add(new FileInputStream("F:\\Demo2.txt"));
		v.add(new FileInputStream("F:\\Demo3.txt"));
		
		Enumeration<FileInputStream> en=v.elements();
		SequenceInputStream sis=new SequenceInputStream(en);//创建序列流对象
		
		FileOutputStream fos=new FileOutputStream("F:\\DemoNew.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 cn.baidu.com;
 
import java.io.*;
import java.util.*;
//分割与合并文件
public class SplitFile {

	public static void main(String[] args) throws IOException {
		splitFile();//分割文件
		merge();//合并文件
	}
	public static void merge() throws IOException
	{
		ArrayList<FileInputStream> a1=new ArrayList<FileInputStream>();//创建ArrayList集合用来装已经切割的三个文件流
		
		for(int x=1;x<=4;x++)
		{
			a1.add(new FileInputStream("F:\\Demo"+x+".part"));//添加到ArrayList去
			
		}
		final Iterator<FileInputStream> it=a1.iterator();//创建迭代器
		
		Enumeration<FileInputStream> en=new Enumeration<FileInputStream>()
		{
			public boolean hasMoreElements()//判断是否有更多元素
			{
				return it.hasNext();//返回下一个元素
			}
			public FileInputStream nextElement()
			{
				return it.next();
			}
		};
		
		SequenceInputStream sis=new SequenceInputStream(en);
		FileOutputStream fos=new FileOutputStream("F:\\NEW-DHTML.chm");
		byte[] buf=new byte[1024*1024];
		int len=0;
		while((len=sis.read(buf))!=-1)
		{
			fos.write(buf, 0, len);
		}
		
		fos.close();
		sis.close();
	}
	public static void splitFile() throws IOException
	{
		FileInputStream fis=new FileInputStream("F:\\DHTML.chm");
		FileOutputStream fos=null;
		byte[] buf=new byte[1024*1024];
		int len=0;
		int count=1;
		while((len=fis.read(buf))!=-1)
		{
			fos=new FileOutputStream("F:\\Demo"+(count++)+".part");
			fos.write(buf, 0, len);
			fos.close();
		}
		fis.close();
	}


}

IO流之File类