IO流（其余流的介紹）-有解無憂

可以讀寫基本資料型別的資料
* 資料輸入流：DataInputStream
* DataInputStream(InputStream in)
* 資料輸出流：DataOutputStream
* DataOutputStream(OutputStream out)

package cn.itcast_01;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 可以讀寫基本資料型別的資料
 * 資料輸入流：DataInputStream
 *             DataInputStream(InputStream in)
 * 資料輸出流：DataOutputStream
 *             DataOutputStream(OutputStream out) 
 */
public class DataStreamDemo {
    public static void main(String[] args) throws IOException {
        // 寫
        // write();

        // 讀
        read();
    }

    private static void read() throws IOException {
        // DataInputStream(InputStream in)
        // 創建資料輸入流物件
        DataInputStream dis = new DataInputStream(
                new FileInputStream("dos.txt"));

        // 讀資料
        byte b = dis.readByte();
        short s = dis.readShort();
        int i = dis.readInt();
        long l = dis.readLong();
        float f = dis.readFloat();
        double d = dis.readDouble();
        char c = dis.readChar();
        boolean bb = dis.readBoolean();

        // 釋放資源
        dis.close();

        System.out.println(b);
        System.out.println(s);
        System.out.println(i);
        System.out.println(l);
        System.out.println(f);
        System.out.println(d);
        System.out.println(c);
        System.out.println(bb);
    }

    private static void write() throws IOException {
        // DataOutputStream(OutputStream out)
        // 創建資料輸出流物件
        DataOutputStream dos = new DataOutputStream(new FileOutputStream(
                "dos.txt"));

        // 寫資料了
        dos.writeByte(10);
        dos.writeShort(100);
        dos.writeInt(1000);
        dos.writeLong(10000);
        dos.writeFloat(12.34F);
        dos.writeDouble(12.56);
        dos.writeChar('a');
        dos.writeBoolean(true);

        // 釋放資源
        dos.close();
    }
}

記憶體操作流：用于處理臨時存盤資訊的，程式結束，資料就從記憶體中消失，
* 位元組陣列：
* ByteArrayInputStream
* ByteArrayOutputStream
* 字符陣列：
* CharArrayReader
* CharArrayWriter
* 字串：
* StringReader
* StringWriter

package cn.itcast_02;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

/*
 * 記憶體操作流：用于處理臨時存盤資訊的，程式結束，資料就從記憶體中消失，
 * 位元組陣列：
 *         ByteArrayInputStream
 *         ByteArrayOutputStream
 * 字符陣列：
 *         CharArrayReader
 *         CharArrayWriter
 * 字串：
 *         StringReader
 *         StringWriter
 */
public class ByteArrayStreamDemo {
    public static void main(String[] args) throws IOException {
        // 寫資料
        // ByteArrayOutputStream()
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        // 寫資料
        for (int x = 0; x < 10; x++) {
            baos.write(("hello" + x).getBytes());
        }

        // 釋放資源
        // 通過查看原始碼我們知道這里什么都沒做，所以根本需要close()
        // baos.close();

        // public byte[] toByteArray()
        byte[] bys = baos.toByteArray();

        // 讀資料
        // ByteArrayInputStream(byte[] buf)
        ByteArrayInputStream bais = new ByteArrayInputStream(bys);

        int by = 0;
        while ((by = bais.read()) != -1) {
            System.out.print((char) by);
        }

        // bais.close();
    }
}

*
* 列印流
* 位元組流列印流 PrintStream
* 字符列印流 PrintWriter
*
* 列印流的特點：
* A:只有寫資料的，沒有讀取資料，只能操作目的地，不能操作資料源，
* B:可以操作任意型別的資料，
* C:如果啟動了自動重繪，能夠自動重繪，
* D:該流是可以直接操作文本檔案的，
* 哪些流物件是可以直接操作文本檔案的呢?
* FileInputStream
* FileOutputStream
* FileReader
* FileWriter
* PrintStream
* PrintWriter
* 看API,查流物件的構造方法，如果同時有File型別和String型別的引數，一般來說就是可以直接操作檔案的，
*
* 流：
* 基本流：就是能夠直接讀寫檔案的
* 高級流：在基本流基礎上提供了一些其他的功能

package cn.itcast_03;

import java.io.IOException;
import java.io.PrintWriter;

/*
 * 列印流
 * 位元組流列印流    PrintStream
 * 字符列印流    PrintWriter
 * 
 * 列印流的特點：
 *         A:只有寫資料的，沒有讀取資料，只能操作目的地，不能操作資料源，
 *         B:可以操作任意型別的資料，
 *         C:如果啟動了自動重繪，能夠自動重繪，
 *         D:該流是可以直接操作文本檔案的，
 *             哪些流物件是可以直接操作文本檔案的呢?
 *             FileInputStream
 *             FileOutputStream
 *             FileReader
 *             FileWriter
 *             PrintStream
 *             PrintWriter
 *             看API,查流物件的構造方法，如果同時有File型別和String型別的引數，一般來說就是可以直接操作檔案的，
 * 
 *             流：
 *                 基本流：就是能夠直接讀寫檔案的
 *                 高級流：在基本流基礎上提供了一些其他的功能
 */
public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        // 作為Writer的子類使用
        PrintWriter pw = new PrintWriter("pw.txt");

        pw.write("hello");
        pw.write("world");
        pw.write("java");
        
        pw.close();
    }
}

package cn.itcast_03;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/*
 * 1:可以操作任意型別的資料，
 *         print()
 *         println()
 * 2:啟動自動重繪
 *         PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
 *         還是應該呼叫println()的方法才可以
 *         這個時候不僅僅自動重繪了，還實作了資料的換行，
 * 
 *         println()
 *        其實等價于于：
 *        bw.write();
 *        bw.newLine();        
 *        bw.flush();
 */
public class PrintWriterDemo2 {
    public static void main(String[] args) throws IOException {
        // 創建列印流物件
        // PrintWriter pw = new PrintWriter("pw2.txt");
        PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);

        // write()是搞不定的，怎么辦呢?
        // 我們就應該看看它的新方法
        // pw.print(true);
        // pw.print(100);
        // pw.print("hello");

        pw.println("hello");
        pw.println(true);
        pw.println(100);

        pw.close();
    }
}

列印流改進復制文本檔案案例

需求：DataStreamDemo.java復制到Copy.java中 -----printWriter實作自動重繪和自動換行

package cn.itcast_03;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/*
 * 需求：DataStreamDemo.java復制到Copy.java中
 * 資料源：
 *         DataStreamDemo.java -- 讀取資料 -- FileReader -- BufferedReader
 * 目的地：
 *         Copy.java -- 寫出資料 -- FileWriter -- BufferedWriter -- PrintWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        // 以前的版本
        // 封裝資料源
        // BufferedReader br = new BufferedReader(new FileReader(
        // "DataStreamDemo.java"));
        // // 封裝目的地
        // BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
        //
        // String line = null;
        // while ((line = br.readLine()) != null) {
        // bw.write(line);
        // bw.newLine();
        // bw.flush();
        // }
        //
        // bw.close();
        // br.close();

        // 列印流的改進版
        // 封裝資料源
        BufferedReader br = new BufferedReader(new FileReader(
                "DataStreamDemo.java"));
        // 封裝目的地
        PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true);
        
        String line = null;
        while((line=br.readLine())!=null){
            pw.println(line);
        }
        
        pw.close();
        br.close();
    }
}

/*
* 隨機訪問流：
* RandomAccessFile類不屬于流，是Object類的子類，
* 但它融合了InputStream和OutputStream的功能，
* 支持對檔案的隨機訪問讀取和寫入，
*
* public RandomAccessFile(String name,String mode)：第一個引數是檔案路徑，第二個引數是操作檔案的模式，
* 模式有四種，我們最常用的一種叫"rw",這種方式表示我既可以寫資料，也可以讀取資料
*/

package cn.itcast_05;

import java.io.IOException;
import java.io.RandomAccessFile;

/*
 * 隨機訪問流：
 *         RandomAccessFile類不屬于流，是Object類的子類，
 *         但它融合了InputStream和OutputStream的功能，
 *         支持對檔案的隨機訪問讀取和寫入，
 * 
 * public RandomAccessFile(String name,String mode)：第一個引數是檔案路徑，第二個引數是操作檔案的模式，
 *         模式有四種，我們最常用的一種叫"rw",這種方式表示我既可以寫資料，也可以讀取資料 
 */
public class RandomAccessFileDemo {
    public static void main(String[] args) throws IOException {
        // write();
        read();
    }

    private static void read() throws IOException {
        // 創建隨機訪問流物件
        RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");

        int i = raf.readInt();
        System.out.println(i);
        // 該檔案指標可以通過 getFilePointer方法讀取，并通過 seek 方法設定，
        System.out.println("當前檔案的指標位置是：" + raf.getFilePointer());

        char ch = raf.readChar();
        System.out.println(ch);
        System.out.println("當前檔案的指標位置是：" + raf.getFilePointer());

        String s = raf.readUTF();
        System.out.println(s);
        System.out.println("當前檔案的指標位置是：" + raf.getFilePointer());

        // 我不想重頭開始了，我就要讀取a，怎么辦呢?
        raf.seek(4);
        ch = raf.readChar();
        System.out.println(ch);
    }

    private static void write() throws IOException {
        // 創建隨機訪問流物件
        RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");

        // 怎么玩呢?
        raf.writeInt(100);
        raf.writeChar('a');
        raf.writeUTF("中國");

        raf.close();
    }
}

合并流讀取兩個檔案的內容復制到一個檔案中

package cn.itcast_06;

import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;

/*
 * 以前的操作：
 * a.txt -- b.txt
 * c.txt -- d.txt
 * 
 * 現在想要：
 * a.txt+b.txt -- c.txt
 */
public class SequenceInputStreamDemo {
    public static void main(String[] args) throws IOException {
        // SequenceInputStream(InputStream s1, InputStream s2)
        // 需求：把ByteArrayStreamDemo.java和DataStreamDemo.java的內容復制到Copy.java中
        InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
        InputStream s2 = new FileInputStream("DataStreamDemo.java");
        SequenceInputStream sis = new SequenceInputStream(s1, s2);
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("Copy.java"));

        // 如何寫讀寫呢，其實很簡單，你就按照以前怎么讀寫，現在還是怎么讀寫
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = sis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        sis.close();
    }
}

合并流讀取多個檔案的內容復制到一個檔案中

package cn.itcast_06;

import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

/*
 * 以前的操作：
 * a.txt -- b.txt
 * c.txt -- d.txt
 * e.txt -- f.txt
 * 
 * 現在想要：
 * a.txt+b.txt+c.txt -- d.txt
 */
public class SequenceInputStreamDemo2 {
    public static void main(String[] args) throws IOException {
        // 需求：把下面的三個檔案的內容復制到Copy.java中
        // ByteArrayStreamDemo.java,CopyFileDemo.java,DataStreamDemo.java

        // SequenceInputStream(Enumeration e)
        // 通過簡單的回顧我們知道了Enumeration是Vector中的一個方法的回傳值型別，
        // Enumeration<E> elements()
        Vector<InputStream> v = new Vector<InputStream>();
        InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
        InputStream s2 = new FileInputStream("CopyFileDemo.java");
        InputStream s3 = new FileInputStream("DataStreamDemo.java");
        v.add(s1);
        v.add(s2);
        v.add(s3);
        Enumeration<InputStream> en = v.elements();
        SequenceInputStream sis = new SequenceInputStream(en);
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("Copy.java"));

        // 如何寫讀寫呢，其實很簡單，你就按照以前怎么讀寫，現在還是怎么讀寫
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = sis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        sis.close();
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/455516.html

標籤：其他

上一篇：java中如何對二進制數進行相加呢？

下一篇：java中String.intern()方法具有什么功能呢？