JAVA 私塾第十三章笔记整理

左右

JAVA 私塾第十三章笔记整理

第十三章  I/O流

    JDK所提供的所有流类型，都位于java.io包内都分别继承自以下四种抽象流类型：

	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

    节点流和处理流
        节点流可以从一个特定的数据源读写数据。
        处理流是连接在已存在的流之上，通过对数据的处理为程序提供更强大的读        
        写功能。
        【此处有图片，可以到JAVA 私塾官网下载完整笔记：www.javass.cn】

        继承自InputStream的流都是用于向程序中输入数据的，且数据的单位为字节（8bit）,上图中深色为节点流，浅色为处理流

        InputStream的方法：
             三个read方法
                int read()：读取一个字节，以整数的形式返回，如返回-1，则表示以到输入流的末尾。
                int read(byte[])：读取一系列字节，返回读取的字节数，如返回-1，则表示以到输入流的末尾。
                int read(byte[], int, int)：读取一系列字节，返回读取的字节数，如返回-1，则表示以到输入流的末尾。Int,int用于定义读取字节数组的范围。

                void close()：关闭流
                skip(long)：跳过n个字节不读，返回实际跳过的字节数。

       继承自OutputStream的流适用于程序输出数据的，且数据的单位为字节（8bit）,上图中深色为节点流，浅色为处理流
       【此处有图片，可以到JAVA 私塾官网下载完整笔记：www.javass.cn】

        void write(int)
        void write(byte[])
        void write(byte[],int,int)
        void close()
        void flush()将缓冲区的数据全部写到目的地。

        继承自InputStream的流都是用于向程序中输入数据的，且数据的单位为字节（16bit）,上图中深色为节点流，浅色为处理流
       【此处有图片，可以到JAVA 私塾官网下载完整笔记：www.javass.cn】

        Reader的方法：
            三个read方法
                int read()：读取一个字节，以整数的形式返回，如返回-1，则表示以到输入流的末尾。
                int read(byte[])：读取一系列字节，返回读取的字节数，如返回-1，则表示以到输入流的末尾。
                int read(byte[], int, int)：读取一系列字节，返回读取的字节数，如返回-1，则表示以到输入流的末尾。Int,int用于定义读取字节数组的范围。

                void close()：关闭流
                skip(long)：跳过n个字节不读，返回实际跳过的字节数。

       继承自Writer的流适用于程序输出数据的，且数据的单位为字节（16bit）,上图中深色为节点流，浅色为处理流
       【此处有图片，可以到JAVA 私塾官网下载完整笔记：www.javass.cn】

        void write(int)
        void write(byte[])
        void write(byte[],int,int)
        void close()
        void flush()将缓冲区的数据全部写到目的地。

FileInputStream

1. 
   
2. import java.io.*;
   
3. public class TestFileInputStream {
   
4.    public static void main(String[] args) {
   
5.       int b = 0;
   
6.       FileInputStream in = null;
   
7.       try {
   
8.          in = new FileInputStream("e:/TestFileInputStream.java");
   
9.       } catch (FileNotFoundException e) {
   
10.          System.out.println("找不到指定文件");
    
11.          System.exit(-1);
    
12.       }
    
13.    
    
14.       try {
    
15.          long num = 0;
    
16.          while((b=in.read())!=-1){
    
17.             System.out.print((char)b);
    
18.             num++;
    
19.          }
    
20.          in.close();  
    
21.          System.out.println();
    
22.          System.out.println("共读取了 "+num+" 个字节");
    
23.       } catch (IOException e1) {
    
24.         System.out.println("文件读取错误"); System.exit(-1);
    
25.       }
    
26.    }
    
27. }

复制代码

共读取了 700 个字节

FileOutputStream

1. 
   
2. import java.io.*;
   
3. public class TestFileOutputStream {
   
4.    public static void main(String[] args) {
   
5.       int b = 0;
   
6.       FileInputStream in = null;
   
7.       FileOutputStream out = null;
   
8.       try {
   
9.          in = new FileInputStream("e:/TestFileInputStream.java");
   
10.          out = new FileOutputStream("e:/1.java");
    
11.          while((b=in.read())!=-1){
    
12.             out.write(b);
    
13.          }
    
14.          in.close();
    
15.          out.close();
    
16.       } catch (FileNotFoundException e2) {
    
17.          System.out.println("找不到指定文件"); System.exit(-1);
    
18.       } catch (IOException e1) {
    
19.          System.out.println("文件复制错误"); System.exit(-1);
    
20.       }
    
21.       System.out.println("文件已复制");
    
22.    }
    
23. }

复制代码

FileReader

1. 
   
2. import java.io.*;
   
3. public class TestFileReader {
   
4.    public static void main(String[] args) {
   
5.       FileReader fr = null;
   
6.       int c = 0;
   
7.       try {
   
8.          fr = new FileReader("e:/TestFileReader.java");
   
9.          int ln = 0;
   
10.          while ((c = fr.read()) != -1) {
    
11.             System.out.print((char)c);
    
12.          }
    
13.          fr.close();
    
14.       } catch (FileNotFoundException e) {
    
15.          System.out.println("找不到指定文件");
    
16.       } catch (IOException e) {
    
17.          System.out.println("文件读取错误");
    
18.       }
    
19.    }
    
20. }

复制代码

FileWriter

1. 
   
2. import java.io.*;
   
3. public class TestFileWriter {
   
4.    public static void main(String[] args) {
   
5.       FileWriter fw = null;
   
6.       try {
   
7.          fw = new FileWriter("e:/sunicode.dat");
   
8.          for(int c=0;c<=50000;c++){
   
9.             fw.write(c);
   
10.          }
    
11.          fw.close();
    
12.       } catch (IOException e1) {
    
13.             e1.printStackTrace();
    
14.         System.out.println("文件写入错误");
    
15.         System.exit(-1);
    
16.       }
    
17.    }
    
18. }

复制代码

BufferedStream

1. 
   
2. import java.io.*;
   
3. public class TestBufferStream{
   
4.   public static void main(String[] args) {
   
5.     try {
   
6.       BufferedWriter bw = new BufferedWriter(new FileWriter("e:/2.java"));
   
7.       BufferedReader br = new BufferedReader(
   
8.              new FileReader("e:/1.java"));
   
9.       String s = null;
   
10.       for(int i=1;i<=100;i++){
    
11.         s = String.valueOf(Math.random());
    
12.         bw.write(s);
    
13.         bw.newLine();
    
14.       }
    
15.       bw.flush();
    
16.       while((s=br.readLine())!=null){
    
17.         System.out.println(s);
    
18.       }
    
19.       bw.close();
    
20.       br.close();
    
21.     } catch (IOException e) { e.printStackTrace();}
    
22.   }
    
23. }

复制代码

简述File类的基本功能
        处理文件和获取文件信息,文件或文件夹的管理
        除了读写文件内容其他的都可以做

代码示例：如何使用随机文件读写类来读写文件内容
    RW表示文件时可读写的
       读：
  try{
    RandomAccessFile f = new RandomAccessFile("test.txt", "rw");
    long len = 0L;
    long allLen = f.length();
    int i = 0;
    while (len < allLen) {
      String s = f.readLine();
      if (i > 0) {
          col.add(s);
      }
      i++;
      //游标
      len = f.getFilePointer();
    }
  }catch(Exception err){
    err.printStackTrace();
  }
  
  写：
  
  try{
    RandomAccessFile f = new RandomAccessFile("test.txt", "rw");
    StringBuffer buffer = new StringBuffer("\n");
    Iterator it = col.iterator();
    while (it.hasNext()) {
      buffer.append(it.next() + "\n");
    }
    f.writeUTF(buffer.toString());
  }catch(Exception err){
     err.printStackTrace();
  }

代码示例：如何使用流的基本接口来读写文件内容

1. 
   
2. import java.io.*;
   
3. public class Test{
   
4. public static void main(String args[]){
   
5.    String currentLine;
   
6.    try{
   
7.       DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream("Test.java")));
   
8.       while ((currentLine = in.readLine()) != null)
   
9.          System.out.println(currentLine);
   
10.       }catch (IOException e) {
    
11.          System.err.println("Error: " + e);
    
12.       } // End of try/catch structure.
    
13.    } // End of method: main
    
14. } // End of class
    

复制代码