黑马程序员 ---IO输入输出（二）

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

20-1 File概述

将a.txt封装成对象，可以将已有的和未出现的文件或者文件夹封装成对象：

File f1 = new File("a.txt");

separator:与系统有关的默认名称分隔符

File f2 = new File("c:"+File.seperator+"a.txt");

File类常见方法：
1，创建。
boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。

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

2，删除。
boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。
void deleteOnExit();在程序退出时删除指定文件。


3，判断。
boolean exists() :文件是否存在.
isFile():
isDirectory();
isHidden();
isAbsolute();


4，获取信息。
getName():
getPath():
getParent():该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。
   如果相对路径中有上一层目录那么该目录就是返回结果。

getAbsolutePath() 
long lastModified() 
long length() 

renameTo(File dest)
          重新命名此抽象路径名表示的文件
public static void method_5()
{
File f1 = new File("c:\\Test.java");
File f2 = new File("d:\\hahah.java");


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


}

static File[]  listRoots() :列出可用的文件系统根。

String[]  list(): 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。

String[]  list(FilenameFilter filter): 过滤得到指定名称的文件和目录

File[] listFiles()

import java.io.*;
class FileDemo2 
{
	public static void main(String[] args) 
	{
		//method ();
		//method_2 ();
		//method_3 ();
		method_4 ();
     }
		public static void method ()
		{

			File[] file = File.listRoots();

			for (File f :file)
			{
				System.out.println(f);
			}
		}

		public static void method_2 ()
		{
			File f = new File("c:\\111.jpg");

			String[] s = f.list();

			for (String str : s)
			{
				System.out.println(str);
			}
		}
		public static void method_3 ()

		{
			File dir = new File("D:\\TDDOWNLOAD");

			String[] s = dir.list(new FilenameFilter()
			{
				public boolean accept(File dir,String name)
				{
					/*if (name.endsWith(".rmvb"))
						return true;
					else
						return false;
						*/
						return name.endsWith(".rmvb");
				}
			});

			for(String str : s)
			{
				System.out.println(str);
			}
			System.out.println(s.length);
		}
		public static void method_4 ()
		{
			File dir = new File("c:\\");

			File[] files = dir.listFiles();

			for(File f : files)
			{
				System.out.println(f.getName()+"..."+f.length());
			}
		}



	
}

递归

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


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


递归要注意：
1，限定条件。
2，要注意递归的次数。尽量避免内存溢出。

import java.io.*;
class FileDemo3 
{
	public static void main(String[] args) 
	{
		//File dir = new File("C:\\Documents and Settings\\Administrator\\桌面\\Java");
		//showFile(dir);

		//toBin(6);
		System.out.println(getSum(10));
		
	}
		//列出指定目录下文件或文件夹，包含子目录中的文件
	public static void showFile(File dir)
	{
		System.out.println(dir);
		
		File[] files = dir.listFiles();

		for (int x=0;x<files.length ;x++ )
		{
			if (files[x].isDirectory())

				showFile(files[x]);
			else
			System.out.println(files[x]);
		}
	}
	//6的二进制
	public static void toBin(int n)
	{
		if (n>0)
		{
			toBin(n/2);
			System.out.println(n%2);
		}
		
	}
	//1-10的和
	public static int getSum(int n)
	{
		if (n==1)
			return 1;

		return n+getSum(n-1);
	}

}

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

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

*/

import java.io.*;
import java.util.*;
class  JavaFileList
{
	public static void main(String[] args) throws IOException
	{
		
		File dir = new File("C:\\Documents and Settings\\Administrator\\桌面\\Java");

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

		fileToList(dir,list);

		File file = new File("d:\\javaList.txt");
		writeToFile(list,file);

	}
	//将.java文件存到集合中
	public static void fileToList(File dir,List<File> list)
	{
		File[] file = dir.listFiles();

		for (int x=0;x<file.length ;x++ )
		{
			if (file[x].isDirectory())
				fileToList(file[x],list);
			else if (file[x].getName().endsWith(".java"))
				list.add(file[x]);
		}
	}

		public static void writeToFile(List<File> list,File file) throws IOException
		{
			BufferedWriter bufw = null;
			try
			{
				bufw = new BufferedWriter(new FileWriter(file));
				for (int x=0;x<list.size() ;x++ )
				{
					String s = list.get(x).getAbsolutePath();
					bufw.write(s);
					bufw.newLine();
					bufw.flush();
				}
			}
			catch (IOException e)
			{
				throw e;
			}
			finally
			{
				try
				{
					if (bufw!=null)
					bufw.close();
				}
				catch (IOException e)
			{
				throw e;
			}
			}
			
		}
}

/*
删除一个带内容的目录。
删除原理：
在window中，删除目录从里面往外删除的。

既然是从里往外删除。就需要用到递归。

*/
import java.io.*;
class RemoveDir 
{
	public static void main(String[] args) 
	{
		File dir = new File("d:\\11");

		removeDir(dir);
	}

	public static void removeDir(File dir)
	{
		File[] files = dir.listFiles();

		for (int x=0;x<files.length ;x++ )
		{
			if (files[x].isDirectory())
				removeDir(files[x]);
			else
				System.out.println(files[x].toString()+"::"+files[x].delete());
			
		}
			System.out.println(dir+"::"+dir.delete());
	}
}

//Properties存取；
import java.util.*;
class  PropertiesDemo
{
	public static void main(String[] args) 
	{
		setAndGet();
	}

	public static void setAndGet()
	{
		Properties pro = new Properties();

		pro.setProperty("zhangsan","20");

		pro.setProperty("lisi","25");

		//System.out.println(pro);

		String s = pro.getProperty("zhangsan");

		//System.out.println(s);

		Set<String> names = pro.stringPropertyNames();

		/*Iterator<String> it = names.iterator();

		while (it.hasNext())
		{
			String name = it.next();
			String age = pro.getProperty(name);

			System.out.println(name+":"+age);
		}
		*/
		for(String ss : names)
		{
			System.out.println(ss+":"+pro.getProperty(ss));
		}
	}
}

/*如何将流中的数据存储到集合中
1.用一个流和info.txt相关联
2.读取一行数据，并用“=”惊醒切割
3.将等号左右两边的数值作为键和值存到Properties中

*/
import java.util.*;
import java.io.*;
class  PropertiesDemo2
{
	public static void main(String[] args) throws IOException
	{
		method_2();
	}

	public static void method_2() throws IOException
	{
		FileReader fr = new FileReader("d:\\info.txt");
		Properties pro = new Properties();
		pro.load(fr);

		//System.out.println(pro);
		
		

		pro.setProperty("zhangsan","18");
		
		FileWriter fw = new FileWriter("d:\\info.txt");
		pro.store(fw,"haha");
		pro.list(System.out);
	}

	public static void method_1() throws IOException
	{
		BufferedReader bufr = new BufferedReader(new FileReader("d:\\info.txt"));
		Properties pro = new Properties();

		String line = null;
		
		while ((line=bufr.readLine())!=null)
		{
			String[] s = line.split("=");
			pro.setProperty(s[0],s[1]);
			
		}
		
		System.out.println(pro);
		bufr.close();

	}
}

/*用于记录应用程序运行次数。
如果使用次数已到，那么给出注册提示。
*/
import java.io.*;
import java.util.*;
class RunCount 
{
	public static void main(String[] args) throws IOException
	{
		Properties pro = new Properties();
		File f = new File("d:\\count.ini");
			if (!f.exists())
			 f.createNewFile();

		FileReader fr = new FileReader(f);

		pro.load(fr);

		int count=0;
		String value = pro.getProperty("time");
			if (value!=null)
		
		{
			count = Integer.parseInt(value);
				if (count>=5)
				{
					System.out.println("试用次数到了，请注册");
					return;
				}
		}
			count++;
			

			pro.setProperty("time",count+"");

			FileWriter fw = new FileWriter("d:\\count.ini");
				pro.store(fw,"");

			fr.close();
			fw.close();
		


			
				

	}
}

//打印输出流

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);

		String line = null;

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

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

//序列流 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("d:\\1.txt"));
		v.add(new FileInputStream("d:\\2.txt"));
		v.add(new FileInputStream("d:\\3.txt"));

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

		SequenceInputStream sis = new SequenceInputStream(en);

		FileOutputStream fos = new FileOutputStream("d:\\4.txt");

		byte[] by = new byte[1024];
		int len=0;

		while ((len=sis.read(by))!=-1)
		{
			fos.write(by,0,len);
			fos.flush();

		}

		fos.close();
		sis.close();
	}
}

//图片切割
import java.io.*;
class SplitDemo 
{
	public static void main(String[] args) throws IOException
	{
		FileInputStream fis = new FileInputStream("c:\\111.jpg");

		FileOutputStream fos = null;

		byte[] by = new byte[1024*10];
		int len=0;
		int count=1;
		while ((len=fis.read(by))!=-1)
		{
			fos= new FileOutputStream("c:\\"+(count++)+"");
			fos.write(by,0,len);
			fos.close();
		}
		fis.close();
	}
}

//ObjectOutputStream,ObjectInputStream

import java.io.*;
class ObjectStreamDemo 
{
	public static void main(String[] args) throws Exception
	{
		//writeObj();
		readObj();
	}

	public static void writeObj() throws IOException
	{
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:\\a.txt"));

		oos.writeObject(new Person("lisi",25));
		oos.close();
	}

	public static void readObj()throws Exception
	{
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\a.txt"));
			Person p =(Person)ois.readObject();

			System.out.println(p);
			ois.close();

	}
}
	class Person implements Serializable
	{
		public static final long serialVersionUID = 42L;

		private String name;
		private int age;

		Person(String name,int age)
		{
			this.name=name;
			this.age=age;
		
		}
		public String toString()
		{
			return name+"..."+age;
		}
	}

//RandomAccessFile
import java.io.*;
class  RAF
{
	public static void main(String[] args) throws IOException
	{
		//randomWrite();
		randomRead();
	}

	public static void randomWrite()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("d:\\a.txt","rw");

		raf.write("李四".getBytes());
		raf.writeInt(880);

		raf.write("王五".getBytes());
		raf.writeInt(33);
		
		raf.close();
	}

	public static void randomRead()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("d:\\a.txt","r");
		 raf.seek(8);
		byte[] by = new byte[4];

		raf.read(by);

		String name = new String(by);
		int age = raf.readInt();
		System.out.println("name:"+name+"   age:"+age);


		raf.close();

	}
}

//ByteArrayInputStream,ByteArrayoutputStream 
import java.io.*;
class  ByteDemo
{
	public static void main(String[] args) 
	{
		ByteArrayInputStream bis = new ByteArrayInputStream("abcdefg".getBytes());

		ByteArrayOutputStream bos = new ByteArrayOutputStream();

			int a = 0;
			while ((a=bis.read())!=-1)
			{
				bos.write(a);
			}
			
			System.out.println(bos.size());
			System.out.println(bos.toString());
	}
}

//转换流的字符编码
import java.io.*;
class EncodeStream 
{
	public static void main(String[] args) throws IOException
	{
		//writeText();

		readwriteText();
	}

	public static void writeText()throws IOException
	{
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf.txt"),"UTF-8");

		osw.write("你好");

		osw.close();
	}

		public static void readwriteText()throws IOException
		{
			InputStreamReader isr = new InputStreamReader(new FileInputStream("utf.txt"),"GBK");

			char[] ch = new char[1024];

			int len = 0;
			while ((len=isr.read(ch))!=-1)
			{
				System.out.println(new String(ch,0,len));

			}

			isr.close();
		}
}

new String(byte[] bytes) 
          通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。

Arrays.toString(byte[] a) : 返回指定数组内容的字符串表示形式。