java File类

Posted 2020-07-16 xiewenda8

File 文件类

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

方便对文件与文件夹的属性信息进行操作。

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

</pre></div><div></div><h2>File 类的常用的方法。</h2><div><pre name="code" class="java">import java.io.*;
/*File类的常见方法
 1.创建。
   boolean  createNewFile();
   boolean  mkdir();创建文件夹
   boolean mkdirs();创建多级文件夹。
   
 2.删除。
   boolean delete();
   void  deleteOnExit();在程序退出时删除文件。
  
 3.判断。
     boolean canExcute(); 判断是否可执行
     boolean exists(); 文件事是否存在。
     isFile();文件
     isDirectory();文件夹
     isHidden();//java能得到文件中的隐藏文件但是对隐藏文件时不能访问的
     isAbsolute();//绝对路径即时不存在也能得到。
 4.获取信息。
     getName();
     getPath();
     getParent();
     
     getAbsolutePath();
     long lastModified();
     long length();
 
 */
public class FileDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args)throws IOException {
		// TODO Auto-generated method stub
          method_4();
	}
	  public static void method_1() throws IOException{
   		  File f= new File("d:\\file.txt");
   		  f.deleteOnExit();//告诉程序当程序结束时才删除f关联的文件 即使发生异常也不受影响
   		//System.out.println("creat:"+f.createNewFile());
   		 System.out.println("delete:"+f.delete());
		  
	  }
	  public static void method_2(){
		   File  f = new File("file.txt");
		  // System.out.println("execute:"+f.canExecute());
		  // System.out.println("exists:"+f.exists());
		   //创建文件夹
		   File dir = new File("d:\\abc");
		   File dirs = new File("d:\\abc\\a\\b\\c");
		    System.out.println("dir:"+dir.mkdir());
		    System.out.println("dirs:"+dirs.mkdirs());
	  }
	  public static void method_3(){
		  File f = new File("file.txt");
		  System.out.println("path:"+f.getPath());
		  System.out.println("absolutePath:"+f.getAbsolutePath());
		  System.out.println("parentpath:"+f.getParent());//该方法返回的是绝对路径中文件的父目录。如获取的是相对路径返回的是null。
		                                                   // 如果相对路径中有上一层目录那么该目录就是返回结果。
	  }
	  public static void method_4(){
		  File f1= new File("d:\\a.txt");
		  File f2= new File("haha.txt");
		  System.out.println(f2.renameTo(f1));//类似于剪切功能
	  }
     public static void consMethod(){
    	 //将a.txt封装成file对象，可以将已有的和为出现的文件或者文件夹封装为对象。
          File f1 = new File("d:\\a.txt");
          
          File f2 = new File("d:\\abc","b.txt");
          File d = new  File("d:\\abc");
          File f3= new File(d,"a.txt");
          System.out.println("f1:"+f1);
          System.out.println("f2:"+f2);
          System.out.println("f3:"+f3);
          //跨平台分隔符<span style="font-family: Arial, Helvetica, sans-serif;">File.separator</span>
          File f4 = new File("d:"+File.separator+"abc"+File.separator+"a.txt");
          System.out.println("f4:"+f4);
        		  
     }
}

获取系统根目录例子

import java.io.*;
public class FileDemo2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
          listDemo();
	}
	
	public static void listDemo(){
		 File f = new File("d:\\");
		 String[] names= f.list();//调用list方法的对象必须封装一个目录，封装文件返回为null
		 for(String name : names){
			 System.out.println(name);
		 }
	}
    public static void listRootsDemo(){
    	File[] files=File.listRoots();
    	
    	for(File f: files)
    	{
    		System.out.println(f);
    	}
    }
}

递归输出文件列表

import java.io.*;
/*
 列出指定目录下的文件或文件夹，包含子目录中的内容。
 也就是列出指定目录下所有内容。
 
 递归注意
 
 1 注意要有结束
 
 2 要注意递归的次数 防止内存溢出
 */

public class FileDemo3 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		  File  f= new File("d:\\u盘备份");
             showDir(f,0);
		   //System.out.println(getSum(10));
	}
	
	   public  static String getLevel(int level)
	   {
		    StringBuilder sb= new StringBuilder();
		    for(int i=0; i<level;i++){
		    	sb.append(" ");
		    }
		    sb.append("|--");
		   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 i=0;i<files.length;i++)
    	  {
    		  if(files[i].isDirectory())
    			  showDir(files[i],level);
    		  else
    			  System.out.println(getLevel(level)+files[i]);
    	  }
    	  
       
     }
     //补充:递归方法求和 
     public static int getSum(int num){
		 if(num==1)
			 return 1;
		 else return num+getSum(--num);
	  }
}

删除文件夹实例

import java.io.*;
/*
 * 删除文件夹要先删除里边的文件。因此就要用到递归了
 * 从里往外删除文件
 * 
 */
public class FileRemoveDir {

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

查找文件夹指定类型保存在文件中

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

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		File dir = new File("d:\\u盘备份");
		List<File> list= new ArrayList<File>();
		fileToList(dir,list);
        File f =new File("javaList.txt"); 
         writeToFile(list,f);
	}
    public static void fileToList(File dir,List<File> list)
    {
    	File[] files = dir.listFiles();
    	for (File file : files){
    		if(file.isDirectory())
    		{
    			fileToList(file,list);
    		}
    		else
    		{
    			if(file.getName().endsWith(".java"))
    				list.add(file);
    		}
    		
    	}
    }
    public static void writeToFile(List<File> List, File f) throws IOException
    {
    	BufferedWriter bw= new BufferedWriter(new FileWriter(f));
    	try{
    		for(File file: List)
    		{
    			String path= file.getAbsolutePath();
    			bw.write(path);
    			bw.newLine();
    			bw.flush();
    			
    		}
    	}catch(Exception e){
    		throw new RuntimeException("失败！");
    	}
    	finally{
    		try{
    			if(bw!=null)
    				bw.close();
    		}catch(Exception ex){
    			throw new RuntimeException("关闭失败！");
    		}
    	}
    	
    }
}

Propreties与流关联的集合类HashTable的子类

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
                    //setAndget();
		//method_1();
		loadDemo();
	}
	//load方法进行文件的集合加载。
	public static void loadDemo() throws IOException
	{
		FileInputStream fis= new FileInputStream("info.txt");
		Properties prop= new Properties();
		prop.load(fis);
		prop.list(System.out);
		prop.setProperty("wangwu","25");
		FileOutputStream fos= new FileOutputStream("info.txt");
		prop.store(fos, "haha");
	}
	//将info.txt中的键值数据存到集合中进行操作。
	/*步骤:
	 1.用一个流和info.txt文件关联。
	 2.读取一行数据，将该数据用"="进行切割。
	 3.等号左边为建，右边卫值。存入Porperties集合中即可.
	 */
	public static void method_1() throws IOException
	{
	BufferedReader br= new BufferedReader(new FileReader("info.txt"));
	String line=null;
	Properties prop= new Properties();
	while((line=br.readLine())!=null)
	{
		String[] s=line.split("=");
		prop.setProperty(s[0], s[1]);
	}
	System.out.println(prop);
	}
	//设置和获取元素
	public static void setAndget()
	{
		Properties prop = new Properties();
		prop.setProperty("zhangsan", "34");
		prop.setProperty("lisi", "22");
		System.out.println(prop);
		String value =prop.getProperty("zhangsan");
		System.out.println(value);
		Set<String>  names = prop.stringPropertyNames();
		for(String name:names)
		{
			System.out.println(prop.getProperty(name));
		}
	}
}

Properties实现程序的使用次数限制

/*用于记录应用程序的次数。
  如果使用次数已到，那么给出注册信息。
  
    思路:
    通过Properties属性文件将使用次数的属性存在此文件中，每次使用一次将计数
    属性修改并重新存到属性文件中，此操作就要借用Properties对象进行操作。
 属性文件用于键值对的存储方式。
 这样便于对数据操作。
 
 键值对是map集合
 数据是以文件的形式存储，使用io数据。
 */
import java.io.*;
import java.util.*;
public class PropertiesCount {

	/**
	 * @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,"haha");
	}
      
}

PrintStream与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(System.out);
              String line = null;
              while((line=bufr.readLine())!=null)
              {
            	  out.println(line.toUpperCase());
            	  out.flush();
              }
              out.close();
              bufr.close();<pre name="code" class="java">

}}

DataInputStream和DataOutputStream 基本数据操作流

import java.io.*;
/*
 DataStream类主要用于操作基本数据类型的流的读取和写入
 */
public class DataInputStreamDemo {

	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
         //writeData();
		//readData();
		writeUTFDemo();
	}
	public static void writeUTFDemo() throws IOException
	{
		 DataOutputStream dos =
				   new DataOutputStream(new FileOutputStream("data.txt"));
		 dos.writeUTF("你好");
		 dos.close();
	}
	public static void readData() throws Exception
	{
		DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
		int num =dis.readInt();
		boolean b= dis.readBoolean();
		double d= dis.readDouble();
		System.out.println("num:"+num);
		System.out.println("b:"+b);
		System.out.println("d:"+d);
	}
   public static void writeData() throws IOException
   {
	   DataOutputStream dos =
			   new DataOutputStream(new FileOutputStream("data.txt"));
	   dos.writeInt(234);
	   dos.writeBoolean(true);
	   dos.writeDouble(444.456);
	   dos.close();
	   
   }
}

ObjectInputStream和ObjectOutputStream对象操作流

import java.io.*;
public class ObjectStreamDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
            writeObj();
	      readObj();
	}
	public static void readObj() throws IOException, IOException, ClassNotFoundException
	{
	  ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
	  Person p =(Person)ois.readObject();
	  System.out.println(p);
	  ois.close();
	  
	}
	public static void writeObj() throws IOException, IOException
	{
		ObjectOutputStream oos=
				new ObjectOutputStream(new FileOutputStream("obj.txt"));
		oos.writeObject(new Person("lisi",39,"china"));
		oos.close();
	}
   
}
     class Person implements Serializable
     {
    	 /**
		 * 自定义
		 */
		private static final long serialVersionUID = 1L;
		private String name;
    	transient int age;//关键字transient定义的成员也不能被序列化 在堆内存中也无法被序列化
    	static String country="cr" ;//静态成员不能被序列化，不再堆内存中
    	 
    	 Person(String name ,int age,String country){
    		 this.name=name;
    		 this.age=age;
    		 this.country=country;
    	 }
    	 public String toString(){
    		 return name+":"+age+country;
    	 }
     }

PipedInputStream 和PipedOutputStream 管道操作流

import java.io.*;
public class PipedStreamDemo {

	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
       PipedInputStream pis= new PipedInputStream();
       PipedOutputStream pos= new PipedOutputStream();
       pis.connect(pos);
       
       PipedRead read = new PipedRead(pis);
       PipedWrite write = new PipedWrite(pos);
       new Thread(read).start();
       new Thread(write).start();
       
	}

}

class PipedRead implements Runnable
{
   private PipedInputStream in;
   PipedRead(PipedInputStream i)
   {
  	 this.in=i;
   }
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try
		{   byte[] buf = new byte[1024];
			int len=in.read(buf);
			String s = new String(buf,0,len);
			System.out.println(s);
			in.close();
		}catch(Exception e)
		{
			throw new RuntimeException("读取失败");
		}
	}
}
   class PipedWrite implements Runnable{
	 private  PipedOutputStream pos;
	   PipedWrite(PipedOutputStream out){
		   this.pos= out;
	   }
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try
		{ 
			Thread.sleep(6000);
			pos.write("ge men lai le".getBytes());
			pos.close();
		}catch(Exception e)
		{
			throw new RuntimeException("写入流失败！");
		}
	}
	   
   }

RondomAccessFile 随机文件读写流

import java.io.*;
/*RandomAccessFile
  该类不是IO体系中的子类
  而是直接继承Object
  
  但是他是IO包中的成员，因为它具有读写数据的功能。
  内部封装了一个数组，而且通过指针对数据元素进行操作。
  可以通过getFilePointer 获取指针的位置。
  同时可以通过seek方法改变指针的位置。
  
  其实就是内部封装了字节输入流和输出流。
  
  通过其拥有的构造函数可以看出，该类只能操作文件。
  而且操作文件还有固定的模式。只读 r 读写rw
  
  如果是只读模式去操作文件，读取已有的文件入如果问价不存在就会报错。
  如果是读写，如果没有文件会创建一个文件在写入。
  
 */
public class RandomAccessFileDemo {

	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
             writeFile();
		    readFile();
	}
	public static void readFile() throws IOException
	{
	   RandomAccessFile raf = new RandomAccessFile("random.txt","r");
	 //seek方法的使用很频繁 将读取文件中的指针调整位置读取数据
	   raf.seek(8*3);//跳过开头的8个字节开始读取数据。
	   
	   byte[] buf = new byte[4];
	   raf.read(buf);
	   String name = new String(buf);
	   int  age= raf.readInt();
	   System.out.println("name:"+name);
	   System.out.println("age:"+age);
	   raf.close();
			   
	}
    public static void writeFile() throws IOException
    {
    	RandomAccessFile  raf = new RandomAccessFile("random.txt","rw");
    	raf.write("李四".getBytes());
    	//raf.write(97);//write 方法是写入最低八位的二进制形式。
    	raf.writeInt(97);//writeInt()方法是写入四个字节不会出现乱码。
    	raf.write("王五".getBytes());
    	raf.writeInt(99);
    	raf.seek(8*3);//跳过一个8字节写入数据
    	raf.write("周七".getBytes());
    	raf.writeInt(98);
    	raf.close();
    }
    
    
}