黑马程序员 Java基础----IO流(2)

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

一:概述

File类:

用来将文件或者文件夹封装成对象

方便对文件与文件夹进行操作。

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

了解File类中的常用方法。

如何创建对象：

方式一:  File(String pathname)  

            通过给定路径名字符串转换为抽象路径名来创建一个新File实例

例:

File  f1  = new File(“c:\\a.txt”);   将文件a.txt封装成File对象，可以将已有的和未出现的文件和文件夹封装成File对象。

方式二:File(String parent , String child)

         根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

例:File f2 = new File(“c:\\”,”a.txt”);

方式三:File(File parent ,String child)

     根据parent抽象路径名和child路径名字符串创建一个新File实例.

例:File f3 = new File(“c:\\”);

   File f4 = new File(f3,”a.txt”);

此三种方式都把a.txt封装成了File对象。

系统默认分隔符:

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

File f5 = new File(“c:”+File.separator+”a.txt”);

二:File对象功能(创建和删除)

File类常见方法：

1，创建。

boolean createNewFile(); ：在指定位置创建文件,如果该文件已经存在，                    则不创建，则返回false。这和输出流不一样，输出流对象一建立就创建文件，如果文件已存在，则会被覆盖。

booelan  mkdir();  创建文件夹。只能创建一级目录。

booelan  mkdirs();  创建多级文件夹。

2.删除。

   boolean delete(); ：删除此抽象路径名表示的文件或者文件夹

   void deleteOnExit();:在虚拟机终止时,请求删除此抽象路径名表示的文件或者文件夹

3.判断.

   boolean canExecute(); 判断文件是否是执行

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

boolean isFile() ;是否是文件

Boolean isdirectory();  是否是文件目录

Boolean isHidden() ;是否是隐藏文件

Boolean isAbsolute();是否是绝对路径

4.获取信息。

  getName();  获取文件名

  getPath(); 文件对象封装的什么内容得到的就是什么内容

  getAbsolutePath(); 获取文件对象的相对路径

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

  long lastModified(); 返回此文件最后一次修改的时间

   long  length();  返回文件的大小。

  Boolean renameTo();  改变文件的名称。也有点相当于剪切。改名成功返回true

5.列出文件及过滤文件：

 static File[] listRoots();  返回可用的文件系统根。

 String[] list();  列出当前目录所有文件，包含隐藏文件，调用list方法的file对象，必须是封装了一个目录，且该目录必须存在。

File[] list(FilenameFilter filter)

 FilenameFilter：文件名过滤器，是一个接口，其中包含一个方法，accept(File dir,String name)，返回的是boolean型，对不符合条件的文件过滤掉。

       File[] listFiles()

 获取当前文件夹下的文件和文件夹，返回类型为File数组

       ListFiles(FilenameFilter filter)

 同list，是对获取的 当前文件夹下的文件和文件夹的 文件名过滤器。

实例：

package itcast;

import java.io.*;


public class FileDemo {
	public static void main(String[] args) throws Exception{

		  createMethod_5();	
	}
	public  static void createMethod() throws IOException{
		 File f1 = new File("e:\\file.txt");
		 System.out.println("create:"+f1.createNewFile());  //此处返回true
		 //要是再次允许此程序返回false,因为文件已经创建 

		 f1.deleteOnExit();
		 //System.out.println("delete:"+f1.delete());  //此处返回true 
	}
	public static void createMethod_2(){
		File f2 = new File("e:\\file.txt");  //创建File对象
		System.out.println("canexecute:"+f2.canExecute());  //此处返回true
		System.out.println("exists:"+f2.exists());  //此处返回true
		
		File f3 = new File("abc");
		System.out.println("mkdir:"+f3.mkdir());  //创建一级目录。返回true
		
		File f4 = new File("abc\\kk\\acaa\\aa\\aaa");
		System.out.println("mkdirs:"+f4.mkdirs());  //创建多级目录。返回true
	}
	
	public static void createMethod_3(){
		File f = new File("file.txt");
		//在判断文件对象是否为文件目录或文件时,一定要先判断文件封装的内容是否存在
		//通过exists
		System.out.println("dir"+f.isDirectory());  //判断文件对象是否是目录
		System.out.println("file"+f.isFile());  //判断文件对象是否是文件
	}
	
	public static void createMethod_4(){
		File f = new File("a.txt");
		System.out.println("path："+f.getPath());  //文件封装的什么内容就获得的是什么内容
		System.out.println("abspath："+f.getAbsolutePath()); //获取文件对象的相对路径
		System.out.println("parent："+f.getParent());  //该方法返回的是绝对路径中的父目录。如果获取的是相对路径，则返回null。如果相对路径中有上一层父目录那么该目录就是返回结果。
	}
	public static void createMethod_5(){
		File f = new File("e:\\1.mp3");
		File f2 = new File("f:\\2.mp3");
		System.out.println("renameto："+f.renameTo(f2));  //改名成功返回true 相当于剪切
	}

}

练习：

package itcast;

import java.io.*;

public class FileDemo2 {
	public static void main(String[] args){
         FilenameFilterMethod();
        
	}

	public static void FilenameFilterMethod() {
		final File f = new File("E:\\webserver\\itcast\\src\\itcast");
        String[] files = f.list(new FilenameFilter(){

			@Override 
			public boolean accept(File dir, String name) {
				// TODO Auto-generated method stub
				
				if(name.endsWith(".java"))
				{
				   return true;	
				}
				return false;
			}});
        for(String file:files){
        	System.out.println(file);
        }
	}
	

}

三：递归

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

也就是列出指定目录下所有内容。

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

递归要注意：1.限定条件，是作为循环结束条件的，否则会出现死循环

2.要注意递归的次数。尽量避免内存溢出

实例：

列出指定目录下文件或文件夹，包含子目录，即列出指定目录下所有内容

package itcast;

import java.io.File;

public class FileDemo3 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
         File f = new File("d:\\360安全卫士");
         showDir(f);
	}
	
	public static void showDir(File file){
		System.out.println(file);
		  File[] files = file.listFiles();
		  for(int i=0;i<files.length;i++){
			  if(files[i].isDirectory()){
				  showDir(files[i]);
			  }
			  else
			   System.out.println(files[i]);
		  }
	}

}

删除一个带内容的目录。

删除原理：

在window中，删除目录从里面往外删除的。同样使用递归

package itcast;

import java.io.File;

public class RemoveDir {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
         File  f= new File("f:\\C#代码");
         removeDir(f);
	}
	
	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()+"："+files[i].delete());
			  }
		 }
		 System.out.println(dir+"："+dir.delete());
	}

}

练习

将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。

建立一个java文件列表文件。

思路：

1.对指定的目录进行递归。

2.获取递归过程中的java文件的路径。

3.将这么路径存储到集合众。

4.将集合中的数据写入到一个文件中。

package itcast;

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

public class JavalistDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		File f = new File("E:\\webserver");
		List<File> list = new ArrayList<File>();
		javaList(f,list);
		//System.out.println(list.size());
        File f2 = new File(f,"javaList.txt");
        writerList(list,f2.toString());
	}
	
	public static void javaList(File file,List<File> list){
		  File[] files = file.listFiles();
		  for(File f:files){
			   if(f.isDirectory()){
				    javaList(f,list);
			   }
			   else{
				    if(f.getName().endsWith(".java")){
				    	 list.add(f);
				    }
			   }
				   
		  }
	}
	public static void writerList(List<File> list,String filename){
		BufferedWriter bw = null;
		 try{
			 bw = new BufferedWriter(new FileWriter(filename));
			 for(File file:list){
				  String name = file.getAbsolutePath();
				  bw.write(name);
				  bw.newLine();
				  bw.flush();
			 }
		 }
		 catch(IOException e){
			 e.printStackTrace();
		 }
		 finally{
			  if(bw!=null){
				  try {
					bw.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			  }
		 }
	}

}

第二节 Properties类

一．概述：Properties是hashtable的子类。也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。

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

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

常用方法：设置和获取元素。

 Object setProperty(String key,String value) ; :调用hashtable的put方法

 String getProperty(String key) ;  以键搜索属性值。

 Set<String> stringPropertynames();  :此属性列表中的键集，其中该键及其对

应值是字符串，包括默认属性列表中的键。

void load(InputStream in) ; :从输入字节流中读取属性列表。

void load(Reader reader); :从输入字符流中读取熟悉列表。

void store(OutputStream out,String comments); ：该方法用于将properties表中的属性列表(键值对)写入到输出流中。

演示，如何将流中的数据存储到集合中。

想要将info.txt中键值数据存到集合中进行操作

思路：

1.用一个流和info.txt文件关联

2.读取一行数据，将该行数据用”=”进行切割。

3.等号左边作为键，右边作为值，存入到Properties集合中即可

package itcast;

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

public class PropertiesDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		loadDemo();
	}
	
	public static void method_1() throws IOException{
		 BufferedReader br = new BufferedReader(new FileReader("e:\\info.txt"));
		 Properties  p   = new Properties();
		 String line=null;
		 while((line=br.readLine())!=null){
			  String[] names = line.split("=");
			
			  p.setProperty(names[0], names[1]);
			 
		 }
		 System.out.println(p);
	}
	public static void loadDemo() throws IOException{
		 FileInputStream f = new FileInputStream("e:\\info.txt");
	    
		 Properties p = new Properties();
		 p.load(f);
		 p.setProperty("zhangsan", "99");
		 FileOutputStream out = new FileOutputStream("e:\\info.txt");
	      p.store(out, "hahah");
		 p.list(System.out);
	}

}

练习：用于记录应用程序运行次数。

如果使用次数已到，那么给出注册提示。

思路：很容易想到的是：计数器。

可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。

可是随着该应用程序的退出，该计数器也在内存中消失了。

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

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

所以要建议一个配置文件。用于记录该软件的使用次数。

该配置文件使用键值对得方式存储。

package itcast;
/*
 * 练习：用于记录应用程序运行次数。
 */
import java.io.*;
import java.util.Properties;

public class RunCount {
	public static void main(String[] args){
		 Properties  prop = new Properties();
		 int count=0;
		 try {
			 File f1 = new File("info.txt");
			 if(!f1.exists()){
				 try {
					f1.createNewFile();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			 }
			FileInputStream fs = new FileInputStream("info.txt");
			try {
				prop.load(fs);
				if(prop.getProperty("time")!=null){
					count =Integer.parseInt( prop.getProperty("time"));
					if(count>=5){
						System.out.println("游戏时间已到,请注册！");
						return;
					}
				}
				count++;
				prop.setProperty("time", count+"");
				FileOutputStream fos = new FileOutputStream("info.txt");
				prop.store(fos, "");
				fos.close();
				fs.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

}

第三节 打印流

一．概述：PrintWriter与PintStream

字节打印流：PrintStream

PrintStream为其他输出添加了功能，使它们能够方便地打印各种数据值表示形式。

构造函数可以接收的参数类型：

1.file对象。

2.字符串路径。String

3.字节输出流。OutputStream

字符打印流：PrintWriter

1.1.file对象。

2.字符串路径。String

3.字节输出流。OutputStream

4.字符输出流。Writer

实例：

package itcast;
/*
 * 打印流
 */
import java.io.*;



public class PrintStreanDemo {
	public static void main(String[] args) throws IOException{
		  //创建键盘输入
		  BufferedReader bw = new BufferedReader(new InputStreamReader(System.in));
		  //创建打印流对象
		  PrintWriter  pw = new PrintWriter(System.out,true);
		  
		  String line=null;
		  while((line=bw.readLine())!=null){
			     if(line.equals("over")){
			    	 break;
			     }
			    pw.println(line.toUpperCase());
			    //pw.flush();
		  }
		  pw.close();
		  bw.close();
	}

}

第三节 合并流

类：sequenceInputStream ：表示其他输入流的逻辑串联。

构造方法：

一 . SequenceInputStream(Enumeration<? extends InputStream> e)

二．SequenceInputStream(InputStream s1,InputStream s2)

演示如何将一个文件切割成很多份，如下面代码splitFile()方法。

演示如何将很多份碎片文件合并成一个完整的文件，如下面代码sequenceFile（）方法

package itcast;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
public class SplitFileDemo {
	public static void main(String[] args){
		 sequenceFile();
	}
	//合并文件
	public static void sequenceFile(){
		ArrayList<FileInputStream>  list = new ArrayList<FileInputStream>();
		File f = new File("e:\\splitfile");
		String[] str = f.list();
		for(int i=1;i<=str.length;i++){
			 try {
				list.add(new FileInputStream("e:\\splitfile\\"+i+".part"));
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		final Iterator<FileInputStream>  it = list.iterator();
		Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){

			@Override
			public boolean hasMoreElements() {
				// TODO Auto-generated method stub
				return it.hasNext();
			}

			@Override
			public FileInputStream nextElement() {
				// TODO Auto-generated method stub
				return it.next();
			}
			
		};
		SequenceInputStream  sis = new SequenceInputStream(en);
		byte[] b = new byte[1024];
		int len=0;
		try {
			FileOutputStream  fos = new FileOutputStream("e:\\splitfile\\时光.mp3");
			try {
				while((len=sis.read(b))!=-1){
					 fos.write(b, 0, len);
				}
				fos.close();
				sis.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	//切割文件分成很多份
	public static void splitFile(){
		  try {
			FileInputStream fs = new FileInputStream("e:\\1.mp3");
			FileOutputStream  fos =null;
			byte[] b = new byte[1024*1024];
			int len=0;
			int count=1;
			try {
				while((len=fs.read(b))!=-1){
					   fos = new FileOutputStream("e:\\splitfile\\"+(count++)+".part");
					   fos.write(b, 0, len);
				}
				if(fos!=null){
					fos.close();
				}
				fs.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	
	}

}