JAVASE_20_#java高级IO_File对象和IO包中的其他类

1，File类

            ------File的实例：--文件或者文件夹

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

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

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

1.1，创建File对象---三种构造方法

1 2 3 4 5 6 7

File f1 =  new  File( "a.txt" );   File f2 =  new  File( "c:\\abc" , "b.txt" ); File f2 =  new  File( "C:" , "b.txt" ); //注意路径写法"c:"或者"c:\\",但是不可"c" File d =  new  File( "c:\\abc" ); File f3 =  new  File(d, "c.txt" );

1.2，目录分隔符

---File类中static String separator

---系统有关的默认名称分隔符,可以跨平台

1 2	File f4 =  new  File( "c:\\abc\\zzz\\a.txt" ); File f4 =  new  File( "c:" +File.separator+ "abc\\zzz\\a.txt" ); //

2，File对象常见方法

1，创建。

  boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。

   和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。

static File  createTempFile(String prefix, String suffix)//创建临时文件

 boolean  mkdir():创建文件夹。

 boolean  mkdirs():创建多级文件夹。

2，删除。 

 boolean  delete()：删除失败返回false。如果文件正在被使用，则删除不了返回false。

如何想在程序时删除文件，却抛出异常，则无法删除。 delete删除目录时，必须目录为空

 void  deleteOnExit();在程序JVM退出时删除指定文件。

3，判断。

Boolean   canExecute()；//

 boolean exists() :文件或者文件夹是否存在.

 isFile();//记住在判断文件对象是否是文件或目录时，必须要先判断该文件对象封装的内容是否存在

  isDirectory();//是否是目录

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

 isAbsolute();//绝对路径，即使文件不存在也可以判断，只看是否带盘符

4，获取信息。

  getName():

 getPath()://获取的时--封装的路径--无论此路径是相对还是绝对路径，和文件存在无关

 getAbsolutePath();//真是的绝对路径，和文件存在无关

 getParent()://该方法返回是绝对路径中的父目录，如果获取的是时相对的，返回的是null

//如果相对路径中有上一层目录那么该目录就会返回结果

 long  lastModified()；最后一次修改的时间

  long  length()；

renameTo(); //有点类似于剪切

1 2 3

File f1 =  new  File( "c:\\Test.java" ); File f2 =  new  File( "d:\\hahah.java" ); sop( "rename:" +f2.renameTo(f1));

3，文件列表

static File[ ]  listRoots();//列出系统根目录

1 2 3 4

File[] files = File.listRoots(); for (File f : files){      System.out.println(f); }

String[ ] list( );返回此目录下的文件盒目录名（包括隐藏的）

-----------调用list方法的file对象必须是封装了一个目录。该目录还必须存在 

-----------如果是一个文件，则下面的高级for抛出NullPointerException

1 2 3 4 5

File f =  new  File( "c:\\abc.txt" ); String[] names = f.list(); // for (String name : names){      System.out.println(name); }

String[ ]  list(FilenameFilter filter);

1 2 3 4 5 6 7 8 9

File f =  new  File( "E:\\workspace" );     String[] names = f.list( new  FilenameFilter(){ //此接口就一个方法，实现接口用匿名类      public  boolean  accept(File dir,String name){          return  dir.exists()&&name.endsWith( ".java" );      } });  for (String name: names){      System.out.println(name); }

File[ ] listFiles( );//开发更常用这2个，因为返回的是对象，调用getName（）等等可以操作！

File[ ] listFiles(FIleFilter filter );

1 2 3 4 5

File dir =  new  File( "c:\\" ); File[] files = dir.listFiles(); for (File f : files){      System.out.println(f.getName()+ "::" +f.length()); }

4，列出目录下所有内容-----递归

也就是函数自身调用自身。 这种表现形式，或者编程手法，称为递归。 

递归要注意： 

1，限定条件。否则无限循环

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

-----递归只有到最后满足限制条件，才会从最后一次调用往上逐渐返回。

1 2 3 4 5 6 7 8 9

public  static  void  toBin( int  num){      if (num> 0 ){          toBin(num/ 2 ); //递归          System.out.println(num% 2 );      } } public  static  void  method(){ //无限制条件是死循环      method(); }

应用：1.列出目录下所有内容

2.删除带内容的目录-----删除原理： 在window中，删除目录从里面往外删除的。

 既然是从里往外删除。就需要用到递归。

3.创建java文件列表清单

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

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

思路： 

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

2，获取递归过程所以的java文件的路径。 

3，将这些路径存储到集合中。 

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

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());          File file =  new  File(dir, "javalist.txt" );          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;}          }      } }

---

---

5，类 Properties简述

-----------Properties是hashtable的子类。 
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。 
是集合中和IO技术相结合的集合容器。 
该对象的特点：可以 用于键值对形式的配置文件。 
那么在加载数据时，需要数据有固定格式：键=值。 

6，Properties存取配置文件

<1>，setProperty(String key, String value);

<2>，getProperty(String key);

1 2 3 4

Properties prop =  new  Properties(); prop.setProperty( "zhangsan" , "30" ); prop.setProperty( "lisi" , "39" ); String value = prop.getProperty( "lisi" );

<3>,Properties存取配置文件

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

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

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

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

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

1 2 3 4 5 6 7 8 9 10 11

public  static  void  method_1() throws  IOException{      BufferedReader bufr =  new  BufferedReader( new  FileReader( "info.txt" ));      String line =  null ;      Properties prop =  new  Properties();      while ((line=bufr.readLine())!= null ){          String[] arr = line.split( "=" );          ///System.out.println(arr[0]+"...."+arr[1]);          prop.setProperty(arr[ 0 ],arr[ 1 ]);      }      bufr.close(); }

<4>.

load(InputStream inStream) ；

// 从输入流中读取属性列表(键值对).上述代码为其原理

void store(OutputStream out, String comments) ；

//将流中数据存储到配置文件

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public  static  void  loadDemo() throws  IOException{      Properties prop =  new  Properties();      FileInputStream fis =  new  FileInputStream( "info.txt" );      //将流中的数据加载进集合。      prop.load(fis);      prop.setProperty( "wangwu" , "39" ); //改变的是内存的结果，      //将改变结果写入文件      FileOutputStream fos =  new  FileOutputStream( "info.txt" );      prop.store(fos, "haha" ); //注释“#”不会被Property类所加载 //  System.out.println(prop);      prop.list(System.out);      fos.close();      fis.close(); }

7，Properties练习

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

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

很容易想到的是:计数器。

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

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

下一次在启动该程序，又重新开始从0计数。

这样不是我们想要的。

程序即使结束，该计数器的值也存在。

下次程序启动在会先加载该计数器的值并加1后在重新存储起来。

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

该配置文件使用 键值对的形式。

这样便于阅读数据，并操作数据。

键值对数据是map集合。

数据是以文件形式存储，使用io技术。

那么map+io -->properties.

配置文件可以实现应用程序数据的共享。

通常情况下java的配置文件都是"config.properties"这种文件形式。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

import  java.io.*; import  java.util.*; class   RunCount{      public  static  void  main(String[] args)  throws  IOException{          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" ); //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, "" );          fos.close();          fis.close();      } }

注意事项：

1.在用IO流操作文件时，要先用File类把文件封装成对象。这样做的目的：流无法对文件进行判断

8.对于配置文件一点点小常识（了解即可day19-14末尾）

XML中的配置形式：

1 2 3 4 5 6 7 8 9 10

<persons>      <person id= "001" >          <name>zhagnsan</name>          <age> 30 </age>          <address>bj</address>      </person>      <person>          <name      </person> </persons>

读取工具为----dom4j     dom for java     four

---

---

9.IO包中的其他类

（一）打印流：PrintStream和PrintWriter

该流提供了打印方法，可以将各种数据类型的数据都原样打印。

1,字节打印流： ------PrintStream 

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

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

2,字符打印流： PrintWriter-----web开发时很常用 

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

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

4，字符输出流，Writer。

b:常见构造

1 2 3 4 5 6 7

PrintWriter(OutputStream out); // PrintWriter(OutputStream out,  boolean  autoFlush); //自动刷新,println，printf或format方法 PrintWriter(File file)  PrintWriter(File file, String csn); //csn字符集，编码 PrintWriter(String fileName); PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true); //把String或者文件对象转换成流就可以自动刷新

（二）序列流SequenceInputStream----对多个流进行合并

构造函数

1.SequenceInputStream(InputStream s1, InputStream s2) 

2.SequenceInputStream(Enumeration<? extends InputStream> e);//枚举找聚合Vector，效率低

应用：多个源一个目的地的时候！----小说把多个章节集合到一个txt里面

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

class  SequenceDemo {      public  static  void  main(String[] args)  throws  IOException{          Vector<FileInputStream> v =  new  Vector<FileInputStream>(); //枚举就是Vector特有的取出方式          v.add( new  FileInputStream( "c:\\1.txt" ));          v.add( new  FileInputStream( "c:\\2.txt" ));          v.add( new  FileInputStream( "c:\\3.txt" ));          Enumeration<FileInputStream> en = v.elements();          SequenceInputStream sis =  new  SequenceInputStream(en);          FileOutputStream fos =  new  FileOutputStream( "c:\\4.txt" );          byte [] buf =  new  byte [ 1024 ];          int  len = 0 ;          while ((len=sis.read(buf))!=- 1 ){              fos.write(buf, 0 ,len);          }          fos.close();          sis.close();      } }

（三）切割文件

等份切割，非要说部分等分，最后一个可以不等份。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

class  SplitFile {      public  static  void  main(String[] args)  throws  IOException{          //splitFile();          merge();      }      public  static  void  merge() throws  IOException{          ArrayList<FileInputStream> al =  new  ArrayList<FileInputStream>();          for ( int  x= 1 ; x<= 3 ; x++){              al.add( new  FileInputStream( "c:\\splitfiles\\" +x+ ".part" ));          }          final  Iterator<FileInputStream> it = al.iterator(); //内部类只能调用final修饰的          Enumeration<FileInputStream> en =  new  Enumeration<FileInputStream>(){ //自己用内部类创建一个枚举              public  boolean  hasMoreElements()              {                  return  it.hasNext();              }              public  FileInputStream nextElement(){                  return  it.next();              }          };          SequenceInputStream sis =  new  SequenceInputStream(en);          FileOutputStream fos =  new  FileOutputStream( "c:\\splitfiles\\0.bmp" );          byte [] buf =  new  byte [ 1024 ];          int  len =  0 ;          while ((len=sis.read(buf))!=- 1 ){              fos.write(buf, 0 ,len);          }          fos.close();          sis.close();      }      public  static  void  splitFile() throws  IOException{          FileInputStream fis =   new  FileInputStream( "c:\\1.bmp" );          FileOutputStream fos =  null ;          byte [] buf =  new  byte [ 1024 * 1024 ];            int  len =  0 ;          int  count =  1 ;          while ((len=fis.read(buf))!=- 1 ){              fos =  new  FileOutputStream( "c:\\splitfiles\\" +(count++)+ ".part" );              fos.write(buf, 0 ,len);              fos.close();          }          fis.close();             } }

---

---

！！结尾！！