黑马程序员 Java IO总结二

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

File类

表示文件和目录的一个类

在程序中操作文件和目录都可以通过File类来完成，

但是想要访问文件中的内容他就无能为力了，还是得用IO流。

 

常见方法：

1，创建。

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

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

       booleanmkdir():创建文件夹。

       booleanmkdirs():创建多级文件夹。

2，删除。

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

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

3，判断。

       booleanexists():文件或目录是否存在.

       isFile():是否是一个标准文件。

       isDirectory();是否是一个目录。

       isHidden();是否是一个隐藏文件。

       isAbsolute();是否为绝对路径名。

4，获取信息。

       getName():

       getPath():

       getParent():

       getAbsolutePath()

       longlastModified()

       longlength()

 

什么是递归

       程序调用自身的编程技巧称为递归。递归做为一种算法在程序设计语言中广泛应用。

       递归就是在过程或函数里调用自身；使用递归时，必须有一个明确的递归结束条件。

 

练习：

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

思路：

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

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

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

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

import java.io.*;import java.util.*;class JavaFileList{       publicstatic void main(String[] args) throws IOException       {             //创建File对象，指定要访问的文件位置              Filedir = new File("d:\\java1223");       //创建ArrayList集合对象              List<File>list = new ArrayList<File>();               fileToList(dir,list);               //System.out.println(list.size());               Filefile = new File(dir,"javalist.txt");              writeToFile(list,file.toString());       }        publicstatic void fileToList(File dir,List<File> list)       {              File[]files = dir.listFiles();               for(Filefile : files)              {                     if(file.isDirectory())//如果还有文件目录就调用fileToList方法，这就是递归                            fileToList(file,list);                     else                     {    //如果文件后缀名为.java则添加文件                            if(file.getName().endsWith(".java"))                                   list.add(file);                     }              }       }        publicstatic void writeToFile(List<File> list,String javaListFile)throwsIOException       {     //建立BufferedWriter的引用              BufferedWriter bufw =  null;              try              {                     bufw= new BufferedWriter(new FileWriter(javaListFile));                                 //使用高级for遍历list集合                     for(File f : list)                     {                            Stringpath = f.getAbsolutePath();                            bufw.write(path);                            bufw.newLine();                            bufw.flush();                     }              }              catch(IOException e)              {                     throwe;              }      //在finally中关闭资源              finally              {                     try                     {                            if(bufw!=null)                                   bufw.close();                     }                     catch(IOException e)                     {                            throwe;                     }              }       }}

打印流：

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

       保证原样性的原理：其实就是将数据变成字符串，在进行写入操作。

 

       PrintStream：字节打印流。

              1，构造函数接收File对象，字符串路径String，字节输出流OutputStream。

              2，该对象具备特有的方法 打印方法 print println,可以打印任何类型的数据。

              3，特有的print方法可以保持任意类型数据表现形式的原样性，将数据输出到目的地。

                     对于OutputStream父类中的write，是将数据的最低字节写出去。

                    

       PrintWriter：字符打印流。

              1，当操作的数据是字符时，可以选择PrintWriter，比PrintStream要方便。

              2，它的构造函数可以接收 File对象，字符串路径，字节输出流，字符输出流。

              3，构造函数中，如果参数是输出流，那么可以通过指定另一个参数true完成自动刷新，该true对println方法有效。

import java.io.*; class PrintStreamDemo{       publicstatic void main(String[] args) throws IOException       {      //创建缓冲区对象，加入转换流，输入流为System.in              BufferedReaderbufr =                     newBufferedReader(new InputStreamReader(System.in));       //创建打印流对象              PrintWriterout = new PrintWriter(new FileWriter("a.txt"),true);               Stringline = null;       //缓冲区数据不为null就一直循环              while((line=bufr.readLine())!=null)              {     //如果读取的字符中包含over，就break                     if("over".equals(line))                            break;     //打印成大写                     out.println(line.toUpperCase());                     //out.flush();              }             //关闭资源              out.close();              bufr.close();       }    }

 

Properties(hashtable的子类)

       也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。

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

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

       那么在加载数据时，需要数据有固定格式：键=值。

/*用于记录应用程序运行次数。如果使用次数已到，那么给出注册提示。 很容易想到的是:计数器。可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。可是随着该应用程序的退出，该计数器也在内存中消失了。 下一次在启动该程序，又重新开始从0计数,这样不是我们想要的。程序即使结束，该计数器的值也存在。下次程序启动在会先加载该计数器的值并加1后在重新存储起来。 所以要建立一个配置文件。用于记录该软件的使用次数。该配置文件使用键值对的形式,这样便于阅读数据，并操作数据。 键值对数据是map集合。数据是以文件形式存储，使用io技术。那么map+io-->properties. 配置文件可以实现应用程序数据的共享。*/import java.io.*;import java.util.*;class RunCount{       publicstatic void main(String[] args) throws IOException       {              Propertiesprop = new Properties();               Filefile = new File("count.ini");              if(!file.exists())                     file.createNewFile();                           FileInputStreamfis = new FileInputStream(file);               prop.load(fis);               intcount = 0;              Stringvalue = prop.getProperty("time");                           if(value!=null)              {                     count= Integer.parseInt(value);                     if(count>=5)                     {                            System.out.println("您好，使用次数已到!");                            return;                     }              }              count++;               prop.setProperty("time",count+"");               FileOutputStreamfos = new FileOutputStream(file);               prop.store(fos,"");               fos.close();              fis.close();                   }} 

ObjectInputStream 和 ObjectOutputStream
 
对象的序列化和反序列化。
 
writeObject  readObject
 
Serializable标记接口
 
关键字：transient

import java.io.*; class ObjectStreamDemo{       publicstatic void main(String[] args) throws Exception       {              //writeObj();              readObj();       }       publicstatic void readObj()throws Exception       {              ObjectInputStreamois = new ObjectInputStream(new FileInputStream("obj.txt"));               Personp = (Person)ois.readObject();               System.out.println(p);              ois.close();       }        publicstatic void writeObj()throws IOException       {              ObjectOutputStreamoos =                     newObjectOutputStream(new FileOutputStream("obj.txt"));               oos.writeObject(newPerson("lisi0",399,"kr"));               oos.close();       }} 

RandomAccessFile:

       特点：

       1，即可读取，又可以写入。

       2，内部维护了一个大型的byte数组，通过对数组的操作完成读取和写入。

       3，通过getFilePointer方法获取指针的位置，还可以通过seek方法设置指针的位置。

       4，该对象的内容应该封装了字节输入流和字节输出流。

       5，该对象只能操作文件。

      

       通过seek方法操作指针，可以从这个数组中的任意位置上进行读和写

       可以完成对数据的修改。

       但是要注意：数据必须有规律。

/*该类不是算是IO体系中子类。而是直接继承自Object。 但是它是IO包中成员。因为它具备读和写功能。内部封装了一个数组，而且通过指针对数组的元素进行操作。可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置。 其实完成读写的原理就是内部封装了字节输入流和输出流。 通过构造函数可以看出，该类只能操作文件。而且操作文件还有模式：只读r，，读写rw等。 如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。 */import java.io.*;class RandomAccessFileDemo{       publicstatic void main(String[] args) throws IOException       {              //writeFile_2();              //readFile();               //System.out.println(Integer.toBinaryString(258));       }        publicstatic void readFile()throws IOException       {              RandomAccessFileraf = new RandomAccessFile("ran.txt","r");                           //调整对象中指针。              //raf.seek(8*1);               //跳过指定的字节数              raf.skipBytes(8);               byte[]buf = new byte[4];               raf.read(buf);               Stringname = new String(buf);               intage = raf.readInt();                System.out.println("name="+name);              System.out.println("age="+age);               raf.close();       }        publicstatic void writeFile_2()throws IOException       {              RandomAccessFileraf = new RandomAccessFile("ran.txt","rw");              raf.seek(8*0);              raf.write("周期".getBytes());              raf.writeInt(103);               raf.close();       }        publicstatic void writeFile()throws IOException       {              RandomAccessFileraf = new RandomAccessFile("ran.txt","rw");               raf.write("李四".getBytes());              raf.writeInt(97);              raf.write("王五".getBytes());              raf.writeInt(99);               raf.close();       }} 

SequenceInputStream:
       特点：
       1，将多个字节读取流和并成一个读取流，将多个源合并成一个源，操作起来方便。
       2，需要的枚举接口可以通过Collections.enumeration(collection);

import java.io.*;import java.util.*;class SequenceDemo{       publicstatic void main(String[] args) throws IOException       {               Vector<FileInputStream>v = new Vector<FileInputStream>();                           v.add(newFileInputStream("c:\\1.txt"));              v.add(newFileInputStream("c:\\2.txt"));              v.add(newFileInputStream("c:\\3.txt"));               Enumeration<FileInputStream>en = v.elements();               SequenceInputStreamsis = new SequenceInputStream(en);               FileOutputStreamfos = new FileOutputStream("c:\\4.txt");               byte[]buf = new byte[1024];               intlen =0;              while((len=sis.read(buf))!=-1)              {                     fos.write(buf,0,len);                           fos.close();              sis.close();       }}

管道流：

需要和多线程技术相结合的流对象。

PipedOutputStream

PipedInputStream

import java.io.*; class Read implements Runnable{       privatePipedInputStream in;       Read(PipedInputStreamin)       {              this.in= in;       }       publicvoid run()       {              try              {                     byte[]buf = new byte[1024];                      System.out.println("读取前。。没有数据阻塞");                     intlen = in.read(buf);                     System.out.println("读到数据。。阻塞结束");                      Strings= new String(buf,0,len);                      System.out.println(s);                      in.close();              }              catch(IOException e)              {                     thrownew RuntimeException("管道读取流失败");              }       }} class Write implements Runnable{       privatePipedOutputStream out;       Write(PipedOutputStreamout)       {              this.out= out;       }       publicvoid run()       {              try              {                     System.out.println("开始写入数据，等待6秒后。");                     Thread.sleep(6000);                     out.write("pipedlai la".getBytes());                     out.close();              }              catch(Exception e)              {                     thrownew RuntimeException("管道输出流失败");              }       }} class PipedStreamDemo{       publicstatic void main(String[] args) throws IOException       {               PipedInputStreamin = new PipedInputStream();              PipedOutputStreamout = new PipedOutputStream();              in.connect(out);               Readr = new Read(in);              Writew = new Write(out);              newThread(r).start();              newThread(w).start();       }}

用于操作字节数组的流对象。

ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。

ByteArrayOutputStream： 在构造的时候，不用定义数据目的，

因为该对象中已经内部封装了可变长度的字节数组。这就是数据目的地。

因为这两个流对象都操作的数组，并没有使用系统资源。所以，不用进行close关闭。

 

流操作规律：

源设备，

       键盘 System.in，硬盘 FileStream，内存 ArrayStream。

目的设备：

       控制台 System.out，硬盘FileStream，内存 ArrayStream。

用流的读写思想来操作数据。

import java.io.*;class ByteArrayStream{       publicstatic void main(String[] args)       {              //数据源。              ByteArrayInputStreambis = new ByteArrayInputStream("ABCDEFD".getBytes());               //数据目的              ByteArrayOutputStreambos = new ByteArrayOutputStream();               intby = 0;               while((by=bis.read())!=-1)              {                     bos.write(by);              }               System.out.println(bos.size());              System.out.println(bos.toString());        //     bos.writeTo(newFileOutputStream("a.txt"));       }}

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