IO流（三）其他流与File类

1:其他的流

1： DataOutputStream ;多了一些操作基本数据类型的功能

DataInputStream:读取文件。

用DataOutputStream流写进去的数据，就用DataInputStream流来读取。

 import java.io.DataInputStream;

 import java.io.DataOutputStream;

 import java.io.FileInputStream;

 import java.io.FileOutputStream;

 import java.io.IOException;

 public class DateIODemo1 {

          public static void main(String[] args) throws IOException {

                    FileOutputStream fos = new FileOutputStream("e:\\cc.txt");

                    /*

                     * 数据输出流是一种处理流，所以应该传入一个节点流作为参数

                     * 数据输出流写到文本上的内容是不是按照程序中的原样写进文件中的

                     */

                    DataOutputStream dos = new DataOutputStream(fos);

                    dos.writeInt(123);//4字节

                    dos.writeBoolean(false);//1字节

                    dos.writeDouble(12.34);//8字节

                    //数据输出流是一种处理流，所以应该传入一个节点流作为参数

                    FileInputStream fis = new FileInputStream("e:\\cc.txt");

                    DataInputStream dis = new DataInputStream(fis);

                    //按顺序读取才能读到正确的数据

                    System.out.println(dis.readInt());

                    System.out.println(dis.readBoolean());

                    System.out.println(dis.readDouble());

                    dis.close();

                    dos.close();

          }

 }

  2：关于内存的流：不用制定硬盘中的某个文件路径，因为所有的数据都是写入到内存上的，所以这些数据不会被永久保存。

　　　　　　2.1 ByteArrayOutputStream;内存写入流。如果不是字符，则可以调用toByteArray方法获得内存中的数据。

 import java.io.ByteArrayOutputStream;

 import java.io.IOException;

 public class ByteArrayOutputDemo1 {

          public static void main(String[] args) throws IOException, InterruptedException {

                    ByteArrayOutputStream bos = new ByteArrayOutputStream();

                    bos.write("我写的这些东西真的放到了内存里面了".getBytes());

                    String str = bos.toString();

                    System.out.println(str);

          }

 }

2.2 ByteArrayInputStream:内存读取流。

 import java.io.ByteArrayInputStream;

 import java.io.IOException;

 public class ByteArrayInputStreamDemo1 {

          public static void main(String[] args) throws IOException {

                    byte[] b = "我真的真的在内存里面".getBytes();

                    ByteArrayInputStream bis = new ByteArrayInputStream(b);

                    byte[] b2 = new byte[1024];

                    int len = -1;

                    while((len = bis.read(b2)) != -1){

                             System.out.println(new String(b2, 0, len));

                    }       

          }

 }

3：打印流: PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。

PrintStream

PrintWriter

 import java.io.BufferedReader;

 import java.io.InputStream;

 import java.io.InputStreamReader;

 import java.io.PrintStream;

 //接收键盘录入，写到文件中。

 public class PrintStreamDemo2 {

          public static void main(String[] args)throws Exception {

                    InputStream is = System.in;

                    BufferedReader br = new BufferedReader(new InputStreamReader(is));

                    //打印流。

                    PrintStream ps = new PrintStream("f:\\aaa.txt");

                    String str = null;

                    while(true){

                             str = br.readLine();

                             if("886".equals(str)){

                                      break;

                             }

                             ps.println(str);//将数据和换行写到目的地中。

                    }

                    br.close();

          }

 }

4：RandomAccessFile：随机流。这个流并不是像平时说的那样“随机”，只是程序员可以使用这个类类读取文件中指定位置的数据，或者在文件中指定是位置写入数据。关键的方法就是seek();

 import java.io.FileNotFoundException;

 import java.io.IOException;

 import java.io.RandomAccessFile;

 public class RandomAccessFiileDemo1 {

          public static void main(String[] args) throws IOException {

                    RandomAccessFile raf = new RandomAccessFile("e:\\cc.txt", "rw");

                    raf.writeBoolean(true);

                    raf.writeBytes("he");

 //               raf.writeFloat(123.99f);

                    raf.write(123);

                    raf.seek(0);//可以让指针指向文件的某个位置

                    System.out.println(raf.readBoolean());

                    System.out.println(raf.read());

                    System.out.println(raf.readInt());

                    //System.out.println(raf.readInt());

                    raf.close();

          }

 }

5：对象流.    Object   操作对象的流

这里会涉及到一个关键字transient（中文：短暂的，临时的），用来修饰成员变量。被static或者transient修饰的成员变量时改变量的值不会被对象流写出去的，也不会被读取到。对象流操作对象必须事项序列化接口Serializable，要不会出现java.io.InvalidClassException 无效的类型异常。

 import java.io.FileInputStream;

 import java.io.FileOutputStream;

 import java.io.IOException;

 import java.io.ObjectInputStream;

 import java.io.ObjectOutputStream;

 import com.java.domain.Student;

 public class WriterObjectDemo1 {

          public static void main(String[] args) throws IOException, ClassNotFoundException {

                    FileOutputStream fos = new FileOutputStream("e:\\stu.txt");

                    ObjectOutputStream oos = new ObjectOutputStream(fos);

                    oos.writeObject(new Student("zzz", 12));

                    oos.close();

                    // java.io.InvalidClassException 无效的类型异常

                    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e:\\stu.txt"));

                    System.out.println(ois.readObject());

                    ois.close();

          }

 }

import java.io.Serializable;

public class Student implements Serializable {

         //使用对象

         private static final long serialVersionUID = 1L;

         private String name;

         //private static int age;

         private transient int age;

//      private int age;

         public Student() {

                   super();

                   // TODO Auto-generated constructor stub

         }

         public Student(String name, int age) {

                   super();

                   this.name = name;

                   this.age = age;

         }

         @Override

         public String toString() {

                   return "Student [name=" + name + ", age=" + age + "]";

         }

         public void test(){

         }

}

Student类

     6:文件类.     File

6.1:File:表示文件或者目录。

6.2 常用的一些方法

　　　　　　　　　　delete() 删除文件或目录。

　　　　　　　　　　exists() 判断文件或目录是否存在。

　　　　　　　　　　getAbsoluteFile()  返回路径名的绝对路径名形式。返回值-File

　　　　　　　　　　getAbsolutePath()  返回路径名的绝对路径名字符串。返回值-String

　　　　　　　　　　getName() 返回由路径名表示的文件或目录的名称。

　　　　　　　　　　boolean isDirectory()  路径名表示的文件是否是一个目录。

　　　　　　　　　　boolean isFile()  路径名表示的文件是否是一个标准文件。

　　　　　　　　　　length()  返回路径名表示的文件的长度。

String[]	list()返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
String[]	list(FilenameFilter filter)返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[]	listFiles()返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
File[]	listFiles(FileFilter filter)返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[]	listFiles(FilenameFilter filter)返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

　　　　　　　　　　mkdir()  创建此抽象路径名指定的目录（只能创建一层）。

　　　　　　　　　　mkdirs() 创建此抽象路径名指定的目录（可创建多层）。

经典示例：

// 遍历所有文件

   public static void getFiles(String path) {

                    File file = new File(path);

                    if (!file.exists()) {

                             System.out.println("没有找到该路径或者文件");

                             return;

                    }

                    if (file.isFile()) {

                             System.out.println(file.getAbsolutePath());

                    } else {

                             System.out.println(file.getAbsolutePath());

                             File[] files = file.listFiles();

                             // 遍历文件

                             for (File file2 : files) {// 递归遍历

                                      // 如果是目录在重新调用自己

                                      getFiles(file2.getAbsolutePath());

                             }

                    }

          }

// 删除所有文件

   public static void deleteFile2(String path) {

                    File file = new File(path);

                    if (!file.exists()) {

                             return;

                    }

                    if (file.isFile()) {

                             file.delete();

                    } else {

                             File[] files = file.listFiles();

                             for (File file2 : files) {

                                      deleteFile2(file2.getAbsolutePath());

                             }

                             file.delete();

                    }

          }