Java文件操作与File类详解-优快云博客

转换流：

通过上述示例，通过键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理

能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？

readLine方法是字符流BufferedReader类中的方法

而键盘录入的read方法字节流InputStream的方法

那么能不能将字节流转成字符流在使用字符流缓冲区的readLine方法呢？

读取流：

InputStreamReader是字节流通向字符流的桥梁

class TransStreamDemo{  
    public static void main(String []args) throws IOException  
   {   
           //获取键盘录入对象  
      // InputStream in=System.in;  
         
       //将字节流对象装换成字符流对象，InputStreamReader  
      //InputStreamReader isr=new  InputStreamReader(in);  
         
       //为了提高效率，讲将字符流进行缓冲区技术的高效操作  
         
      // BufferedReader bufr=new BufferedReader(isr);  
        
       BufferedReader bufr=new BufferedReader(new InputStreamReader(new FileInputStream("CopyMp3.java")));  
         
         
       BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));  
         
         
       String line=null;  
         
       while((line=bufr.readLine())!=null)  
       {  
         if("over".equals(line))  
         break;  
         System.out.println(line.toUpperCase());  
      
           }  
       bufr.close();  
   }  
}

写入转换流

OutputStreamWriter是字符流通向字节流的桥梁

class TransStreamDemo{  
    public static void main(String []args) throws IOException  
   {   
        
      //*************毕老师说这句换一定要记住，键盘录入，非常的重要********************  
      //键盘录入最常见写法  
       BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));  
         
      
         
       BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));  
         
         
       String line=null;  
         
       while((line=bufr.readLine())!=null)  
       {  
         if("over".equals(line))  
         break;  
         bufw.write(line.toUpperCase());  
             bufw.newLine();  
          bufw.flush();  
           
          
       }  
         
       bufr.close();  
   }  
}

流操作规律

流操作的基本规律：

最痛苦的就是流对象有很多，不知道该用哪一个
通过三个来明确
1.明确源和目的
源：输入流 InputStream Reader
目的：输出流 OutputStream Writer

2.明确操作的数据是否是纯文本
是：字符流
不是：字节流

3.当体系明确后，在明确要使用哪个具体的对象
通过设备来进行区分;
源设备：内存（ArrayStream），硬盘（FileStream），键盘（System.in）
目的设备：内存（ArrayStream），硬盘（FileStream），控制台（System.out）。

转换流什么时候使用

字符和字节之间的桥梁，通常，涉及到字符编码装换时需要用到转换流

存储时需要加入指定的编码表utf-8，只有转换流才能指定

OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

class TransStreamDemo2{  
    public static void main(String []args) throws IOException  
   {   
          //获取键盘录入对象  
      // InputStream in=System.in;  
      
      //键盘录入最常见写法  
       BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));  
         
       BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d2.txt"),"UTF-8"));  
         
         
       String line=null;  
         
       while((line=bufr.readLine())!=null)  
       {  
         if("over".equals(line))  
         break;  
        
         bufw.write(line.toUpperCase());  
         bufw.newLine();  
         bufw.flush();  
           }  
       bufr.close();  
   }  
}

改变标准输入输出设备

System.setIn(new FileInputStream("PersonDemo.java"));
System.setOut(new PrintStream("zz.txt"));

创建日志：

/* 
说明：Log4j的jar包可以完成日志信息建立 
*/  
import java.io.*;  
import java.util.*;  
//格式化要用的包  
import java.text.*;  
  
class ExceptionInfo  
{  
  public static void main(String[] args) throws IOException  
  {  
    try{  
        
      int[] arr=new int [2];  
      System.out.println(arr[3]);  
        
    }catch(Exception e)  
    {  
    try{  
       //打印日期  
       Date d=new Date();  //默认当前值
       //SimpleDateFormat将时间格式化  
       SimpleDateFormat sdf=new  SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//h是12小时制，H是24小时制  
       String s=sdf.format(d);  
         
       PrintStream ps=new PrintStream("exception.log");  
       //ps是字节流，要将字符串变成字节数组写出去  
       //ps.write(d.toString().getBytes); //不需是字节 
       //ps.println(d.toString());  可以使字符串
       ps.println(s);  
        //改变标准输出  
       System.setOut(ps);  
       //e.printStackTrace(new PrintStream("a.txt"));  
    }catch(IOException ex)  
    {  
      throw new RuntimeException("日志文件创建失败");  
    }  
      
       e.printStackTrace(System.out); //默认是System.out 
    }  
      
    
  }  
    
}

打印系统信息：

import java.io.*;  
import java.util.*;  
class SystemInfo  
{  
  public static void main(String[] args) throws IOException  
  {  
      //打印系统信息  
     //源就是集合中的数据也就是内存  
     Properties prop=System.getProperties();  
       
     //System.out.println(prop);  //不是按键值对形式打印
     //将系统信息打印在控制台上  
      //prop.list(System.out);  
      prop.list(new PrintStream("sysinfo.txt"));  
  }  
}

File类

File类概述：

File类：文件和目录路径的抽象表现形式

特点：

用来将文件或文件夹封装成对象
方便于对文件与文件夹的属性信息进行操作
File对象可以作为多数传递给流的构造函数

import java.io.*;  
  
class FileDemo  
{  
   public static void main(String[] args) throws IOException  
   {  
    //  consMethod();  
    method_5();  
   }  
   //创建File对象  
   public static void consMethod()    
   {  
     //将a.txt封装成file对象。可以将已有的和未出现的文件或则文件夹封装成对象。  
      File f1=new File("a.txt");  
        
      //abc指的是父目录，b.txt指的是目录中的文件名  
       File f2=new File("C:\\abc","b.txt");  
        
       //将目录封装成对象  
       File d=new File("C:\\abc");  
       File f3=new File(d,"c.txt");  
         
       sop("f1:"+f1);  
       sop("f2:"+f2);  
       sop("f3:"+f3);  
         
       //separator是与系统有关的默认的名称分割符，这样就可以实现跨平台  
       File f4=new File("c:"+File.separator+"abc"+File.separator+"ggg"+File.separator+"a.txt");  
   }  
    
   public static void sop(Object obj)  
   {  
      System.out.println(obj);  
   }

File类的常见方法

1.创建
boolean createNewFile();在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
和输出流不一样，输出流对象一创建就创建文件。而且文件已经存在，则覆盖。
boolean mkdir()：创建文件夹，只能创建一级目录
boolean mkdirs():创建多级文件夹，可以创建多级目录
2.删除
boolean delete();删除失败，返回false；
void deleteOnExit();在程序退出时删除指定文件。
3.判断。
boolean exists():文件是否存在
  booleanisFile():是否是文件
  boolean isDirectory():是否是文件目录
  boolean isHidden():文件是否隐藏
  boolean isAbsolute():是否是绝对路径
4.获取信息。
  String getName(); 获取文件名
  String getPath();  获取文件的相对路径（即创建的对象传入的参数是什么就获取到什么）
String getParent();获取父目录，该方法返回绝对路径中的父目录，获取相对路径，返回null，如果相对路径中有上一级目录，则返回的即为该目录
String getAbsolutePath();获取绝对路径
long lastModified();最后一次修改的时候
long length():文件的大小
  static File[] listRoots() ;获取文件的系统根，即各个盘符

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

boolean renameTo(File dest);对文件重命名为dest

  //方法一  
   public static void method_1() throws IOException  
   {  
      File f=new File("file.txt");  
      f.deleteOnExit();  
//    sop("create:"+f.createNewFile());  
  
      sop("delete:"+f.delete());  
   }  
    //方法二  
    public static void method_2() throws IOException  
    {  
         File f=new File("file.txt");  
           
         //文件是否能被执行  
        // sop("execute:"+f.canExecute());  
        //判断文件是否存在  
        //sop("exists:"+f.exists());  
        //创建文件夹  
        //mkdir()方法用于创建目录,只能创建一级目录，不能创建多级目录  
        //File dir=new File("abc\\aaa");  
        //mkdir()方法用于创建一级目录  
        //sop("mkdir:"+dir.mkdir());  
          
        //mkdirs()方法用于创建多级目录  
        File dir=new File("abc\\aaa\\ccc\\nnggg");  
        //mkdir()方法用于创建多级目录  
        sop("mkdir:"+dir.mkdirs());  
    }  
    //方法三  
    public static void method_3() throws IOException  
    {  
       File f=new File ("file.txt");  
       //记住在判断文件对象是否是文件对象或者目录时，必须要先判断该文件对象封装的内容是否存在  
       //通过exists判断。  
         
       //f.createNewFile();  
         
       f.mkdir();  
         
       //isDirectory()判断是否是目录，isFile判断是否是文件  
       sop("dir:"+f.isDirectory());  
       sop("dir:"+f.isFile());  
         
       //判断文件是否是绝对路径  
       sop(f.isAbsolute());  
    }  
    //方法四  
    public static void method_4() throws IOException  
    {  
        File f=new File("file.txt");  
          
        sop("path:"+f.getPath());  
          
        sop("abspath:"+f.getAbsolutePath());   
        //该方法返回的是绝对路径中的父目录  
        //如果获取的是相对路径，返回null空  
        //如果相对路径中有上一层目录，那么该目录就是返回结果  
        sop("parent:"+f.getParent());   
          
    }  
      
    //方法五  
    public static void method_5() throws IOException  
    {  
        //这样相当于移动（剪贴）和重命名  
        File f1=new File("C:/Test.java");  
          
        File f2=new File("d:/Sword.java");  
          
        //renameTo()方法用于更换文件的名字  
        sop(f1.renameTo(f2));  
          
    }   
      
}

5· 列出及过滤文件：

String[] list(); 列出当前目录所有文件，包含隐藏文件，调用list方法的file对象，必须是封装了一个目录，且该目录必须存在。
String[] list(FilenameFilter filter); FilenameFilter：文件名过滤器，是一个接口，其中包含一个方法， accept(File dir,String name)，返回的是boolean型，对不符合条件的文件过滤掉。
File[] listFiles(); 获取当前文件夹下的文件和文件夹，返回类型为File数组
ListFiles(FilenameFilter filter);同list，是对获取的当前文件夹下的文件和文件夹的文件名过滤器。

/* 
list用于打印指定目录下文件或则文件夹的名称的 
 
listRoots()列出机器中有效的盘符 
*/  
  
import java.io.*;  
  
class FileDemo2  
{  
   public static void main(String[] args) throws IOException  
   {   
       File dir=new File("C:\\");  
         
       File[] files=dir.listFiles();  
         
       for(File f: files)  
       {  
          System.out.println(f.getName()+"::"+f.length());  
       }  
         
         
   }  
    public static void  listDemo_2()  
   {  
         // listRootsDemo();  
       
     //listDemo();  
     File dir=new File("C:\\Users\\Administrator\\Desktop\\冲刺黑马之路\\代码");  
       
     //FilenameFilter()为匿名内部类  
      String[] arr=dir.list(new  FilenameFilter()  
      {  
         public boolean accept(File dir,String name)  
         {  
            // System.out.println("dir:"+dir+"...name"+name);  
             /* 
             if(name.endsWith(".java")) 
             { 
                 return true; 
             } 
             */  
             return name.endsWith(".java");  
         }  
      });  
       
      System.out.println("len:"+arr.length);  
       
      for(String name:arr)  
      {   
         System.out.println(name);  
      }  
   }  
     
   public static void  listDemo()  
   {  
      File f=new File("C:\\");  
      //list()用于打印指定目录下文件或则文件夹的名称的  
      //调用list方法的file对象必须是封装了一个目录，该目录还必须存在。  
      String[] names=f.list();  
      for(String name:names)  
      {   
         System.out.println(name);  
      }  
   }  
     
   public static void listRootsDemo()  
   {   
      //列出机器中有效的盘符  
       File[] files=File.listRoots();  
         
       //高级for循环，也就是for增强  
       for(File f:files)  
      {  
        System.out.println(f);  
      }      
   }  
}

递归：

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

分析:因为目录中还有目录，只有使用同一个列出目录功能的函数完成即可，在列出过程中出现的还是目录的话，还可以再调用本功能，

即函数自身调用自身，这种表现形式或手法，称为递归。

注意：

1、限定条件，是作为结束循环用的，否则是死循环

2、注意递归的次数，尽量避免内存溢出。因为每次调用自身的时候都会先执行下一次调用自己的方法，所以会不断在栈内存中开辟新空间，次数过多，会导致内存溢出。

带层次--列出目录下的所有内容：

import java.io.*;  
  
class FileDemo3   
{  
    public static void main(String[] args)   
    {  
        File dir = new File("d:\\testdir");  
        //showDir(dir,0);  
  
        //toBin(6);  
        //int n = getSum(8000);  
        //System.out.println("n="+n);  
  
        System.out.println(dir.delete());  
    }  
    //对目录进行分级  
    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);  
        }  
    }  
        public static void method()  
    {  
        method();  
    }  
}

删除一个带内容的目录：

删除原理：在window中，删除目录是从里往外删除的，同样使用递归

import java.io.*;  
  
class  RemoveDir  
{  
    public static void main(String[] args)   
    {  
          
        File dir = new File("d:\\testdir");  
        removeDir(dir);  
    }  
  
    public static void removeDir(File dir)  
    {  
        File[] files = dir.listFiles();  
          
        for(int x=0; x<files.length; x++)  
        {  
             //if(!files[x].isHidden()&&files[x].isDirectory())判断文件是否隐藏  
          
            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());  
    }  
  
}

练习:

将一个指定目录下的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("d:\\java1223");  
  
        List<File> list = new ArrayList<File>();  
  
        fileToList(dir,list);  
  
       // System.out.println(list.size());  
    
       //dir是父目录，"javalist.txt"是文件名  
        File file = new File(dir,"javalist.txt");  
          
        //file.toString()将路径强转成字符串  
        writeToFile(list,file.toString());  
  
          
  
  
    }  
    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,String javaListFile)throws IOException  
    {  
        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)  
        {  
            throw e;  
        }  
        finally  
        {  
            try  
            {  
                if(bufw!=null)  
                    bufw.close();  
            }  
            catch (IOException e)  
            {  
                throw e;  
            }  
        }  
    }  
}

----------- java培训、java技术博客、期待与您交流！ ------------