Java基础_IO流（File类和properties类相关操作）

一、IO流(File概述)

File类：

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

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

/*
File概述:
*/
import java.io.*;
class FileDemo
{
	public static void main(String[] args) 
	{
		consMethod();
	}
	public static void consMethod()//创建File对象
	{
		//将a.txt封装成对象。可以将已有和未出现的文件或文件夹封装成对象
		File f1=new File("a.txt");//1

		File f2=new File("e:\\abc","b.txt");//2
		
		File d=new File("e:\\abc");//3
		File f3=new File(d,"c.txt");

		File f4=new File("c:"+File.separator+"abc"+File.separator+"e.txt");

		sop("f1:"+f1);
		sop("f2:"+f2);
		sop("f3:"+f3);
		sop("f4:"+f4);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

二、IO流(File对象功能)

File类常见方法：

1.创建。

boolean createNewFile()：在指定位置创建文件，如果该文件已经存在，则不创建，返回false。

 和输出流不一样，输出流对象一创建文件，而且文件已经存在，会覆盖。

boolean mkdir()：创建一级文件夹

boolean mkdirs():创建多级文件夹

2.删除。

boolean delete():删除失败返回false。

boolaan deleteOnExit():在程序退出时删除指定文件。

3.判断。

boolean canExecute():测试应用程序是否可以执行此抽象路径名表示的文件。 

boolean exists():文件是否存在。

boolean isFile():测试此抽象路径名表示的文件是否是一个标准文件。

boolean isDirectory():测试此抽象路径名表示的文件是否是一个目录。

boolean isHidden():测试此抽象路径名指定的文件是否是一个隐藏文件。

boolean isAbsolute():测试此抽象路径名是否为绝对路径名。

4.获取信息。

String getName():返回由此抽象路径名表示的文件或目录的名称。

String getPath():将此抽象路径名转换为一个路径名字符串。

String getParent():返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。

File getAbsoluteFile():返回此抽象路径名的绝对路径名形式。等同于 new File(this.getAbsolutePath())。 

String getAbsolutePath():返回此抽象路径名的绝对路径名字符串。

long lastModified():返回此抽象路径名表示的文件最后一次被修改的时间。 

long length():返回由此抽象路径名表示的文件的长度。如果此路径名表示一个目录，则返回值是不确定的。

boolean renameTo(File dest):重新命名此抽象路径名表示的文件。

/*
File类常见方法：

*/
import java.io.*;
class FileDemo
{
	public static void main(String[] args) throws IOException
	{
		consMethod();
		method_1();
		method_2();
		method_3();
		method_4();
		method_5();
	}
	
	public static void method_1()throws IOException
	{
		sop("method_1:");

		File f=new File("file.txt");
		f.deleteOnExit();//告诉结束程序时删除file.txt
		sop("create:"+f.createNewFile());
		sop("delete:"+f.delete());

		//创建文件夹（注意：目录已存在，则创建失败！）
		File dir1=new File("abc");
		sop("mkdir:"+dir1.mkdir());//创建一级文件夹
		File dir2=new File("abc\\bcd\\asd");
		sop("mkdirs:"+dir2.mkdirs());//创建多级文件夹


	}

	public static void method_2()throws IOException
	{
		sop("method_2:");

		File f=new File("file.txt");
		sop("exists:"+f.exists());
		//sop("execute:"+f.canExecute());
	}

	public static void method_3()throws IOException
	{
		sop("method_3:");

		File f=new File("file.txt");

		/*注意：在判断文件对象是否是文件或者目录时，必须先判断文件对象封装的内容是否存在。
		通过exists判断。
		*/
		f.createNewFile();
		//f.mkdir();
		sop("isDirectory:"+f.isDirectory());
		sop("isFile:"+f.isFile());

		sop("isAbsolute:"+f.isAbsolute());//测试此抽象路径名是否为绝对路径名。
	}
	public static void method_4()throws IOException
	{
		sop("method_4:");

		File f=new File("a.txt");
		f.createNewFile();
		sop("path:"+f.getPath());
		sop("abspath:"+f.getAbsolutePath());/*返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
											  如果相对路径中有上一层目录，那么就返回该目录。
											*/
	}
	public static void method_5()throws IOException
	{
		sop("method_5:");
		File f1=new File("e:\\a.txt");
		f1.createNewFile();
		File f2=new File("e:\\b.txt");

		sop("rename:"+f1.renameTo(f2));
	}


	public static void consMethod()//创建File对象
	{
		sop("consMethod:");
		//将a.txt封装成对象。可以将已有和未出现的文件或文件夹封装成对象
		File f1=new File("a.txt");//1

		File f2=new File("e:\\abc","b.txt");//2
		
		File d=new File("e:\\abc");//3
		File f3=new File(d,"c.txt");

		File f4=new File("c:"+File.separator+"abc"+File.separator+"e.txt");

		sop("f1:"+f1);
		sop("f2:"+f2);
		sop("f3:"+f3);
		sop("f4:"+f4);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

三、IO流(File对象功能-文件列表)

/*
static File[] listRoots():列出可用的文件系统根。
String[] list():返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。

String[] list(FilenameFilter filter)返回一个字符串数组，这些字符串指定此抽象路径名表示的
目录中满足指定过滤器的文件和目录。除了返回数组中的字符串必须满足过滤器外，此方法的行为与 
list() 方法相同。如果给定 filter 为 null，则接受所有名称。否则，当且仅当在此抽象路径名及
其表示的目录中的文件名或目录名上调用过滤器的 
FilenameFilter.accept(java.io.File, java.lang.String) 方法返回 true 时，该名称才满足过滤器。

*/
import java.io.*;
class FileDemo2 
{
	public static void main(String[] args) 
	{
		listDemo_1();//获取根目录文件和文件夹名称
		listDemo_2();//获取根目录文件和文件夹名称（只提取*.doc文件）
		listDemo_3();//获取根目录文件和文件夹名称以及文件的长度		
	}
	public static void listDemo_3()
	{
		File dir=new File("e:\\");
		File[] files=dir.listFiles();
		for(File f:files)
		{
			System.out.println("文件名:"+f.getName()+"长度："+f.length());
		}
		System.out.println();
	}
	public static void listDemo_2()
	{
		File dir=new File("e:\\");
		String[] arr=dir.list(new FilenameFilter(){
		
		public boolean accept(File fir,String name)
		{
			/*
			if(name.endsWith(".doc"))
				return true;
			else
				return false;
			*/

			return name.endsWith(".doc");
		}
		
		});
		for(String name:arr)
		{
			System.out.println(name);
		}
		System.out.println();
	}
	public static void listDemo_1()
	{
		File f=new File("c:\\");
		String[] names=f.list();//调用list的File对象必须是一个目录，该目录必须存在。
		for(String name:names)
		{
			System.out.println(name);
		}
		System.out.println();
	}
	public static void listRootsDemo()
	{
		File[] files =File.listRoots();
		for(File f:files)
		{
			System.out.println(f);
		}
		System.out.println();
	}
}

四、IO流(列出目录下所有内容-递归)

/*
列出指定目录下文件或文件夹，包含子目录中的内容。
也就是列出指定目录下的所有内容。

因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。在列出过程中出现的还是目录的话，
还可以再次调用本功能。也就是函数自身调用自身，这种编程手法称为递归。

注意：
1.限定条件
2.注意递归的次数，避免内存溢出。
*/
import java.io.*;
class FileDemo3 
{
	public static void main(String[] args) 
	{
		File dir=new File("d:\\");
		showDir(dir);

		//toBin(3);//十进制转换为二进制
		//System.out.println();
		//System.out.println(getNum(100));//等差数列前N项和
	}
	
	public static void showDir(File dir)
	{
		System.out.println(dir);
		File[] files=dir.listFiles();
		for(int i=0;i<files.length;i++)
		{
			if(files[i].isDirectory())
				showDir(files[i]);
			else
				System.out.println(files[i]);
		}
	}
	
	
	public static void toBin(int num)//十进制转换为二进制
	{
		if(num>0)
		{
			toBin(num/2);
			System.out.print(num%2);
		}
	}
	public static int getNum(int n)//等差数列前N项和
	{
		if(n==1)
			return 1;
		return n+getNum(n-1);
	}
}

五、IO流(列出目录下所有内容-带层次)

/*
列出目录下所有内容-带层次:
*/
import java.io.*;
class FileDemo3 
{
	public static void main(String[] args) 
	{
		File dir=new File("C:\\Users");
		showDir(dir,0);
	}
	public static String getLevel(int level)
	{
		StringBuilder sb=new StringBuilder();
		sb.append("|---");
		for(int i=0;i<level;i++)
		{
			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 i=0;i<files.length;i++)
		{
			if(files[i].isDirectory())
				showDir(files[i],level);
			else
				System.out.println(getLevel(level)+files[i]);
		}
	}
}

六、IO流(删除带内容的目录)

/*
删除一个带内容的目录：
删除原理：
在Windows中，删除目录从里面往外删除。
既然是从里往外删除，就需要用到递归。
*/
import java.io.*;
class RemoveDir 
{
	public static void main(String[] args) 
	{
		File dir=new File("e:\\removeText");
		removeDir(dir);
	}
	public static void removeDir(File dir)
	{
		File[] files=dir.listFiles();
		for(int i=0;i<files.length;i++)
		{
			if(files[i].isDirectory())
				removeDir(files[i]);
			else
				System.out.println(files[i].toString()+"\t文件删除状态："+files[i].delete());

		}
		System.out.println(dir+"\t目录删除状态："+dir.delete());
		
	}
}

七、IO流(创建java文件列表)

/*
练习：

将一个指定目录下的java文件的绝对路径存储到一个文本文件中，也就是建立
一个Java文件列表文件。

思路：
1.对指定的目录进行递归。
2.获取在递归过程中所有Java文件的路径。
3.将这些路径存储到集合中。
4.将集合中的数据写入到一个文件中。

*/
import java.io.*;
import java.util.*;
class JavaFileList 
{
	public static void main(String[] args)
	{
		File dir=new File("d:\\java");
		List<File> list=new ArrayList<File>();
		fileToList(dir,list);

		File file=new File(dir,"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(".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)
		{
			throw new RuntimeException("操作文件失败");
		}
		finally
		{
			try
			{
				if(bufw!=null)
					bufw.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("关闭写入流失败");
			}
		}
	}
}

八、IO流(Properties简述)

Properties是Hashtable的子类，也就是说它具备了Map集合的特点。它里面存储的键值对都是字符串。

是集合中和IO技术相结合的集合容器。

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

那么在加载数据式，需要数据有固定格式：键=值

九、IO流(Properties存取)

/*
Properties存取:
*/
import java.io.*;
import java.util.*;
class PropertiesDemo 
{
	public static void main(String[] args) 
	{
		setAndGet();
	}
	public static void setAndGet()
	{
		Properties prop=new Properties();
		prop.setProperty("zhangsan","20");
		prop.setProperty("lisi","39");

		System.out.println(prop);
		System.out.println(prop.getProperty("lisi"));
		
		prop.setProperty("lisi","43");
		Set<String> names=prop.stringPropertyNames();
		for(String s:names)
		{
			System.out.println(s+":"+prop.getProperty(s));
		}
	}
}

十、IO流(Properties存取配置文件)

/*
Properties存取:

想要将info.txt中键值数据存入到集合中进行操作。
1.用一个流和info.txt文件关联。
2.读取一行数据，将该行数据用"="号进行切割。
3.等号左边作为键，右边作为值。存入到Properties集合中。
*/
import java.io.*;
import java.util.*;
import java.io.*;
class PropertiesDemo 
{
	public static void main(String[] args)throws IOException
	{
		//setAndGet();
		//method_1();
		loadDemo();
	}
	public static void loadDemo()throws IOException
	{
		Properties prop=new Properties();
		FileInputStream fis=new FileInputStream("info.txt");

		//将流中的数据加载进集合。
		prop.load(fis);
		prop.setProperty("wangwu","21");

		FileOutputStream fos=new FileOutputStream("info.txt");
		prop.store(fos,"abc");//第二个参数：注释信息
		//System.out.println(prop);
		prop.list(System.out);
		fos.close();
	}
	public static void method_1()throws IOException
	{
		BufferedReader bufr=new BufferedReader(new FileReader("info.txt"));
		String line=null;
		Properties prop=new Properties();
		while((line=bufr.readLine())!=null)
		{
			String[] arr=line.split("=");
			//System.out.println("键："+arr[0]+"\t值："+arr[0]);
			prop.setProperty(arr[0],arr[1]);
		}
		bufr.close();

		System.out.println(prop);
	}
	public static void setAndGet()
	{
		Properties prop=new Properties();
		prop.setProperty("zhangsan","20");
		prop.setProperty("lisi","39");

		System.out.println(prop);
		System.out.println(prop.getProperty("lisi"));
		
		prop.setProperty("lisi","43");
		Set<String> names=prop.stringPropertyNames();
		for(String s:names)
		{
			System.out.println(s+":"+prop.getProperty(s));
		}
	}
}

十一、IO流(Properties练习)

/*
用于记录应用程序运行次数。
如果使用次数已到，那么给出注册提示。

很容易想到：计数器。
课时该计数器定义在程序中随着程序的运行而在内存中存在，并进行自增。
可是随着该应用程序的退出，计数器也在内存中消失了，下次再启动该程序，
该计数器也在内存中消失了。
下一次再启动该程序，又重新开始从0计数。
程序即使结束，该计数器的值也存在，下次程序启动在会先加载该计数器的值并加1后再重新
存储起来。所以要建立一个配置文件，用于记录该软件的使用次数。

该配置文件使用键值对的形式，这样便于阅读数据并操作数据。
键值对数据是Map集合。数据是以文件形式相结合，使用IO技术，那么 Map+IO --> Properties

配置文件可以实现应用程序数据的共享。

*/
import java.io.*;
import java.util.*;
class RunCount 
{
	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>=3)
			{
				System.out.println("您好，试用次数已到。");
				return;
			}
			
		}

		count++;
		prop.setProperty("time",count+"");
		FileOutputStream fos=new FileOutputStream(file);
		prop.store(fos,"");
	}
}

十二、IO流(PrintWriter)

打印流：

PrintWriter与PrintStream：

可以直接操作输入流和文件。

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

字节打印流：
PrintStream:
构造函数可以接受的参数类型：
1.file对象。File
2.字符串路径。String
3.字节输出流。OutputStream

字符打印流：
PrintWriter:
构造函数可以接受的参数类型：
1.file对象。File
2.字符串路径。String
3.字节输出流。OutputStream
4.字符输出流。Writer

*/
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(new FileWriter("a.txt"),true);//true:刷新缓冲区

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

十三、IO流(合并流)

序列流：

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

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

		SequenceInputStream sis=new SequenceInputStream(en);
		FileOutputStream fos=new FileOutputStream("e:\\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();

	}
}

十四、IO流(切割文件)

/*
切割，合并mp3文件：

*/
import java.io.*;
import java.util.*;
class SplitFile 
{
	public static void main(String[] args)throws IOException 
	{
		splitFile();
		merge();
	}
	public static void splitFile()throws IOException//切割
	{
		FileInputStream fis=new FileInputStream("e:\\1.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("e:\\splitfiles\\"+(count++)+".part");
			fos.write(buf,0,len);
			fos.close();
		}
		fis.close();
	}
	public static void merge()throws IOException //合并
	{
		ArrayList<FileInputStream> a1=new ArrayList<FileInputStream>();
		for(int i=1;i<=4;i++)
		{
			a1.add(new FileInputStream("e:\\splitfiles\\"+i+".part"));
		}

		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("e:\\splitfiles\\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();
	}
}