day20File类，各方法。递归。删除一带内容的目录。Properties 。记录应用程序运行次数。打印流。切割合并文件。

/*
File类，各方法。递归。删除一个带内容的目录。Properties 。记录应用程序运行次数。打印流。切割合并文件。
*/


/*
File类
用来将文件或者文件夹封装成对象。
方便对文件与文件夹的属性信息进行操作
File对象可以作为参数传递给流的构造函数

了解File类中的常用方法
1,创建。
	boolean creatNewFile();在指定位置创建文件，如果文件已经存在，
		则不创建，返回false.
		和输出流不一样，输出流对象一建立就创建文件，而且文件存在会覆盖
	File creatTeamFile():创建临时文件.
	boolean mkdir();创建一级目录,创建文件夹。
	boolean mkdirs();创建多级目录
2。删除
	boolean delete();删除失败返回false。
	void deleteOnExit();在程序退出时删除指定文件。
3.判断
	boolean exists();文件是否存在。
	canExecute();能执行？
	isDirectory();是否是目录
	isFile();是否是文件
	isHidden();是否是隐藏文件
	f.ifAbsolute()；是否是抽象,是否是绝对路径。
4，获取信息
	getName():
	getPath();路径
	getParent();
	getAbsolutePath();//获取绝对路径
	lastModified();最后修改时间
	long length():文件大小
	renameTo:和移动文件差不多啊！
*/
import java.io.*;

class  FileDemo
{
	public static void main(String[] args) throws IOException
	{
		method_1();
	}
	public static void method_5()
	{
		File f1 = new File("c:\\test.java");
		File f2 = new File("c:\\hahaha.java");

		sop("rename:"+f1.renameTo(f2));//改名字，成功返回true.可用于复制文件
	}

	public static void method_4()//获取信息
	{
		File f = new File("c:\\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");//只关联，没有创建就不存在。
		//f.creatNewFile();这里才是创建文件。
		//f.mkdir();//这里是创建目录。

		//记住在判断文件对象是否是文件或者是目录时，必须
		//要先判断该文件对象封装的内容是否存在。exists()

		sop("dir:"+f.isDirectory());//1.false，不能用主观判断
		sop("file:"+f.isFile());//1.false

		sop(f.ifAbsobute());//绝对路径，文件不存在也能判断
	}
	public static void method_2()//判断
	{
		File f = new File("file.txt");
		sop("exists:"+f.exists());//exists：文件是否存在
		//sop("canExecute"+f.canExecute());//文件是否能执行。

		File dir = new File("abc\\kkk");
		sop("mkdir:"+dir.mkdir());//mkdir()只能创建一级目录。
		//mkdirs(),创建多级目录。
	}

	public static void method_1()throws IOException//创建和删除
	{
		File f = new File("file.txt");//将file.txt文件封装成file对象
		
		//sop("create:"+f.createNewFile());//创建，创建成功打印true.
		sop("delete"+f.delete());//删除成功返回true.如果程序异常，这句就读不到。
								//放到finally也可能删不掉，程序可能正在应用。
		f.deleteOnExit();//发生异常也没关系。在程序退出时会删除指定文件。
	}
	public static void consMethod()
	{
		File f1 = new File("a.txt");//将a.txt文件封装成file对象，这里不会创建。

		File f2 = new File("c;\\abc","b.txt");//目录和文件分开传入。

		File d = new File("c:\\abc");
		File f3 = new File(d,"c.txt");

		sop("f1:"+f1);//只打印路径。
		sop("f2:"+f2);//绝对路径
		sop("f3:"+f3);
		
		//反\\是目录分隔符。File.separator是跨平台的分隔符。
		File F4 = new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
//------------------------------
import java.io.*;
class FileDemo2 
{
	public static void main(String[] args) 
	{
		//listRootsDemo();
		//listDemo();
	}
	public static void listDemo3()
	{
		File f = new File("c:\\");

		File[] files = f.listFiles();//返回文件和文件对象，实际开发用这个。

		for (File f1 : files )
		{
			System.out.println(f1.getName()+".."+f1.length());
		}
	}
	public static void listDemo2()
	{
		File dir = new File("d:\\java0217\\day15");

		String[] arr = dir.list(new FilenameFilter()//文件名过滤，只拿文件名。
		{
			public boolean accept(File dir,String name)
			{
				//通过返回值确定文件是否存在
				//dir :上面的目录，name:文件名
				/*
				if (name.endsWith(".bak"))
				{
					return true;
				}
				else
					return false;
					*/
				return name.endsWith(".bmp");
			}
		});
		System.out.println("len:"+arr.length);

		for (String name:arr )
		{
			System.out.println(name);
		}
	}

	public static void listDemo()
	{
		File f = new File("c:\\");
		String[] names = f.list();
		//f必须是封装了一个目录，该目录必须存在。
		//当f.list,f为一个文件时，数组为空，会发生异常。

		for (String name: names)
		{
			System.out.println(name);//打印文件和文件夹名称，隐藏的也会打印。
		}
	}
	public static void listRootsDemo()
	{
		File[] files = File.listRoots();//列出机器里的有效盘符

		for (File f:files )
		{
			System.out.println(f);
			//System.out.println(f.length());//0。
		}
	}
}

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

因为目录中还有目录，只要使用同一个列出目录的功能的函数完成
在列出过程中出现的还是目录的话，还可以再次调用本功能

也就是函数自身调用自身
这种表现形式，或者编程手法，称为递归

递归要注意
1。限定条件。。。下一级程序结束的条件
2。要注意递归的次数，尽量避免内存溢出
*/
import java.io.*;

class  FileDemo3
{
	public static void main(String[] args) 
	{
		File f = new File("d:\\java\\package");
		showDir(f,0);
		
		//File f = new File("d:\\java0217");
		//showFile(f);
		
		//toBin(6);
		
		//int sum = getSum(10);
		//System.out.println(sum);
	}
	public static String getLevel(int level)
	{
		StringBuilder sb = new StringBuilder();
		sb.append("|--");
		for (int x =0;x<level ;x++ )
		{
			//sb.append("|--");
			sb.insert(0,"  ");
		}
		return sb.toString();
	}

	public static void showDir(File f,int level)
	{
		
		System.out.println(getLevel(level)+f.getName());
		level++;
		File[] files = f.listFiles();
		for (int x = 0;x<files.length ;x++ )
		{
			if (files[x].isDirectory())
			{
				showDir(files[x],level);
			}
			else
				System.out.println(getLevel(level)+f.getName());
		}		
	}
	public static int getSum(int i)//演示递归
	{
		if (i == 1)
		{
			return 1;
		}
		else
			return i + getSum(i-1);
	}

	public static void toBin(int i)//演示递归
	{
		if (i>0)
		{
			toBin(i/2);
			System.out.print(i%2);
		}
	}
	public static void showFile(File f)
	{
		System.out.println(f);
		File[] files = f.listFiles();
		for (int x = 0;x<files.length ;x++ )
		{
			if (files[x].isDirectory())
			{
				showFile(files[x]);
			}
			else
				System.out.println(files[x]);
		}	
	}
}

/*
删除一个带内容的目录
删除原理：
在window中，删除目录从里面往外删除的。
从里往外删除，就需要用到递归。
*/
import java.io.*;
class  RemoveDir
{
	public static void main(String[] args) 
	{
		File f = new File("d:\\test");
		deldir(f);
	}

	public static void deldir(File f)
	{
		File[] files = f.listFiles();

		for (int x = 0;x<files.length;x++ )
		{
			if (files[x].isDirectory())
			{
				deldir(files[x]);
			}
			else//不带else，会比较低效，因为是文件夹时已经删过一次了
				System.out.println(files[x].toString() +"-:file:-"+files[x].delete());
		}
		System.out.println(f +" :dir:"+f.delete());
	}
}

/*练习题
将一个指定目录下的java文件的绝对路径，存储到一个文本文件中
建立一个java文件列表文件。

1。对指定的目录进行递归
2。递归过程中拿到所有的java文件，存到集合中.
3。遍历集合，将这些文件路径存储到流中
4。将流中的数据写入到一个文件中
*/
import java.io.*;
import java.util.*;
class  JavaFileList
{
	public static void main(String[] args)throws IOException
	{
		File f = new File("d:\\java0217");

		List<File> list = new ArrayList<File>();

		FileToList(f,list);

		//System.out.println(list.size());

		File dir = new File(f,"info1.txt");

		listToFile(list,dir.toString());

	}

	public static void fileToList(File f,List<File> list)
	{
		File[] files = f.listFiles();
		for (File file:files)
		{
			if (file.isDirectory())
			{
				fileToList(file,list);
			}
			else 
			{
				if (file.getName().endsWith(".java"))
				{
					list.add(file);
				}
			}
		}
	}
	public static void listToFile(List<File> list,String name)throws IOException
	{
		BufferedWriter bufw = null;
		
		try
		{
			bufw = new BufferedWriter(new FileWriter(name));//自己指定的文件路径name
			for (File fi : list)
			{
				//bufw.write(fi.toString());//???
				String path = fi.getAbsolutePath();
				bufw.write(path);
				bufw.newLine();
				bufw.flush();
			}
		}
		catch (IOException e)
		{
			throw e;
		}

		finally
		{
			try
			{
				if(bufw != null)
					bufw.close();
			}
			catch (IOException e)
			{
				throw e;
			}
		}
	}
}

/*
Properties 是hashtable的子类
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串！
不需要泛型，是集合和IO技术相结合的集合容器

该对象的特点：可以用于键值形式的配置文件。
在加载数据时，需要数据有固定格式：键=值。
*/

import java.util.*;
import java.io.*;
class  PropertiesDemo
{
	public static void main(String[] args) throws IOException
	{
		//getSet();
		//getProperties();
		method();
	}
	/*
	public static void getSet()
	{
		//设置
		Properties prop = new Properties();

		prop.setProperty("zhangsan","20");
		prop.setProperty("lisi","29");

		//System.out.println(prop);

		String value = prop.getProperty("lisi");//获取
		//System.out.println(value);

		//Set<String> names = prop.stringPropertyNames();
		//1.6版本之后才有这方法
		for (String name:names)
		{
			String value1 = prop.getProperty(name);//get方法返回要强转
			System.out.println(name + "=" + value1);
		}
	}
	*/
	//演示将流中的数据存储到集合中
	//想要将info.txt中键值数据存到集合中进行操作
	/*method_1方法
	1用一个流和info.txt文件关联
	2读取一行数据，将该行数据用“=”进行切割
	3.等号左边作为键，右边作为值，存入到Properties集合中就可
	*/
		public static void method_1()throws IOException
		{
			BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));
			Properties prop = new Properties();
			
			String line = null;
			while ((line = bufr.readLine())!=null)
			{
				String[] arr = line.split("=");
				prop.setProperty(arr[0],arr[1]);
			}
			System.out.println(prop);
		}

	public static void method3()throws IOException
	{
		FileInputStream fis = new FileInputStream("info.txt");//流。
		Properties prop = new Properties();
		prop.load(fis);//加载输入字节流

		prop.setProperty("lisi","44");//改过来了，只改内存，但文件中没有保存。

		FileOutputStream fos = new FileOutputStream("info.txt");

		prop.store(fos,"");//这里存进了文件,修改了硬盘上的文件数据

		//System.out.println(prop);
		prop.list(System.out);//自己的输出方法。
	}
}
/*练习题
用于记录应用程序运行次数
如果使用次数已到，那么给出注册提示

很容易想到的是：计数器。
可是该计数器定义在程序中，随着程序的运行而在内存中存在，
并进行了自增。可是随着应用程序的退出，该计数器也在内存中消失

下一次再启动该程序，又重新开始从0计数，
这样不是我们想要的。

程序结束，该计数器的值也存在，下次程序启动会先加载计数器的值，
并加1后再重新存储起来

所以要建立一个配置文件，用于该计数次数。

该配置文件使用键值对的形式便于阅读数据，并操作数据
键值对数据是map集合。数据是以文件夹形式存储，使用IO技术
那么map+io--->properties

配置文件可以实现应用程序数据的共享。
*/
import java.io.*;
import java.util.*;
class RunCount
{
	public static void main(String[] args) throws IOException
	{	
		File file = new File("count.ini");
		if (!file.exists())
		{
			file.createNewFile();
		}
		FileInputStream fis = new FileInputStream(file);
		Properties prop = new Properties();

		prop.load(fis);

		String value = prop.getProperty("time");
		int count = 0;
		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,"");
 		fis.close();
		fos.close();
	}
}

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

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

PrintWriter:字符打印流,web开发常用，把字符一条一条打出去。
构造函数可以接收的参数类型
1.file对象File
2.字符串路径String
3.字节输出流OutputStream
4.字符输出流，Writer.
-------------
SequenceInputStream类
	合并流：多个源对应一个目的。先把多个源变成一个源，要用到枚举。
*/
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);//true.流有自动刷新
		PrintWriter out = new PrintWriter(new FileWriter("ab.txt"),true);

		String line = null;
		while ((line = bufr.readLine())!=null)
		{
			if ("over".equals(line))
			{
				break;
			}
			//out.write(line.toUpperCase());没有换行，用下面那个
			//out.flush();没有true就要刷新。

			out.println(line.toUpperCase());//加上true，就println自动刷新
		}
		bufr.close();
		out.close();
	}
}
import java.io.*;
import java.util.*;
class  SequenceFile
{
	public static void main(String[] args) throws IOException
	{
		sequenecFile();
	}
	public static void sequenecFile()throws IOException
	{
		//合并流，三个文件合成一个，三种方法拿到en.
		/*1.Vector<FileInputStream> v = new Vector<FileInputStream> ();

		v.add(new FileInputStream("c:\\file\\1.txt"));
		v.add(new FileInputStream("c:\\file\\2.txt"));
		v.add(new FileInputStream("c:\\file\\3.txt"));
		Enumeration<FileInputStream> en = v.elements();*/

		ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
		for (int x =1;x<=3 ;x++ )
		{
			al.add(new FileInputStream("c:\\file\\" + x+ ".txt"));
		}
		//2.Enumeration <FileInputStream>en = Collections.enumeration(al);
		//3.
		final Iterator <FileInputStream> it = al.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("c:\\file\\123.txt");
		int len = 0;
		byte[] buf = new byte[1024];
		while ((len = sis.read(buf))!=-1)
		{
			fos.write(buf,0,len);
		}
		sis.close();
		fos.close();
	}
}


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

//切割文件，再合并！
//切电影类的大文件别冲动！小心内存溢出。可以每装一次获取文件大小
//定个计数器，当装到100M的时候，再创建一个输出对象。

class SplitFile 
{
	public static void main(String[] args) throws IOException
	{
		FileInputStream fis = new FileInputStream("c:\\0.mp3"); 
		byte[] buf = new byte[1024*1024];
		int len = 0;int count = 1;
		FileOutputStream fos = null;
		while ((len = fis.read(buf))!=-1)
		{
			fos = new FileOutputStream("c:\\file\\"+ count+".part");
			fos.write(buf,0,len);
			count++;
			fos.close();
		}
		
		fis.close();//切割文件
		//-----------------
				//合并文件
		ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
		for (int x =1;x<=4 ;x++ )
		{
			al.add(new FileInputStream("c:\\file\\"+ x+".part"));
		}

		Enumeration<FileInputStream> en = Collections.enumeration(al);
		SequenceInputStream sis = new SequenceInputStream(en);

		FileOutputStream fos1 = new FileOutputStream("c:\\file\\111.mp3");

		byte[] buf1 = new byte[1024];
		int len1 = 0;
		while ((len1=sis.read(buf1))!=-1)
		{
			fos1.write(buf1,0,len1);
		}
		fos1.close();
		sis.close();
	}
}