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();
    }
}