码迷,mamicode.com
首页 > 其他好文 > 详细

黑马程序员——24,File类,Properties类,

时间:2015-08-11 14:14:07      阅读:119      评论:0      收藏:0      [点我收藏+]

标签:黑马程序员

------<ahref="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------

          

         黑马程序员——24,File类,Properties类,

 

/*

File类的应用:

针对文件或者文件夹封装成对象进行操作.

 

*/

 
import java.io.*;
class Ioliou16
{
         publicstatic void main(String[] args)
         {
    
                                                                             
              File   f1=new File("f:\\亚马逊\\亚马逊1号.txt");
                   /*
                   将亚马逊1号.txt封装成了对象,
                   这句话既可以对已经存在的文件封装成对象,
                   又可以对还没有存在的文件封装成对象。
        */
                    File f2=new  File("f:\\亚马逊","亚马逊1号.txt");
                    /*
                             这句话效果和前一句一样,
                             只不过,把指定位置和文件分开成两个参数进行传递,更加灵活。
                    */
                    File f3=new  File("f:\\亚马逊");
                    File f4=new  File(f3,"亚马逊1号.txt");
                    soc("f1="+f1);//打印的是f1=f:\亚马逊\亚马逊1号.txt
                    soc("f2="+f2);//打印的是f2=f:\亚马逊\亚马逊1号.txt
                    soc("f3="+f3);//打印的是f3=f:\亚马逊
                    soc("f4="+f4);//打印的是f4=f:\亚马逊\亚马逊1号.txt
                    File f5=new  File("f:\\亚马逊"+File.separator+"亚马逊1号.txt");
                    //File.separator表示仅仅是通用的分隔符
                    soc("f5="+f5);//打印的是f5=f:\亚马逊\亚马逊1号.txt
         }
 
         public  static void  soc(Object  obj)
         {
             System.out.println(obj);            
         }
}

——————分割线——————

 

/*

File类的方法调用

*/

import java.io.*;
class  Ioliou17
{
         public  static void  main(String[] args) throwsIOException
         {
 
                    //createNewFileDemo();
                    //deleteDemo();
                   //mkdirsDemo();
                   //isAbsoluteDemo();
                   //renameTo();
                   lastModifiedDemo();
         }
         public  static void  createNewFileDemo()throwsIOException
         {
                        File  f=new File("f:\\mianbao.txt");
 
                   //以下是在指定路径上创建文件
                    boolean  b  =f.createNewFile();
                    soc(b);
                    /*
                    createNewFile返回的是boolean型,
                    如果在指定路径上创建文件mianbao.txt成功就返回true,否则false
                    注意:如果指定路径下有同名文件就不会创建了返回的也是false
                    还有涉及到IO流的一般都会抛出IO异常,不要忘记这一点。
        如果是这样写的话:
                           File f=new  File("f:\\面包\\mianbao.txt");
                           boolean  b=f.createNewFile();
                    这样是编译显示IO异常,找不到指定路径。
                    (本人电脑f盘此时并没有面包这个文件夹)
                    也就是说路径一定要是真实存在的。
                    */                  
         }
   public  static  void deleteDemo()throws IOException
         {
              File f=new File("f:\\mianbao.txt");
                    f.createNewFile();//创建文件
                    boolean b= f.delete();
                    soc(b);
                    /*
                    delete方法删除文件,
                    该方法返回的也是boolean型的, 删除成功则是返回true,否则false
                    File类中还有一个方法deleteOnExit
                    如果用在此例中f.deleteOnExit();表示java程序运行结束前删除文件
        */
 
         }
         public  static void  existsDemo()throws  IOException
         {
              File f=new  File("e:\\JAVAwenjian\\Ioliou17\\Ioliou.17"); 
                    boolean   b=f.exists();//判断文件是否在指定路径存在
                    soc(b);
         }
         public  static void  mkdirDemo() throws  IOException
         {
              File f=new File("shuei\\klkl");
                    boolean b=    f.mkdir();   
                    /*
                    mkdir方法建立一级目录,
                    如果建立指定目录成功返回true否则返回false
                    下面有一种常见情况:
                    一,
          File  f=new  File("f://单");
                      boolean b=f.mkdir();//返也恶意回true
                      也可以指定哪一个盘存放
                    二,
                      File f=new File("shuei//klkl");
                      boolean b=f.mkdir();//返也恶意回false
                      只可以指定建立一级目录
                    */
                    soc(b);
         }
         public  static void  mkdirsDemo()throws  IOException
         {
               File f=new  File("菠菜\\好吃的菠菜\\更好吃的菠菜");
                     boolean b=    f.mkdirs();
                     //mkdirs方法可以建立多级目录
                     soc(b);
                     soc("f.exists()="+f.exists());
                     //exists方法也可以用来判断指定路径下是否存在文件夹
 
                     File f2=new  File("水果.txt");
                     boolean  b2=f2.mkdirs();//这里建立的是名为“水果.txt”的文件夹!
                     soc(b2);
                     //所以mkdir和mkdirs方法都是建立的是文件夹!
         }
         public  static void  pd()
         {
               File f=new  File("f:\\狂热\\热.txt");      
                       boolean b1=     f.isFile();//判断封装的对象是否是文件
                       boolean b2   =   f.isDirectory();//判断封装的对象是否是文件夹(路径)
                     /*
                     此例的情况是在指定路径下没有名为“热”的txt文件,
                     所以,b1和b2都是false
          */
                      soc("b1="+b1+"   b2="+b2);
 
          
         }
         public  static void  isAbsoluteDemo()throws  IOException
         {
                File f=new  File("玄幻1\\玄幻小说.txt"); //
                      boolean  b=f.isAbsolute();
                      /*
                      isAbsolute方法判断是否是绝对路径,
                      就算是文件不存在只要是绝对路径就返回true
                      所谓的绝对路径就是从哪一个盘开始写起的才算是绝对路径
                      */
                      soc("b="+b);                 
                     soc("f.getPath()="+f.getPath());//f.getPath()=玄幻1\玄幻小说.txt
                     soc("f.getParent()="+f.getParent());//f.getParent()=玄幻1
                     // getParent方法返回的是绝对路径的父目录否则返回null
 
                      soc("f.getAbsolute()="+f.getAbsolutePath());
                      //打印的是f.getAbsolute()=E:\JAVAwenjian\玄幻1\玄幻小说.txt
                      //getAbsolutePath方法返回的是绝对路径
                     soc("f.getName()="+f.getName());//f.getName()=玄幻小说.txt
 
                                
         }
         public  static void  lastModifiedDemo()
         {
                   File  f=new File("e:\\JAVAwenjian\\Ioliou17.java");
                 long l=   f.lastModified();
                            //lastModified方法返回的是文件最后一次被修改的时间
          soc("f.lastModified()="+f.lastModified());         
         }
   public  static  void renameTo()
         {
               File f=new  File("f:\\无标题23copy.png"); 
                     File f2=new  File("d:\\无标题23copy.png");
                     f.renameTo(f2);
                     //效果是:f盘中的无标题23copy.png被剪切到d盘上
 
               File f3=new File("f:\\yuyuyu.java"); 
                     File f4=new File("d:\\shue.java");
                     f3.renameTo(f4);
         //效果是:f盘中的yuyuyu.java剪切到d盘上并更名为shue.java
 
         }
         public  static void  soc(Object  obj)
         {
              System.out.println(obj);       
         }
}

——————分割线——————

 

 

/*

File类中方法应用

文件列表

*/

import java.io.*;
class  Ioliou18
{
         public  static void  main(String[] args)
         {
                   listDemo();
       listRootsDemo();
         }
         public  static void  listDemo()
    {
                   soc("以下是listDemo--------");
       File  f=new  File("f:\\yuyuyu.txt");
                   String[]   s= f.list();
                   /*
                   list方法返回的是指定路径下(不能是指定文件)所有的文件名和文件夹名,
                   如果指定的不是路径而是文件,那么会运行空指针异常
        */
                    for(String s2: s)
                   {
                    soc(s2);
                   }
         }
         public  static void  listRootsDemo()
         {
                   soc("以下是listRootsDemo-------");
              File[] f=File.listRoots(); 
                    for(File f2:f)
                    {
                          soc(f2);  
                    }
                    /*
                    打印的是:
以下是listRootsDemo-------
C:D:E:F:G:                    */
 
         }
         public  static void  soc(Object  obj)
         {
           System.out.println(obj);                        
         }
}

————————分割线——————

 

 

/*
File对象的功能:
文件列表
如果只需要罗列出某个指定路径下的某种类型的文件名,
就要用到FilenameFilter,其作用相当于过滤器,
里面有一个方法boolean  accept(File dir,String  name)
*/
import java.io.*;
class  Ioliou19
{
         public  static void  main(String[]args)throws  IOException
         {
         listDemo(); 
 
         }
         public  static void  listFilesDemo()
         {
                   soc("以下是listFilesDemo----");
              File  f=new  File("f:\\");
                    File[]  fs=     f.listFiles();
                    for(File  zz:  fs)
                    {
                       soc(zz.getName()+"---"+zz.length());
                             //如果是文件夹的话,打印出来的长度显示为0的
                    }
         }
         public  static void  listDemo()
         {
                   //只是打印出f盘中的所有的.txt文件
                   File  f=new File("f:\\");
                   String[]  s   =f.list( new    FilenameFilter(){
                      public boolean  accept(File  dir,String name)
                      {
                            return name.endsWith(".txt");
                      }
                   });
       for(String   s2:s)
                   {
                       soc(s2);   
                   }                      
         }
         public  static void  soc(Object  obj)
         {
              System.out.println(obj);       
         }
}

————————分割线——————

 

/*
File类的应用:
罗列出指定路径下所有文件。
这个就需要用到递归了,
使用递归的时候要注意限制条件以及递归次数。
*/
import java.io.*;
class Ioliou20
{
         public  static void  main(String[] args)
         {
                   File   f=new File("f:\\技术博客的图片\\");
       method(f)   ;   
 
         }
         public  static void  method(File   f)
         {
                   soc("这是---"+f);
             File[]   fs=f.listFiles();
                   for(int  x=0;x<fs.length;x++  )
                   {
                           
                            if(fs[x].isDirectory())
                method(fs[x]);
                            /*
                            因为目录中还有目录,
                            所以可以自身调用自身函数,这种编程手法称为递归
                            */
                            else
                        soc(fs[x]); //打印的是绝对路径          
                   }                    
         }
         public  static void  soc(Object  obj)
         {
             System.out.println(obj);
         }
}

————————分割线——————

/*
删除带内容的目录
*/
import java.io.*;
class  Ioliou21
{
         publicstatic void main(String[] args)
         {
                   File    f=new  File("f:\\今天练习\\");
       method(f);
                  
         }
         public  static  void  method(File    f)
         {
             File[]    fs=   f.listFiles(); 
                   for(int  x=0;x<fs.length;x++)
                   {
                        if(fs[x].isDirectory())    
                             {
                                      method(fs[x]);
                                 //soc(fs[x]+"--文件夹--"+fs[x].delete());
                                      
                             }
                             else
              soc(fs[x]+"---"+fs[x].delete());
                             
                   }
                   if(f.isDirectory())//这里加上这个判断把外层的文件夹删掉
                            soc(f+"--文件夹--"+f.delete());
                  
 
         }
         public  static  void   soc(Object  obj)
         {
             System.out.println(obj);             
         }
}

——————分割线——————

 

/*
建立java文件列表
*/
import java.io.*;
import java.util.*;
class  Ioliou22
{
         public  static void  main(String[] args)throws  IOException
         {
                   File  f=new File("f:\\java文件练习");
       List<String>  li=new  ArrayList<String>();
                   File   f2=new File("f:\\2015.8.10.txt");
       method(f, li) ;
                   method2(li,f2);        
         }
         public  static void  method(File  f,List<String>  li  )
         {
                    File[] fs     =f.listFiles();
                    for(int x=0;x<fs.length;x++)
                    {
                          if(fs[x].isDirectory())
                                        method(fs[x],li);
                               else
                                       if(fs[x].getName().endsWith(".java"))
                      li.add(fs[x].getAbsolutePath());                     
                    }
                            
         }
         public  static void method2(List<String>  li,File   f)throws  IOException
         {
          //FileWriter   fw=new   FileWriter(f.getAbsolutePath());
                FileWriter   fw=new  FileWriter(f);
                      //FileWriter构造函数也可以接受File类对象
                      BufferedWriter   bfw=new  BufferedWriter(fw);
                      for(String  s:li)
                      {
                           bfw.write(s);    
                                     bfw.newLine();
                                     bfw.flush();
                      }
                      bfw.close();
                     
         }
         public  static void  soc(Object  obj)
         {
              System.out.println(obj);              
         }
}

——————分割线——————

 

/*
IO流(Properties类的介绍)
 
同时具备Map集合特点,里面存放的都是字符串,没有泛型。
Properties集合是Hashtable集合的子类
Properties集合对象特点:可以用于键值对形式的配置文件,
从文件中把数据加载到容器里面的时候需要固定格式:键=值
 
f:\\8.10号练习.txt的内容:
bvuivb=8
heauobgvjeb=02   qcdtycwqd=45
buiverhbgvi=09
oirjgbitr=20
hbn=00
iohoii=74
oirjgbitr=55
 
*/
import java.io.*;
import java.util.*;
class  Ioliou23
{
         public  static void  main(String[] args)throws  IOException
         {
 
        method3();
         }
 
         public   static void  method()
         {
                   Properties   pro=new Properties();
                   pro.setProperty("pupi","01");//加入元素
                   pro.setProperty("huj","03");
                   pro.setProperty("hjsbf","12");
                   pro.setProperty("hjsbf","100");//注意有重复元素
                   pro.setProperty("add","10");
                   String   s=  pro.getProperty("hjsbf");//获取键所对应的值
                   soc("s---"+s);
                    Set   jian=   pro.stringPropertyNames();//把所有键放在Set集合里面
                    
                    /*
                    由于Properties具有Map集合的特点,所以,某对键值对重复了,
                    那么新来的重复元素会覆盖前一个。
                 */
         }       
        
         public   static void  method2()throws  IOException
         {
             
                     Properties  pro=new  Properties();
                     FileInputStream   fis=new FileInputStream("f:\\8.10号练习.txt");
                     pro.load(fis); //将流的数据加载进集合
                     /*
                        f:\\8.10号练习.txt里面的数据要是以等号为分割符分割开来的
                     */
                    pro.setProperty("kkkkkk","kk");
                     soc(pro);/*
                     程序执行到这一行时,打开“8.10号练习.txt”文件来看,
                     并没有上一行添加进的键值对"kkkkkk","kk"
          */ 
                     fis.close();
                      /*打印结果:
                      {bvuivb=8, oirjgbitr=55, kkkkkk=kk,heauobgvjeb=02   qcdtycwqd=45,buiverhbgvi=09, iohoii=74, hbn=00}
 
                      */
         }
         public   static void  method3()throws  IOException
         {
                Properties   pro=new Properties();
                      FileInputStream   fis=new FileInputStream("f:\\8.10号练习.txt");
                      pro.load(fis);//加载文件数据到容器中
          pro.setProperty("kkkkkk","kk");//添加元素到容器中
                      FileOutputStream   fos=new FileOutputStream("f:\\8.10号练习.txt");
                      pro.store(fos,"jk");//把pro容器里面的键值对保存在文件中相当于更新,其中jk仅仅为注释
         
                      pro.list(System.out);
                      /*
                      这句话把容器pro的内容打印出来,打印的格式:
          -- listing properties --
          bvuivb=8
          oirjgbitr=55
          kkkkkk=kk
          heauobgvjeb=02   qcdtycwqd=45
          buiverhbgvi=09
          hbn=00
          iohoii=74
 
          */
 
          fis.close();
                      fos.close();
                     
         }
         public   static void  soc(Object  obj)
         {
             System.out.println(obj);        
         }
}

——————分割线————————

 

 

/*
Properties的练习:(配置文件的建立和使用)
记录程序运行次数,次数已到就给出注册提示。
 
Map加IO技术就是Properties
配置文件可以实现应用程序数据的共享。
 
*/
import java.io.*;
import java.util.*;
class  Ioliou24
{
         public  static void main(String[] args) throws IOException
         {
                   //File   f=new File("f:\\jilu.properties");//一般写后缀名.properties配置文件
       File   f=new  File("f:\\jilu.ini");
                   if(!f.exists())
                            f.createNewFile();
 
                   FileReader   fis=new  FileReader(f);
                   //建立读取流对象,这里可以用字符流读取流又可以用字节流读取流
                   Properties   pro=new Properties();//建立Properties对象
                   pro.load(fis);//加载文件数据到容器中
                   String   s= pro.getProperty("cishu");//获取值
                   int  i=0;
                   if(s==null)
                   {
              pro.setProperty("cishu","1");       
                             
                  }
                   else
                   {
                       i= Integer.parseInt(s);//把字符串转变成数字
                            i++;
                            if(i>=6)
                                {
                                    soc("次数超过了");      
                                }
                       pro.setProperty("cishu",i+"");
                   }
        
                   FileWriter   fos=new FileWriter(f);
                   //建立写入流对象,这里可以用字符流写入流又可以用字节流写入流
                    pro.store(fos,"haha");//把数据保存在文件中
        fis.close();
                    fos.close();
 
         }
         public  static void  soc(Object  obj)
         {
             System.out.println(obj) ;       
         }
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

黑马程序员——24,File类,Properties类,

标签:黑马程序员

原文地址:http://blog.csdn.net/dangaodeaiyi/article/details/47418519

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!