黑马程序员---Java基础--20天(IO流之三)

---------------------- android培训、java培训、期待与您交流！ ----------------------

1.IO流(File概述)

2.IO流(File对象功能-创建和删除)

3.IO流(File对象功能-判断)

4.IO流(File对象功能-获取)

/*
 * File类常见方法:
 * 1.创建.
 * boolean createNewFile():
 * 		在制定位置创建文件,如果该文件已经存在,则不创建,返回false.
 * 		和出输出流不一样,输出流对象已建立创建文件,而且文件已经存在,会覆盖.
 * boolean mkdir():创建文件夹.
 * boolean mkdir():创建多级文件夹.
 * 
 * 2.删除.
 * boolean delete():删除失败返回false.如果文件正在被使用,则删除不了返回false.
 * void deleteOnExit():在程序退出是删除指定文件.
 * 
 * 3.判断.
 * boolean exists():文件是否存在.
 * isFile();
 * isHidden();
 * isAbsolute();
 * 
 * 4.获取信息.
 * getName();
 * getPath();
 * getParent();
 * 
 * getAbsolutePath();
 * long lastModified();
 * long length();
 * */
import java.io.*;
import java.lang.reflect.Field;
public class FileDemo {


	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		//method_1();
		//method_2();
		//method_3();
		//method_4();
		//method_5();
		consMethod();
	}
	public static void method_5()
	{
		File f1 = new File("E:\\java\\java0517\\day20\\file.txt");
		File f2 = new File("E:\\java\\java0517\\day20\\file1_rename.txt");
		
		sop("rename:"+f1.renameTo(f2));
	}
	public static void method_4()
	{
		File f = new File("E:\\java\\java0517\\day20\\file1.txt");
		
		sop("path:"+f.getPath());
		sop("abspath:"+f.getAbsolutePath());
		sop("parent:"+f.getParent());//该方法返回的是绝对路径的父目录.
		//如果获取的是相对路径,返回null.
		//如果相对路径中有上一层目录,那么该目录就是返回结果.
	}
	public static void method_3() throws IOException
	{
		File f = new File("E:\\java\\java0517\\day20\\file2.txt");
		f.createNewFile();
		f.mkdir();
		
		//记住在判断文件对象是否是文件或者目的时,必须要先判断该文件对象封装的
		//内容是否存在.
		//通过exists判断
		sop("dir:"+f.isDirectory());
		sop("file:"+f.isFile());
		
		sop(f.isAbsolute());
	}
	
	public static void method_2()
	{
		File f = new File("E:\\java\\java0517\\day20\\file.txt");
		sop("exists:"+f.exists());
		
		//创建文件夹
		File dir = new File("E:\\java\\java0517\\day20\\abc\\kkk\\a\\a\\dd\\ee\\qq\\aaa");
		sop("mkdir:"+dir.mkdirs());
	}
	public static void method_1() throws IOException
	{
		File f = new File("E:\\java\\java0517\\day20\\file.txt");
		sop("create:"+f.createNewFile());
		//sop("delete:"+f.delete());
	}
	public static void consMethod()
	{
		//将a.txt封装成File对象.可以将已有的和未出现的文件或者文件夹封装成对象.
		File f1 = new File("E:\\java\\java0517\\day20\\a.txt");
		
		File f2 = new File("E:\\java\\java0517\\day20","b.txt");
		
		File d = new File("E:\\java\\java0517\\day20");
		File f3 = new File(d,"c.txt");
		
		sop("f1:"+f1);
		sop("f2:"+f2);
		sop("f3:"+f3);
		
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}


}

5.IO流(File对象功能-文件列表)

6.IO流(File对象功能-文件列表2)

import java.io.*;




public class FileDemo2 {


	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//listDemo_2();
		File dir = new File("e:\\");
		File[] files = dir.listFiles();
		
		for(File f : files)
		{
			System.out.println(f.getName()+";;"+f.length());
		}
	}
	public static void listDemo_2()
	{
		File dir = new File("e:\\java");
		String[] arr = dir.list(new FilenameFilter()
		{


			public boolean accept(File dir, String name) {
				// TODO Auto-generated method stub
//				System.out.println("dir:"+dir+"...name"+name);
//				
//				if(name.endsWith(".txt"))
//				{
//					return true;
//				}
//				else
//					return false;
				return name.endsWith(".txt");
			}
		});
		
		System.out.println("len"+arr.length);
		for(String name : arr)
		{
			System.out.println(name);
		}
		
	}
	public static void listDemo()
	{
		File f = new File("E:\\");
		//调用list方法的file对象必须是封装了一个目录.该目录还必须存在
		String[] lists = f.list();
		for(String list : lists)
		{
			System.out.println(list);
		}
	}
	public static void listRootDemo()
	{
		File[] files = File.listRoots();
		for(File f : files)
		{
			System.out.println(f);
		}
	}
	


}

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

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

/*
 * 列出指定目录下文件或者文件夹,包含目录中的内容.
 * 也就是列出指定目录下所有内容.
 * 
 * 因为目录中还有目录,只要使用同一个列出目录功能的函数完成即可.
 * 在列出过程中出现的还是目录的话,还可以再次调用本功能.
 * 也就是函数自身调用自身.
 * 这种变线行驶,或者变成手法,成为递归.
 * 
 * 递归要注意:
 * 1.限定条件.
 * 2.要注意递归的次数.尽量避免内存溢出.
 * */
import java.io.*;
public class FileDemo3 {


	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//File dir = new File("e:\\java\\java0517");
		//showDir(dir,0);
		toBin(6);//求二进制
		int n = getSum(8000);
		System.out.println("n="+n);
	}
	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 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 int getSum(int n)
	{
		if(n==1)
			return 1;
		return n+getSum(n-1);
	}
	public static void toBin(int num)
	{
		if(num>0)
		{
			toBin(num/2);
			System.out.println(num%2);
		}
	}


}

9.IO流(删除带内容的目录)

/*
 * 删除一个带内容的目录.
 * 删除原理:
 * 在windows中,删除目录从里面往外删除.
 * 
 * 既然是从里往外删除,就需要用到递归.
 * */
import java.io.*;
public class RemoveDir {


	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		File dir = new File("e:\\test");
		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()+"-file-:"+files[x].delete());
			
		}
		System.out.println(dir+"::dir::"+dir.delete());
	}


}

10.IO流(创建java文件列表)

/*
 * 练习:将制定目录下的java文件的绝对路径,存储到一个文本文件中.
 * 建立一个java文件列表
 * 
 * 思路:
 * 1.对指定的目录进行递归.
 * 2.获取递归过程所有的java文件的路径.
 * 3.将这些路径存储到集合中去.
 * 4.将集合中的数据写入到一个文件中
 * */
import java.io.*;
import java.util.*;
public class JavaFileList {


	/**
	 * @param args
	 */
	public static void main(String[] args) throws IOException
	{
		// TODO Auto-generated method stub
		File dir = new File("e:\\java\\java0517");
		
		List<File> list = new ArrayList<File>();
		
		fileToList(dir,list);
		
		System.out.println(list.size());
		
		File file = new File(dir,"javalist.txt");
		
		writeToFile(list,file.toString());
		
	}


	public static void writeToFile( List<File> list,String javaListFile)throws IOException
	{
		// TODO Auto-generated method stub
		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) {
			// TODO Auto-generated catch block
			throw e;
		}finally
		{
			if(bufw!=null)
				bufw.close();
			
		}
		
	}


	public static void fileToList(File dir, List<File> list) {
		// TODO Auto-generated method stub
File[] files = dir.listFiles();
		
		for(File file : files)
		{
			if(file.isDirectory())
				fileToList(file, list);
			else
			{
				if(file.getName().endsWith(".java"))
					list.add(file);
			}
		}
	}


}

11.IO流(Properties简述)

12.IO流(Properties存取)

13.IO流(Properties存取配置文件)

/*
 * Properties是HashTable的子类.
 * 也就是说它具备集合的特点.而且它里面存储的键值对都是字符串.
 * 
 * 是集合中和IO技术中相结合的集合容器.
 * 
 * 该对象的特点:可以用于键值对形式的配置文件.
 * 
 * 那么加载数据时,需要数据有固定格式:键=值.
 * 
 * 练习:限制程序运行次数.
 * 当运行次数超过5次时,给出请您注册的提示.
 * */
import java.io.*;
import java.util.*;
public class PropertiesDemo {


	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
//		method_1();
		loadDemo();
	}
	public static void loadDemo() throws IOException
	{
		Properties prop = new Properties();
		FileInputStream fis = new FileInputStream("E:\\java\\java0517\\day20\\info.txt");
		
		//将流中的数据加载进集合
		prop.load(fis);
		prop.setProperty("wangwu", "39");
		
		FileOutputStream fos = new FileOutputStream("E:\\java\\java0517\\day20\\info.txt");
		
		prop.store(fos, "haha");
		
		prop.list(System.out);
		
		fos.close();
		fis.close();
	}
	//演示:如若将流中的数据存储到集合中.
	//1.用一个流和info.txt文件关联。
	//2.读取一行数据，将该行数据用"="进行切割。
	//3.等号左边作为键，右边作为值。存入到Properties集合中即可。
	public static void method_1() throws IOException
	{
		BufferedReader bufr = 
			new BufferedReader(new FileReader("E:\\java\\java0517\\day20\\info.txt"));
		String line = null;
		Properties prop = new Properties();
		
		while((line=bufr.readLine())!=null)
		{
			
			String[] arr = line.split("=");
		
			//System.out.println(arr[0]+";;;"+arr[1]);
			prop.setProperty(arr[0], arr[1]);
		}
		bufr.close();
		System.out.println(prop);
		
	}
	//设置和获取元素。
	public static void setAndGet()
	{
		Properties prop = new Properties();


		prop.setProperty("zhangsan","30");
		prop.setProperty("lisi","39");


//		System.out.println(prop);
		String value = prop.getProperty("lisi");
		//System.out.println(value);
			
		prop.setProperty("lisi",89+"");


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

14.IO流(Properties练习)

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


/*
 * 用于记录应用程序运行次数.
 * 如果使用次数已到,那么给出注册提示.
 * 
 * 很容易想到的是:计数器.
 * 可是该计数器定义在程序中,随着程序的运行而在内存中存在,并进行自增.
 * 可是随着该应用程序的的退出,该计数器也在内存中消失了.
 * 
 * 下一次再启动该程序,又重新开始从0计数.
 * 这样不是我们想要的.
 * 
 * 程序即使结束,该计数器的值也存在.
 * 下次程序启动会先加载该计数器的值并加1后重新存储起来.
 * 
 * 所以要建立一个配置文件.用于记录该软件的使用次数.
 * 
 * 该配置文件使用键值对的形式.
 * 这样便于阅读数据,并操作数据.
 * 
 * 键值对数据时map集合.
 * 数据是以文件形式存储,使用io技术.
 * 那么map+io -->properties
 * 
 * 配置文件可以实现应用程序数据的共享.
 * */
public class RunCount {


	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		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();
	}
	


}

15.IO流(PrintWriter)

/*
 * 打印流:
 * 该打印流提供了打印方法,可以将各种数据类型的数据都原样打印.
 * 
 * 字节打印流:
 * PrintStream
 * 构造函数可以接收的参数类型.
 * 1.file对象.File
 * 2.字符串路径.String
 * 3.字节输出流.OutputStream.
 * 
 * 字符打印流:
 * PrintWriter
 * 构造函数可以接收的参数类型.
 * 1.file对象.File
 * 2.字符串路径.String
 * 3.字节输出流.OutputStream
 * 4.字符输出流.Writer
 * */
import java.io.*;
public class PrintStreamDemo {


	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader bufr = 
			new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new FileWriter("a.txt"));
		String line = null;
		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
				break;
			out.println(line.toUpperCase());
			
		}
		out.close();
		bufr.close();
		
	}


}

16.IO流(合并流)

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




public class SequenceDemo {


	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		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();
	}


}

17.IO流(切割文件)

import java.io.*;
import java.util.*;
public class SplitFile {


	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		merge();
	}
	public static void merge() throws IOException
	{
		ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
		for(int x=1; x<=3; x++)
		{
			al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));
		}
		final Iterator<FileInputStream> it = al.iterator();
		
		Enumeration<FileInputStream> en = new Enumeration<FileInputStream>() 
		{
			
			
			public FileInputStream nextElement() {
				// TODO Auto-generated method stub
				return it.next();
			}
			
			public boolean hasMoreElements() {
				// TODO Auto-generated method stub
				return it.hasNext();
			}
		};
		SequenceInputStream sis = new SequenceInputStream(en);
		
		FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.png");
		
		byte[] buf = new byte[400];
		
		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("c:\\a.png");
		
		FileOutputStream fos = null;
		
		byte[] buf = new byte[400];
		
		int len = 0;
		int count = 1;
		while((len=fis.read(buf))!=-1)
		{
			fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");
			fos.write(buf,0,len);
			fos.close();
		}
		fis.close();
		
		
	}


}

---------------------- android培训、 java培训、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net/heima