16种输入输出流介绍

1.基本概念

（1）16种流介绍

　　                                                   

（2）Input_OutputStream继承结构图

　　　　　　　　

（3）Reader_Writer继承结构图

                                            

2.基本操作

2.1.基本读操作- read()方法

（1）

/*
   java.io.InputStream
       java.io.FileInputStream
       按照字节方式读取
*/
import java.io.*;
class  FileInputStreamtest
{
    public static void main(String[] args) 
    {
        FileInputStream fis = null;
        try{
            //文件路径
         //String filePath="text1.txt";//相对路径，在当前路径下
        // String filePath="D:\Sourcecode\Editplus\java\file\text1.txt";
         String filePath="D:/Sourcecode/Editplus/java/file/text1.txt";
         fis = new FileInputStream(filePath);
         //读
         int i1 = fis.read();//以字节方式读，只能读取一个字母
         System.out.println(i1);//输出字母对应的ASSICK值
        
        }catch(FileNotFoundException e){
           e.printStackTrace();
        }catch(IOException e){
           e.printStackTrace();
        }finally{
        //保证流一定释放，使用try..catch语句
        if(fis!=null){
           try{
             fis.close();
           }catch(IOException e){
             e.printStackTrace();
           }
        }
          
        }
    }
}

（2）

import java.io.*;
class FileInputStreamtest02 
{
    public static void main(String[] args) throws Exception  
    {
        FileInputStream fis = new FileInputStream("text1.txt");
        int temp =0;
        while((temp=fis.read())!=-1){
           System.out.println(temp);
        }
        fis.close();
    }
}

（3）

/*
   int read(byte[] bytes)
   读取之前在内存中准备一个byte数组，每次读取多个字节存储到byte数组中，一次读取多个字节。
   效率高
   text1.txt文件中的内容为abcdefg
*/
import java.io.*;
class FileInputStreamtest03 
{
    public static void main(String[] args) throws Exception
    {
        FileInputStream fis = new FileInputStream("text1.txt");
        byte[] bytes = new byte[3];//每次读3个字节

        int i1 = fis.read(bytes);
        System.out.println(new String(bytes));//abc
        int i2 = fis.read(bytes);
        System.out.println(new String(bytes));//def
        int i3 = fis.read(bytes);
        System.out.println(new String(bytes));//gef
        System.out.println(new String(bytes,0,i3));//g
        int i4 = fis.read(bytes);
      
      //int类型的i表示每次读取的字节数
        System.out.println(i1);//3
        System.out.println(i2);//3
        System.out.println(i3);//1
        System.out.println(i4);//-1

    }
}

（4）

/*
  循环读取
  text1.txt文件中的内容为abcdefg
*/
import java.io.*;
class FileInputStreamtest04 
{
    public static void main(String[] args) throws Exception 
    {
        FileInputStream fis = new FileInputStream("text1.txt");
        byte[] bytes = new byte[1024];//每次读3个字节
         int temp =0;
         while((temp=fis.read(bytes))!=-1){
           System.out.print(new String(bytes,0,temp));
         }
         fis.close();
    }
}

2.2.available()方法和skip()方法

import java.io.*;
/*
  available()方法：返回流中剩余的字节数
  skip(n)方法：跳过n个字节不读取
   text1.txt文件中的内容为abcdefg
*/
class FileInputStreamtest05 
{
    public static void main(String[] args) throws Exception
    {
        FileInputStream fis = new FileInputStream("text1.txt");
        System.out.println(fis.available());//7
        System.out.println(fis.read());//97
        System.out.println(fis.available());//6
        fis.skip(2);//跳过两个字节不读取
         System.out.println(fis.read());//100
        fis.close();
        
    }
}

2.3.写入数据的方法

/*
  java.io.OutputStream
    java.io.FileOutputStream;文件字节输出流
    将计算机内存中的数据写入硬盘文件中
*/
import java.io.*;
class  FileOutputStreamtest01
{
    public static void main(String[] args) 
    {
         FileOutputStream fos=null;
        try{
           //fos= new FileOutputStream("text2.txt");//多次运行，会覆盖源文件内容
           fos= new FileOutputStream("text2.txt",true);//追加写入
          //写入
          String msg = "Hello World";
          //将String转换成byte数组
          byte[] bytes = msg.getBytes();
          fos.flush();//强制写入，保证数据完全写入硬盘，与、需要刷新
          //fos.write(bytes);//强制写入,写入全部
          fos.write(bytes,0,3);//写入3个,将byte数组部分写入

        }catch(Exception e){
          e.printStackTrace();
        }finally{
            if(fos!=null){
               try{
                 fos.close();
               }catch(Exception e){
                 e.printStackTrace();
               }
            }
           
        }
    }
}

2.4.文件的复制粘贴

　　FileInputStream  FileOutputStream

/*
   文件的复制粘贴
*/
import java.io.*;
class Copy01 
{
    public static void main(String[] args) throws Exception
    {
        FileInputStream fis = new FileInputStream("text1.txt");
        FileOutputStream fos = new FileOutputStream("text2.txt");
        //读，写
        byte[] bytes = new byte[1024];
        int temp = 0;
        while((temp=fis.read(bytes))!=-1){
          fos.write(bytes,0,temp);
        }
        fis.close();
        fos.close();

    }
}

　　fileReader,FileWriter

/*
 文件复制,只能复制纯文本文件
*/
import java.io.*;
class  Copy02
{
    public static void main(String[] args) throws Exception
    {
        FileReader fr = new FileReader("text1.txt");//一个已经存在的文件
        FileWriter fw = new FileWriter("text4.txt");//运行后复制出一个文件
        char [] chars = new char[1024];
        int temp =0;
        while((temp=fr.read(chars)) != -1){
          fw.write(chars,0,temp);
        }
        fw.flush();
        fr.close();
        fw.close();
    }
}

2.5.FileWriter()方法写入文件

/*
    java.io.Writer;
      java.io.OutputStream;转换流
        java.io.FileWriter文件字符输出流
*/
import java.io.*;
class FileWritertest01 
{
    public static void main(String[] args) throws Exception
    {
        FileWriter fw = new FileWriter("text3.txt",true);
         fw.write("写入文件");//直接写入字符串
         char [] chars = {'写','入','文','件','{','。','、',};
         fw.write(chars,0,6);
         fw.flush();
        fw.close();
    }
}
/*
运行结果：
写入文件写入文件{。
*/

2.6.BufferedReader带有缓冲区的字符输入流

/*
  readLine() 方法一次读取一行文本
*/
import java.io.*;
class  BufferedReadertest01
{
    public static void main(String[] args) throws Exception
    {
        BufferedReader br = new BufferedReader(new FileReader("BufferedReadertest01.java"));
        String temp = null;
        while((temp=br.readLine())!=null){
          System.out.println(temp);
        }
        br.close();
    }
}

/*
  readLine() 方法一次读取一行文本
*/
import java.io.*;
class  BufferedReadertest02
{
    public static void main(String[] args) throws Exception
    {
        FileInputStream fis = new FileInputStream("BufferedReadertest01.java");//文件字节输入流
        InputStreamReader brs = new InputStreamReader(fis); //将字节流转换成字符流
        BufferedReader br = new BufferedReader(brs);//brs是字符流
       //将上面的语句合并
     //  BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("BufferedReadertest01.java")));
        String temp = null;
        while((temp=br.readLine())!=null){
          System.out.println(temp);
        }
        br.close();
    }
}

3.文件输入/输出流

1.FileinputStream 与FileOutputStream类将文件读出与写入。

2.FileReader和FileWriter将文件读出与写入。

　　二者的区别：

　　使用FileOutputStream类向文件中写入数据与使用FileinputStream类从文件中将内容读出来都存在一点不足，即这两个类都只有提供了对字节或字节数组的读取方法，由于汉子在文件中占用两个字节，如果使用字节流，读取不好可能会出现乱码的情况，此时采用字符流Reader或Writer类即可避免这种现象。

　　FileReader和FileWriter字符流对应了FileinputStream 与FileOutputStream类，FileReader流顺序地读取文件，只要不关闭流，每次调用read（）方法就顺序地读取源文件中其余内容，直到源的末尾或流被关闭。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileTest3 {
     
    public static void main(String[] args) {
       File file = new File("D:/Sourcecode/Java/file/word1.txt");
       try{
           FileOutputStream out = new FileOutputStream(file);
           byte buy[]  ="风住尘香花已尽，日晚倦梳头。物是人非事事休，欲语泪先流。".getBytes();
           out.write(buy);
           out.close();
       }catch(Exception e){
           e.printStackTrace();
       }
       try{
           FileInputStream inputStream = new FileInputStream(file);
           byte byt[] = new byte[1024];
           int len  =inputStream.read(byt);
           System.out.print("文件中的信息是： "+ new String(byt,0,len));
           inputStream.close();
       }catch(Exception e){
           e.printStackTrace();
       }
    }

}

import java.awt.*;
import java.awt.event.*;
import java.io.*;

import javax.swing.*;

public class Ftest extends JFrame { // 创建类，继承Jframe类
    private JScrollPane scrollPane;
    private static final long serialVersionUID = 1L;
    private JPanel jContentPane = null; // 创建面板对象
    private JTextArea jTextArea = null; // 创建文本域对象
    private JPanel controlPanel = null; // 创建面板对象
    private JButton openButton = null; // 创建按钮对象
    private JButton closeButton = null; // 创建按钮对象
    
    private JTextArea getJTextArea() {
        if (jTextArea == null) {
            jTextArea = new JTextArea();
        }
        return jTextArea;
    }
    
    private JPanel getControlPanel() {
        if (controlPanel == null) {
            FlowLayout flowLayout = new FlowLayout();
            flowLayout.setVgap(1);
            controlPanel = new JPanel();
            controlPanel.setLayout(flowLayout);
            controlPanel.add(getOpenButton(), null);
            controlPanel.add(getCloseButton(), null);
        }
        return controlPanel;
    }
    
    private JButton getOpenButton() {
        if (openButton == null) {
            openButton = new JButton();
            openButton.setText("写入文件"); // 修改按钮的提示信息
            openButton
                    .addActionListener(new java.awt.event.ActionListener() {
                        // 按钮的单击事件
                        public void actionPerformed(ActionEvent e) {
                            // 创建文件对象
                            File file = new File("word.txt");
                            try {
                                // 创建FileWriter对象
                                FileWriter out = new FileWriter(file);
                                // 获取文本域中文本
                                String s = jTextArea.getText();
                                out.write(s); // 将信息写入磁盘文件
                                out.close(); // 将流关闭
                            } catch (Exception e1) {
                                e1.printStackTrace();
                            }
                        }
                    });
        }
        return openButton;
    }
    
    private JButton getCloseButton() {
        if (closeButton == null) {
            closeButton = new JButton();
            closeButton.setText("读取文件"); // 修改按钮的提示信息
            closeButton
                    .addActionListener(new java.awt.event.ActionListener() {
                        // 按钮的单击事件
                        public void actionPerformed(ActionEvent e) {
                            File file = new File("word.txt"); // 创建文件对象
                            try {
                                // 创建FileReader对象
                                FileReader in = new FileReader(file);
                                char byt[] = new char[1024]; // 创建char型数组
                                int len = in.read(byt); // 将字节读入数组
                                // 设置文本域的显示信息
                                jTextArea.setText(new String(byt, 0, len));
                                in.close(); // 关闭流
                            } catch (Exception e1) {
                                e1.printStackTrace();
                            }
                        }
                    });
        }
        return closeButton;
    }
    
    public Ftest() {
        super();
        initialize();
    }
    
    private void initialize() {
        this.setSize(300, 200);
        this.setContentPane(getJContentPane());
        this.setTitle("JFrame");
    }
    
    private JPanel getJContentPane() {
        if (jContentPane == null) {
            jContentPane = new JPanel();
            jContentPane.setLayout(new BorderLayout());
            jContentPane.add(getScrollPane(), BorderLayout.CENTER);
            jContentPane.add(getControlPanel(), BorderLayout.SOUTH);
        }
        return jContentPane;
    }
    
    public static void main(String[] args) { // 主方法
        Ftest thisClass = new Ftest(); // 创建本类对象
        thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        thisClass.setVisible(true); // 设置该窗体为显示状态
    }
    /**
     * @return
     */
    protected JScrollPane getScrollPane() {
        if (scrollPane == null) {
            scrollPane = new JScrollPane();
            scrollPane.setViewportView(getJTextArea());
        }
        return scrollPane;
    }
}

4.带缓存的输入输出流

　　由于Java中的字符是Unicode编码，是双字节的，writeBytes只是将字符串中的每一个字符的低字节内容写入目标设备中，而writeChars将字符串的每一个字符的两个字节的内容都写到目标设备中，WriterUTF将字符串按照UTF编码后的字节长度写入目标设备，然后才是每一字节的UTF编码。

　　DataInputStream类只提供了一个readUTF（）方法返回字符串，这是因为要在一个连续的字节流读取一个字符串，如果没有特殊的标记作为一个字符串的结尾，并且不知道这个字符串的长度，就无法知道读取到什么位置才是这个字符串的结束，DataOutputStream类中只有writeUTF（）方法向目标设备中写入字符串的长度，所以也能准确的读回写入的字符串。

例：

public class Dataintandout {

    public static void main(String[] args) {
        try{
            //创建FileOutputStream对象
            FileOutputStream fStream = new FileOutputStream("D:/Sourcecode/Java/file/word4.txt");
            //创建DataOutputStream对象
            DataOutputStream dStream = new DataOutputStream(fStream);
            dStream.writeUTF("使用writeUTF()方法写入数据：不是无心惜落花，落花无意恋春花");
            dStream.writeChars("使用writeChars()方法写入数据：今朝春去谁家落，把酒临风千种恨");
            dStream.writeBytes("使用writeBytes()方法写入数据：昨日寒鸦一片愁，柳塘新绿却温柔");
            dStream.close();
            //创建FileInputStream对象
        FileInputStream fileInputStream = new FileInputStream("D:/Sourcecode/Java/file/word4.txt");
        //创建DataInputStream对象
        DataInputStream dataInputStream = new DataInputStream(fileInputStream);
        System.out.println(dataInputStream.readUTF());//将文件输出
        }catch(Exception e){
            e.printStackTrace();
        }
    }

}

　　运行结果：使用writeUTF()方法写入数据：不是无心惜落花，落花无意恋春花

　　打开文本内容如下：

       

　　尽管在记事本中出现乱码的情况，但在控制台屏幕上仍然能正确显示内容。但如果使用writeChars（）方法和writeBytes（）方法写入字符串，就不能正确读出。

　　带缓存的输入输出流

　　缓存是I/o的一种性能优化，带缓存为I/o流增加了内存缓存区，有了缓存区，使得在流上执行skip（），mark（），reset（）方法成为可能。

4.1.BufferedinputStream与BufferedOutputStream类

1. BufferedinputStream有两种构造方法：

　　（1）BufferedinputStream（inputStream in）

　　（2）BufferedinputStream(inputStream in,int size)

　　第一种形式的构造方法创建了一个带有32个字节的缓存流，第二种形式的构造方法按指定的大小来创建缓存区。一个最优的缓存区的大小，取决于它所在的操作系统，可用的内存空间以及机器配置。从构造方法可以看出，BufferedinputStream对象位于InputStream类对象之前

 2.BufferedOutputStream类有两种构造方法

　　（1）BufferedOutputStream（OutputStream in）

　　（2）BufferedOutputStream（OutputStream in，int size）

　　第一种构造方法创建了一个有32个字节的缓存区域，第二种构造方法以指定的大小来创建缓存区

　　注意：flush()方法是用于即使在缓存区域没有存满的情况下，也将缓存区的内容强制写入到外设，习惯上称这个过程为刷新，flush（）方法只对使用缓存区的OutputStream类的子类有效，当调用close（）方法时，系统在关闭之前，也将缓存区中的信息刷新到磁盘文件中。

4.2.BufferedReader与BufferedWriter类

　　BufferedReader类常用的方法如下。

　　（1）read()方法：读取单个字符。

　　（2）readLine（）方法：读取一个文本行，并将其返回为字符串。若无数据可读，则返回null。BufferedWriter类中的方法都返回void，常用的方法如下：

　　　　a、 write（String s，int off， int len）方法：写入字符串的某一部分。

　　　　b、flush（）方法：刷新该流得缓存。

　　　　c、newline（）方法：写入一个行分隔符。

 　　例：

package file;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;

public class Student {
   public static void main(String []args){
       String contet[] = {"夜夜思君情断肠，缘何人不双，夜夜痴迷空自伤，月随人彷徨"};
       //创建文件对象
       File file = new File("D:/Sourcecode/Java/file/word2.txt");
       try{
           //创建FileWriter类对象
           FileWriter fw = new FileWriter(file);
           //创建bufferWriter类对象
           BufferedWriter buffw  = new BufferedWriter(fw);
           for(int k = 0;k < contet.length;k++){
               buffw.write(contet[k]);//将字符串数组中的元素写入到磁盘文件中
               buffw.newLine();//将数组中的单个元素以单行的形式写入文件
           }
           buffw.close();    //将BufferReader流关闭
           fw.close();       //将FileWriter流关闭
       }catch(Exception e){
           e.printStackTrace();
       }
       try{
           //创建FileReader类对象
           FileReader fr = new FileReader(file);
           //创建BufferReader类对象
           BufferedReader bufr = new BufferedReader(fr);
           String s = null;//创建字符串对象
           int i = 0;    
           //如果文件文本行数不为空，则进入循环
           while((s = bufr.readLine()) != null){
               i++;
               System.out.println("第"+i+"行"+s);
           }
           bufr.close();
           fr.close();
           
       }catch(Exception e){
           e.printStackTrace();
       }
   }
}

　　运行结果：

　　第1行夜夜思君情断肠，缘何人不双，
　　第2行夜夜痴迷空自伤，月随人彷徨

5.序列化和反序列化-对象流

5.1.序列化-ObjectOutputStream

　　序列化就是将堆中的Java对象存入到硬盘中。

import java.io.Serializable;//可序列化的，没有任何方法的标识接口
class  User implements Serializable
{
    String name;
    User(String name){
      this.name = name;
    }
    public String toString(){
      return "User[name="+name+"]";
    }
}

　　注：  User 实现了 Serializable  接口， JVM会给该类添加自动一个属性：序列化版本号。（可以自定义一个序列化版本号，则系统不会再成序列化版本号，

也不会出现版本号不相同的情况）

　　例：自定义序列化版本号

static final long seriaVersionUID="xxxxxxxxx";

　　如果不让某个属性参与序列化，可以使用transient关键字修饰;

transient String name;

/*
   java.io.ObjectOutputStream;序列化Java对象到硬盘
   java.io.ObjectInputStream;将硬盘中的数据反序列化到jvm内存
*/
import java.io.*;
class  ObjectOutputStreamtest01
{
    public static void main(String[] args) throws Exception 
    {
        //创建Java对象
        User u1 = new User("Java对象");
        //创建输出流（序列化流）jvm中的java对象状态保存到硬盘中
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("text6.txt"));
        //写
        oos.writeObject(u1);
        oos.flush();
        oos.close();
    }
}

5.2.反序列化-ObjectInputStream

　　反序列化就是将硬盘中的对象恢复到内存中。

/*
   反序列化
*/
import java.io.*;
class  ObjectInputStreamtest01
{
    public static void main(String[] args) throws Exception
    {
        //创建反序列化流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("text6.txt"));
        //反序列化
        Object o = ois.readObject();
        System.out.println(o);
        ois.close();
    }
}
/*
User[name=Java对象]
请按任意键继续. . .
*/

6.File

6.1.特点

　　Java.io.File;File类和流无关，不能通过该类完成文件的读和写，File是文件和目录路径名的抽象表示形式，File代表的是硬盘上的文件夹和文件名。

6.2.常用方法

import java.io.*;
/*
   判断指定路径或文件是否存在，不存在则创建
*/
class Filetest01 
{
    public static void main(String[] args) throws Exception 
    {
        //相对路径
        File f1 = new File("text1.txt");
        //绝对路径
        File f2 = new File("D:\Sourcecode\Editplus\java");
        
        System.out.println(f1.exists());//true
        System.out.println(f2.exists());//true

        File f3 = new File("D:\Sourcecode\Editplus\java\AA");
        System.out.println(f3.exists());//false
       //如果不存在则创建
       if(!f3.exists()){
         //创建目录
         //f3.mkdir();
         //创建文件
         f3.createNewFile();
       }
       File f4 = new File("D:/a/b/c");
       if(!f4.exists()){
         //创建多重目录
         f4.mkdirs();
       }
    }
}