黑马程序员——java io流概述

----------------------------android培训    java培训      期待与您交流！ -----------------

 IO流用来处理设备之间的数据传输。

Java对数据的操作是通过流的方式，操作流的对象都在IO包中。按照数据流的方向不同可以分为输入流和输出流；按照处理数据单位不同可以分为字节流和字符流；按照实现功能不同可以分为节点流和处理流。

字节流和字符流的原理是相同的，只不过处理的单位不同而已。字节流一次读入或读出是8位二进制。字符流一次读入或读出是16位二进制。后缀是Stream是字节流，而后缀是Reader，Writer是字符流，

流继承了InputStream(字节输入流)，OutputStream（字节输出流），Reader（字符输入流），Writer（字符输出流）四大类。

例如InputStream的子类FileInputStream。

例如Reader的子类FileReader。

对文件进行操作：FileInputStream（字节输入流），FileOutputStream（字节输出流），FileReader（字符输入流），FileWriter（字符输出流）

对管道进行操作：PipedInputStream（字节输入流）,PipedOutStream（字节输出流），PipedReader（字符输入流），PipedWriter（字符输出流）PipedInputStream的一个实例要和PipedOutputStream的一个实例共同使用，共同完成管道的读取写入操作。主要用于线程操作。

字节/字符数组：ByteArrayInputStream，ByteArrayOutputStream，CharArrayReader，CharArrayWriter是在内存中开辟了一个字节或字符数组。

Buffered缓冲流：：BufferedInputStream，BufferedOutputStream，BufferedReader,BufferedWriter,是带缓冲区的处理流，缓冲区的作用的主要目的是：避免每次和硬盘打交道，提高数据访问的效率。

转化流：InputStreamReader/OutputStreamWriter，把字节转化成字符。

数据流：DataInputStream，DataOutputStream。

打印流：printStream，printWriter，一般是打印到控制台，可以进行控制打印的地方。

对象流：ObjectInputStream，ObjectOutputStream，把封装的对象直接输出，而不是一个个在转换成字符串再输出。使用对象流需要实现Serializable接口，否则会报错。

序列化流：SequenceInputStream。

对象序列化：把对象直接转换成二进制，写入介质中。

 （注意）

 对于io流，我们选择使用流的步骤是先看源，再看属于字节流还是字符流！！！！！！

下面我们用文件字节流上传张图片。

代码如下：

import java.io.*;
public class CopyPicture {
    public static void main(String[] args) {
        FileOutputStream fos=null;
        FileInputStream fis=null;
        try {
             fos=new FileOutputStream(
                    "2.jpg");
             fis=new FileInputStream("1.jpg");
             //定义一个数组
             byte[]  buf=new byte[1024];
             int len=0;
             //往输入流里传送数据
             while((len=fis.read(buf))!=-1){
                 fos.write(buf,0,len);
             }
             System.out.println("nnnnnnnnnnnn");
             
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            System.out.println("文件找不到");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            System.out.println("文件复制失败");
        }
        finally{
            //如果输入流不为空，必须关闭
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    System.out.println("关闭输入流失败");
                }
            }
            //如果输出流不为空，必须关闭
            if(fis!=null){
                try {
                        fis.close();
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        System.out.println("关闭输出流失败");
                    }
                }
            }
        }
}

下面用一下用转换流

import java.io.*;
public class trans {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
        String str=null;
        try {
            while((str=br.readLine())!=null){
                bw.write(str);
                bw.newLine();
                bw.flush();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            System.out.println("输出失败");
        }finally{
            try {
                bw.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                System.out.println("关闭流失败");
            }
        }
    }
}

 我们再用一下对象流（使用对象流需要实现Serializable接口，否则会报错。）

import java.io.*;
public class ObjectStreamDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        writeObject();
        readObject();
    }
    private static void readObject() {
        // TODO Auto-generated method stub
        try {
            ObjectInputStream os=new ObjectInputStream(new  FileInputStream("obj.txt"));
            person11 p=(person11) os.readObject();
            System.out.println(p.getAge());
            os.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    private static void writeObject() {
        // TODO Auto-generated method stub
        try {
            ObjectOutputStream  ops=new ObjectOutputStream(new FileOutputStream("obj.txt") );
            ops.writeObject(new person11("lilei",30));
            ops.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
    
}
class person11 implements Serializable{
    private  String  name;
    private  int age;
    person11(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
}