Java IO流

IO(Input Output)流

• IO流用來處理設備之間的數據傳輸
• Java對數據的操作是通過流的方式
• Java用於操作流的對象都在IO包中
• 流按操作數據分爲兩種: 字節流與字符流。

• 流按流向分爲：輸入流，輸出流。

• 字節流的抽象基類：

  • InputStream OutputStream
• 字符流的抽象基類：
  
  • Reader Writer
• 注:由這四個類派生出來的子類名稱都是以其父類名作爲子類名的後綴
  
  • 如: InputStream 的子類 FileInputStream
  • 如: Reader的子類 FileReader

FileWriter

• 寫文件
• 異常處理

import java.io.*;
/*
字符流
在硬盤上創建一個文件，並寫入一些文字數據
*/
class IoDemo
{
    public static void main(String[] args)
    {
        FileWriter wt=null;
        try
        {
            //創建一個FileWriter對象，該對象一被初始化就必須要明確被操作的文件
            //而且該文件會被創建到指定目錄下。如果該目錄下已有同名文件，將被覆蓋。
            //這一步就是在明確數據要存放的目的地。
            wt=new FileWriter("d:\\test.txt");

            //調用write方法，將字符串寫入到流中
            wt.write("hello.");
            //將數據刷到目的地中
            wt.write("test");
            wt.flush();
            //關閉流資源，但是關閉之前會刷新一次內部的緩衝中的數據
            //將數據刷到目的地中


        }
        catch(IOException e)
        {

            e.printStackTrace();
        }
        finally
        {
            try
            {
                //和flush區別:flush刷新後，流可以繼續使用
                //close刷新後，會將流關閉。
                if(wt!=null)
                    wt.close();
            }
            catch(IOException e)
            {
                e.printStackTrace();
            }
        }

    }
}

文件的續寫

FileWriter(String filename,boolean append);//第二個參數代表是否追加,如果爲true將添加文本到文件末尾處

/*
演示對已有文件的數據續寫
\r\n代表換行
*/
import java.io.*;
class IoDemo2
{
    public static void main(String[] args) throws IOException
    {
        //在文件末尾處追加文本
        //傳遞一個true參數，代表不覆蓋已有文件.
        FileWriter fw =null;
        try
        {
            fw=new FileWriter("d:\\test.txt",true);
            fw.write("\r\nappend");         
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            try
            {
                if(fw!=null)
                    fw.close();
            }
            catch(IOException e)
            {
                e.printStackTrace();
            }

        }
    }
}

FileReader 字符文件讀取

int read()讀取一個字符

/*

*/
import java.io.*;
class ReaderDemo
{
    public static void main(String[] args) throws IOException
    {

        FileReader fr=null;
        String encoding=null;

        try
        {
            //創建一個文件讀取流對象，和指定名稱的文件相關聯
            //要保證該文件是已經存在的，如果不存在，會發生FileNotFoundException
            fr=new FileReader("d:\\test.txt");
            encoding=fr.getEncoding();
            //調用讀取流對象的read方法.
            //read():一次讀取一個字符，而且會自動往下讀。
            for(int ch=fr.read();ch!=-1;ch=fr.read())
            {
                System.out.print((char)ch);
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            try
            {
                if(fr!=null)
                    fr.close();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }

    }
}

int read(char[] cbuf) 將字符讀入數組

import java.io.*;
import java.util.*;
class ReaderDemo2
{
    public static void main(String[] args) throws IOException
    {

        FileReader fr=null;
        String encoding=null;
        //定義一個字符數組，用於存儲讀取到的字符
        char[] cbuf=new char[1024];

        try
        {
            //創建一個文件讀取流對象，和指定名稱的文件相關聯
            //要保證該文件是已經存在的，如果不存在，會發生FileNotFoundException
            fr=new FileReader("d:\\test.txt");
            encoding=fr.getEncoding();
            //調用讀取流對象的read方法.
            //read():一次讀取一個字符，而且會自動往下讀。

            for(int num=fr.read(cbuf);num!=-1;num=fr.read(cbuf))
            {
                System.out.println(new String(cbuf,0,num));
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            try
            {
                if(fr!=null)
                    fr.close();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

拷貝文件

//將C盤一個文本文件複製到D盤
/*
複製的原理:
其實就是將C盤下的文件數據存儲到D盤的一個文件彙總。
步驟:
1.在D盤創建一個文件，用於存儲C盤文件中的數據
2.定義讀取流和C盤文件關聯
3.通過不斷的讀寫完成數據存儲
4.關閉資源
*/
import java.io.*;
class CopyText
{
    public static void main(String[] args)
    {
        copy_1();
    }
    //從C盤讀一個字符，就往D盤寫一個字符。
    public static void copy_1()
    {
        FileWriter fw=null;
        FileReader fr=null;
        try
        {
            fr=new FileReader("c:\\test.txt");
            fw=new FileWriter("d:\\test.txt");
            char[] cbuf=new char[1024];
            int len=0;
            //for(len=fr.read(cbuf);len!=-1;len=fr.read(cbuf))
            while((len=fr.read(cbuf))!=-1)
            {
                fw.write(cbuf,0,len);
                System.out.print(new String(cbuf,0,len));
            }
            //fw.flush();
        }
        catch(Exception e)
        {
            e.printStackTrace();
            throw new RuntimeException("讀寫失敗!");
        }
        finally
        {
            try
            {
                if(fw!=null)
                    fw.close();
                if(fr!=null)
                    fr.close();

            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }

    }
}

字符流的緩衝區

• 緩衝區的出現提高了對數據的讀寫效率
  
  • BufferedWriter
  • BufferedReader
• 緩衝區要結合流纔可以使用
• 在流的基礎上對流的功能進行了增前

BufferedWriter

import java.io.*;
class BufferedWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        FileWriter fw=new FileWriter("d:\\test.txt");

        BufferedWriter bufw = new BufferedWriter(fw);
        for(int x=1;x<5;x++)
        {
            bufw.write("abcde"+x);
            bufw.newLine();
            bufw.flush();
        }
        bufw.close();

    }
}

BufferedReader

import java.io.*;

class CopyDemo
{
    public static void main(String[] args) throws Exception
    {
        copy();
    }
    public static void copy() throws Exception
    {
        FileReader fr=new FileReader("C:\\test.txt");
        FileWriter fw=new FileWriter("d:\\test.txt");
        BufferedReader br=new BufferedReader(fr);
        BufferedWriter bw=new BufferedWriter(fw);

        char[] cbuf=new char[1024];
        int num=0;
        while(((num=br.read(cbuf))!=-1))
        {
            bw.write(cbuf,0,num);
        }
        bw.flush();
        br.close();
        bw.close();
    }
}

LineNumberReader

public class LineNumberReader extends BufferedReader
跟蹤行號的緩衝字符輸入流。
此類定義了方法
setLineNumber(int)
getLineNumber()
它們可分別用於設置和獲取當前行號

字節流 FileOutputStream FileInputStream

/*
字符流
FileReader
FileWriter

BufferedReader
BufferedWriter

字節流
InputStream
OutputStream

操作圖片數據，這時就要用到字節流。

*/

import java.io.*;
class OutputStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        //writeFile();
        readFile3();
    }
    public static void readFile3() throws IOException
    {
        FileInputStream fis=new FileInputStream("d:\\tmp.txt");

        int num=fis.available();
        System.out.println("num="+num);
        fis.close();
    }
    public static void readFile2() throws IOException
    {
        FileInputStream fis=new FileInputStream("d:\\tmp.txt");
        byte[] buf=new byte[1024];
        int len=0;
        while((len=fis.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,len));
        }
        fis.close();
    }
    public static void readFile() throws IOException
    {
        FileInputStream fis=new FileInputStream("d:\\tmp.txt");
        int ch=0;
        while((ch=fis.read())!=-1)
        {
            System.out.println((char)ch);
        }
        fis.close();
    }
    public static void writeFile() throws IOException
    {
        FileOutputStream fos=new FileOutputStream("d:\\tmp.txt");
        fos.write("abcde".getBytes());
        fos.close();
    }

}

複製圖片

import java.io.*;

class CopyPic
{
    public static void main(String[] args)
    {
        copyPic();
    }
    public static void copyPic()
    {
        FileInputStream fis=null;
        FileOutputStream fos=null;

        try
        {
            fis=new FileInputStream("c:\\tmp.jpg");
            fos=new FileOutputStream("d:\\tmp.jpg");

            byte[] buf=new byte[1024];
            int num=0;
            while((num=fis.read(buf))!=-1)
            {
                fos.write(buf,0,num);
            }
        }
        catch(IOException e)
        {
            throw new RuntimeException("讀寫文件失敗.");
        }
        finally
        {
            try
            {
                if(fis!=null)
                    fis.close();
            }
            catch(IOException e)
            {
                e.printStackTrace();
            }
            try
            {
                if(fos!=null)
                    fos.close();
            }
            catch(IOException e)
            {
                e.printStackTrace();
            }
        }
    }
}

轉換流，通常，涉及到字符編碼轉換時，需要用到轉換流。

讀取鍵盤錄入,讀取轉換流

System.in
static InputStream in
“標準”輸入流。

import java.io.*;
class TransStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        //獲取鍵盤錄入對象
        InputStream in=System.in;
        //將字節流對象轉成字符流對象，使用轉換流
        InputStreamReader isr=new InputStreamReader(in);
        //爲了提高效率，將字符串進行緩衝區技術高效操作，使用BufferedReader
        BufferedReader br=new BufferedReader(isr);
        String s=br.readLine();
        System.out.println(s.toUpperCase());
        br.close();
    }
}

寫入轉換流

OutputStreamWriter

import java.io.*;
class TransStreamDemo2
{
    public static void main(String[] args) throws IOException
    {
        /* InputStream in=System.in;
        OutputStream ot=System.out;

        InputStreamReader isr=new InputStreamReader(in);
        BufferedReader bufr=new BufferedReader(isr);

        OutputStreamWriter osw=new OutputStreamWriter(ot);
        BufferedWriter bufw=new BufferedWriter(osw); */

        BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));

        BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));
        String line=null;

        while((line=br.readLine())!=null)
        {
            if("over".equals(line))
                break;
            bufw.write(line);
            bufw.newLine();
            bufw.flush();
        }
        bufr.close();
        bufw.close();

    }
}

異常的日誌信息

下載工具 log4j更方便

import java.io.*;
import java.util.*;
import java.text.SimpleDateFormat;
class ExceptionInfo
{
    public static void main(String[] args) throws Exception
    {
        //System.setOut(new PrintStream("d:\\err.log"));
        //BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
        try
        {
            int[] arr=new int[2];
            System.out.println(arr[3]);
        }

        catch(Exception e)
        {
            /* bw.write(e.toString());
            bw.newLine();
            bw.flush(); */
            try
            {
                Date date=new Date();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String s=sdf.format(date);
                PrintStream ps=new PrintStream("d:\\err.log");
                ps.println(s);
                System.setOut(ps);


            }
            catch(IOException ioe)
            {
                throw new RuntimeException("日誌文件創建失敗.");
            }
            e.printStackTrace(System.out);

        }
        //bw.close();
    }
}

系統信息

import java.util.*;
import java.io.*;
class SystemInfo
{
    public static void main(String[] args) throws Exception
    {
        Properties prop = System.getProperties();
        //prop.list(System.out);
        PrintStream ps=new PrintStream("d:\\sysinfo.txt");
        prop.list(ps);
        ps.close();
    }
}