黑马程序员--- 学习笔记(第二十天)

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————
File类
用于文件夹或文件封装成对象
方便对文件与文件夹的属性信息进行操作
File对象可以作为参数传递给流的构造函数


File f1=new File("a.txt");
将a.txt封装成对象,可以将已有的和未出现的文件或者文件夹封装成对象


File f2=new File("c:\\","b.txt");
将父目录与文件封装成对象


File f3=new File("c:\\");
File f4=new File(f3,"a.txt");
将目录封装成对象,作为对象传入到f4的构造函数


System.out.println(f1);


封装相对的路径,打印就是相对的,封装成绝对路径,打印就是绝对的


File.separator 系统默认的分隔符,跨平台的

/**
File类 构造函数以及常用方法演示类
*/ 
import java.io.*;
class Demo1 
{
	public static void main(String[] args) 
	{
		method_5();
	}
	public static void method_1(){
		/*以下常用三种构造方法 只是将文件或者目录封装封对象
		文件或者目录是不存在
		*/
		File f=new File("a.txt");

		File f1=new File("c:/a.txt");

		File dir=new File("c:"+File.separator);
		String fileName="a.txt";
		File f2=new File(dir,fileName);

		sop(f);
		sop(f1);
		sop(f2);
		

	}
	public static void method_2(){
	   File f=new File("c:"+File.separator+"a.txt");
	   File dirs=new File("c:/tttttt/adadadad/ddd");
	   File dir=new File("c:/tt");
	   File temp=null;
	   try
	   {
			sop(f.createNewFile());
			sop(dir.mkdir());
			sop(dirs.mkdirs());
			sop(temp=File.createTempFile("tddf","temp",new File("c:/")));	//创建临时文件
	   }
	   catch (IOException e)
	   {
		  sop(e.getMessage());
	   }
	   finally{
			f.delete();

			/*多级目录,只能删除子级一级*/
			dirs.deleteOnExit();

			dir.delete();

			if(temp!=null)
			temp.deleteOnExit();
	   }
	}
	public static void method_3(){
		File f=new File("a.ddd");
		File f1=new File("c:/");
		 try
	   {
			sop("创建文件"+f.createNewFile());
			if(f.exists()){
			
				sop("是否可读"+f.canRead());
				sop("是否可写"+f.canWrite());
				sop("是否可执行"+f.canExecute());
				sop("f1是否是目录"+f1.isDirectory());
				sop("f是否是目录"+f.isDirectory());
				sop("是否是文件"+f.isFile());
				sop("是否是隐藏文件"+f.isHidden());
				sop("是否是绝对路径"+f.isAbsolute());

			}else{
				System.out.println("文件已存在");
			}
	   }
	   catch (IOException e)
	   {
		  sop(e.getMessage());
	   }
	}
	public static void method_4(){
	File f=new File("a.txt");
	File f1=new File("c:/b.txt");									  
	File ff=new File("C:\\Documents and Settings\\Administrator\\桌面\\java\\day20");
	sop(f.getName());
	sop(f1.getName());

	sop(f.getParent());
	sop(f1.getParent());

	sop(f.getPath());
	sop(f1.getPath());

	sop(f.getAbsolutePath());
	sop(f1.getAbsolutePath());

	sop(f.lastModified());
	sop(f1.lastModified()) ;

	sop(f.length());
	sop(f1.length());
	sop(ff.length());
	}
	public static void method_5(){
	   // boolean renameTo(File dest) 
         // 重新命名此抽象路径名表示的文件。
		 /*
		 //文件更名
		 File f=new File("a.txt");
		 File ff=new File("b.txt");

		 sop(f.renameTo(ff));
		 */
		 /*移动文件*/
		  File f=new File("c:/a.txt");
		 File ff=new File("b.txt");

		 sop(ff.renameTo(f));

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

File类常见方法
1.创建
createNewFile();创建新文件,如果该文件存在返回false
mkdir();创建一级目录
mkdirs();创建多级目录
createTempFile();创建临时文件
2.删除
delete();//删除文件或目录
deleteOnExit();//在程序结束时,删除
3.判断
canExecute();是否可执行
canRead();是否可读
canWrite();是否可写
compareTo();比较文件或目录进行,获得依据排序
exits(); 判断文件是否存在
isDirectory(); 是否是目录
isFile();是否是文件
isHidden();是否是隐藏文件
isAbsolute();是否为绝对路径
注意:在判断文件对象是否是文件或者目录时,必须要判断该文件
封装的内容是否存在,通过exits判断


4.获取
getName();获取文件名
getParent();获取父目录,相对路径返回null,返回的是绝对路径
但,如果相对路径中有上一层目录,返回就是这个目录的结果
getPath();获取路径
getAbsolute();获取绝对路径
lastModified();获取最后一次修改时间,返回long
length();获取文件的大小,或目录的大小


覆盖的原理就是先删除在创建


5.重命名
renameTo();//可以移动文件,或者重命名

/*
File 常用方法
 String[] list() 
          返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。 
 String[] list(FilenameFilter filter) 
          返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。 
 File[] listFiles() 
          返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。 
 File[] listFiles(FileFilter filter) 
          返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。 
 File[] listFiles(FilenameFilter filter) 
          返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。 
static File[] listRoots() 
          列出可用的文件系统根。 
*/
import java.util.*;
import java.io.*;
class Demo2 
{
	public static void main(String[] args) 
	{
		method_3();
	}
	public static void method_1(){
	   	File []file=File.listRoots();
		for (File f : file )
		{
			sop(f);
		}
	}
	public static void method_2(){
		/*
		//第一种
		File file=new File("C:\\Documents and Settings\\Administrator\\桌面\\java");
		String []files=file.list();
		for (String s: files )
		{
			sop(s);
		}
		*/
		/*第二种 过滤只获取doc文件*/
	  File file=new File("C:\\Documents and Settings\\Administrator\\桌面\\java");
	 		String []files=file.list(new FilenameFilter(){
				public boolean accept(File dir,String name){

					return name.endsWith(".doc");
				}
			
			});
		for (String s: files )
		{
			sop(s);
		}

	}
	public static void method_3(){
		 File file=new File("C:\\Documents and Settings\\Administrator\\桌面\\java");

		
		/*
		//不使用过滤
		File []files=file.listFiles();

		for (File f : files)
		{
			//获取文件名
			sop(f.getName());
			//获取绝对路径,加文件大小
			//sop(f.getAbsolutePath()+" "+f.length());
		}
		*/
		/*使用过滤*/
		File []files=file.listFiles(new FilenameFilter(){
		
			public boolean accept(File absolutePath,String name){
				return name.endsWith(".doc");
			}
		});

		for (File f : files)
		{
			//获取文件名
			//sop(f.getName());
			//获取绝对路径,加文件大小
			sop(f.getAbsolutePath()+" 大小:"+f.length());
		}
	}
	public static void sop(Object o){
		System.out.println(o);
	}
}

listRoots();列出计算机上所有的盘符


list();获取指定目录的文件,包括隐藏文件
调用list方法,对象必须封装了一个目录,该目录必须存在 ..
list(过滤);//获取文件目录
list方法依据accept返回判定是否过滤文件,dir问知道指定过滤
目录,name为指定过滤文件名,用局部匿名内部类是实现


listFiles();//获取文件对象
返回当前目录文件夹的文件

/*

需求: 取指定目录下包括子目录所有文件,分级先显示
		例如d:/java
				|--test/
					|--Demo.java

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

递归注意事项:
1.必须要有限定条件
2.注意递归次数,过多会导致内存溢出

*/
import java.io.*;
class Demo3 
{
	public static void main(String[] args) 
	{
		//sop(getSum(12));
		//toBin(6);
		//如果指定目录不存在,空指针异常
	File file=new File("c:/test");
	   list(file,1);
	}
	/*等级划分*/
	public static String level(int l){
		StringBuilder sb=new StringBuilder();
		
		for (int i=0;i<l ;i++ )
		{
			sb.append("   ");
		}
		sb.append("|--");
		return sb.toString();
	}
	/*递归列出指定路径 所有目录或文件 包括子目录*/
	public static void list(File file,int l){
		l++;
		File files[]=file.listFiles();
		sop(file.getAbsolutePath());
		for (File f : files)
		{
			
			if(f.isDirectory())
				list(f,l);
			else
				sop(level(l)+f.getName());
		}
	}
	/*递归 求和*/
	public static int getSum(int num){
		if(num==1)
			return 1;
		return num+getSum(num-1);
	}
	/*递归 求二进制*/
	public static void toBin(int num){
		if(num>0) {
			toBin(num/2);
			System.out.println(num%2);
		}
	}
	public static void sop(Object o){
		System.out.println(o);
	}
}

/*
 删除一个带内容的目录

 删除原理:
 在window中,删除目录从里面往外删除,既然是从里往外删除,就要用到
 递归
*/
import java.io.*;
class Demo4 
{
	public static void main(String[] args) 
	{	 //目录不存在会报空指针异常
		File file=new File("c:/test2");
		deleteDir(file);
	}
	/*递归 删除指定目录*/
	public static void deleteDir(File file){
		File []files=file.listFiles();
		for (File f: files )
		{
			//如果是目录 就进里面删
			if(f.isDirectory())
				deleteDir(f);
			else
				sop(f.delete());
		}
		file.delete();
	}
	public static void sop(Object o){
		System.out.println(o);
	}
}

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

思路:
1.对指定目录进行递归
2.获取递归过程中java文件的路径
3.将这些路径存储到集合中
4.将集合写入到流
*/
import java.util.*;
import java.io.*;
class Demo5 
{
	public static void main(String[] args) 
	{
	 File file=new File("C:\\Documents and Settings\\Administrator\\桌面\\java");  
	  File filename=new File("list.txt");
	  ArrayList<File> al=new ArrayList<File>();
	  toList(file,al);
	  toText(al,filename);
	}
	/*将集合中读取绝对路径输出到硬盘文本文件list.txt*/
	public static void toText(ArrayList<File> al,File filename){
		BufferedWriter bos=null;
		try
		{
			bos=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename)));
			Iterator<File> it=al.iterator();
			for (;it.hasNext() ; )
			{
				bos.write(it.next().getAbsolutePath());
				bos.newLine();
			}
		}
		catch (IOException e)
		{
			System.out.println("写入失败");
		}
		finally{
			try
			{
				if(bos!=null)
					bos.close();
			}
			catch (IOException e)
			{
				System.out.println("关闭失败");
			}
		}
	}
	/*将java文件存进集合*/
	public static void toList(File file,ArrayList<File> al){
		File []files=file.listFiles();
		for (File f :files)
		{
			if(f.isDirectory())
				  toList(f,al);
			else
				if(f.getName().endsWith(".java"))
					al.add(f);
		}
	}
}

Properties类
是HashTable的子类,也就是说它具备Map集合的特点,而且他
里面存储的键值对,都是字符串


是集合和ＩＯ技术相结合的容器


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

/*
纪录程序运行次数,
如果使用次数已达到次数,那么给出提示
*/
import java.util.*;
import java.io.*;
class Demo6 
{
	public static void main(String[] args)throws Exception 
	{
		Properties p=new Properties();
		File file =new File("count.ini");
		PrintWriter pw=null;
		int count=1;
		if(!file.exists()){	 //如果文件不存在
			file.createNewFile();  //创建一个
			pw=new PrintWriter(new FileWriter(file),true);//设置输出目的并自动刷新
			pw.println("count="+count);
		}else{
			p.load(new FileInputStream(file)); //加载键值对
			count=new Integer(p.getProperty("count"));//获取值
			if(count>=5){ //5次为限
				System.out.println("你的使用次数已达5次,请充值后重新打开");
				return;
			}else{
				//每次使用增
				count++;
				//设置键值
				p.setProperty("count",count+"");
				//保存
				p.store(new PrintWriter(new FileWriter(file),true),"");
			}
		}
		//关流
		if(pw!=null)
			pw.close();	
	}
}

打印流:
该流提供了打印方法,可以将各种基本数据类型都原样打印


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


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


构造函数,autoFlush,如果设置为true,则println,printf或format
方法将自动刷新到输出流,只能用于流

/*
演示

字符打印流特有方法 

PrintWriter(OutputStream out, boolean autoFlush) 
          通过现有的 OutputStream 创建新的 PrintWriter。


*/
import java.io.*;
class Demo7 
{
	public static void main(String[] args) 
	{
		File file=new File("printWriter.txt");
		PrintWriter pw=null;
		try
		{
			//设置自动刷新就不用手动flush()了
			pw=new PrintWriter(new FileWriter(file),true);
//			  void println() 
//          通过写入行分隔符字符串终止当前行。 
				pw.println();
//			 void println(boolean x) 
//					  打印 boolean 值，然后终止该行。
				pw.println(true);
//			 void println(char x) 
//					  打印字符，然后终止该行。 
				pw.println('o');
//			 void println(char[] x) 
//					  打印字符数组，然后终止该行。
			char ch[]={'a','i'};
			pw.println(ch);
//			 void println(double x) 
//					  打印双精度浮点数，然后终止该行。 
			pw.println(3.14152);
//			 void println(float x) 
//					  打印浮点数，然后终止该行。 
			pw.println(8.88f);
//			 void println(int x) 
//					  打印整数，然后终止该行。
			pw.println(1314);
//			 void println(long x) 
//					  打印 long 整数，然后终止该行。
			pw.println(1313131);
//			 void println(Object x) 
//					  打印 Object，然后终止该行。
			pw.println(new Integer("9"));
//			 void println(String x) 
//					  打印 String，然后终止该行。 
		   pw.println("输入字符串");
		}
		catch (IOException e)
		{
		   System.out.println("写入错误");
		}
	}
}

SequenceInputStream
合并流

/*
切割文件


合并文件

SequenceInputStream
*/
import java.io.*;
import java.util.*;
class Demo8 
{
	public static void main(String[] args)throws Exception 
	{													 
		BufferedInputStream bis=new BufferedInputStream(new FileInputStream("Dj.mp3"));
		BufferedOutputStream bos=null;
		byte []buf=new byte[1024*1024*2];
		int len=0;
		int count=0;
		while((len=bis.read(buf))!=-1){
			bos=new BufferedOutputStream(new FileOutputStream("split/Dj_"+(++count)+".part"));
			bos.write(buf,0,len);
			bos.close();
		}
		ArrayList<InputStream> al=new ArrayList<InputStream>();
		count=0;
		while(count!=3){
			al.add(new FileInputStream("split/Dj_"+(++count)+".part"));
		}
		final Iterator<InputStream> it=al.iterator();
		Enumeration<InputStream> en=new Enumeration<InputStream>(){
		  public boolean hasMoreElements(){
			return it.hasNext();
		  }
		  public InputStream nextElement(){
			return it.next();
		  }
		};
		
		SequenceInputStream sis=new SequenceInputStream(en);
		PrintStream ps=new PrintStream("split/Dj.mp3");
		byte []b=new byte[1024];
		len=0;
		while((len=sis.read(b))!=-1){
		   ps.write(b,0,len);
		}
		if(bis!=null)
			bis.close();
		if(bos!=null)
			bos.close();
		sis.close();
		ps.close();
	}
}

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