Java输入输出流

一.输入输出流

　　流：流就是指一连串流动的字符，以先进先出的方式发送信息的通道。

　　输出流：写数据。

　　输入流：读数据。

二.File类

　　1.构造方法：

构造方法摘要

File(File parent, String child) 
          根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。

File(String pathname) 
          通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

File(String parent, String child) 
          根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

File(URI uri) 
          通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。

 　　2.主要成员方法：

方法摘要
boolean	canExecute()            测试应用程序是否可以执行此抽象路径名表示的文件。
boolean	canRead()            测试应用程序是否可以读取此抽象路径名表示的文件。
boolean	canWrite()            测试应用程序是否可以修改此抽象路径名表示的文件。
int	compareTo(File pathname)            按字母顺序比较两个抽象路径名。
boolean	createNewFile()            当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
boolean	equals(Object obj)            测试此抽象路径名与给定对象是否相等。
boolean	exists()            测试此抽象路径名表示的文件或目录是否存在。
String	getName()            返回由此抽象路径名表示的文件或目录的名称。
String	getParent()            返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
File	getParentFile()            返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。
String	getPath()            将此抽象路径名转换为一个路径名字符串。
long	getTotalSpace()            返回此抽象路径名指定的分区大小。
long	getUsableSpace()            返回此抽象路径名指定的分区上可用于此虚拟机的字节数。
int	hashCode()            计算此抽象路径名的哈希码。
boolean	isAbsolute()            测试此抽象路径名是否为绝对路径名。
boolean	isDirectory()            测试此抽象路径名表示的文件是否是一个目录。
boolean	isFile()            测试此抽象路径名表示的文件是否是一个标准文件。
boolean	isHidden()            测试此抽象路径名指定的文件是否是一个隐藏文件。
long	lastModified()            返回此抽象路径名表示的文件最后一次被修改的时间。
long	length()            返回由此抽象路径名表示的文件的长度。
String[]	list()            返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
String[]	list(FilenameFilter filter)            返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[]	listFiles()            返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
File[]	listFiles(FileFilter filter)            返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[]	listFiles(FilenameFilter filter)            返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
boolean	mkdir()            创建此抽象路径名指定的目录。
boolean	mkdirs()            创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
String	toString()            返回此抽象路径名的路径名字符串。

 例：

package com.swpu;

import java.io.File;
import java.io.IOException;

public class FileDemo {
    public static void main(String[] args) {
        // 创建File对象
        // 注Linux中目录为/，Windows中为\
        // File file=new File("G:\io\test.txt");
        // File file=new File("G:\io","test.txt");
        File file = new File("G:\io");
        File file1 = new File(file, "test.txt");
        System.out.println("是否是文件夹" + file.isDirectory());
        System.out.println("是否是文件：" + file.isFile());
        // 创建文件
        File file2 = new File("G:\io", "new");
        if (!file2.exists()) {
            file2.mkdir();
            // 创建多级目录
            // file2.mkdirs();
        }
        // 创建文件
        if (!file1.exists()) {
            try {
                file1.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

 三.字节字符流

　　1.字节输入流（InputStream）：

　　　　1.1InputStream：

　　　　　　成员方法：

方法摘要
int	available()            返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。
void	close()            关闭此输入流并释放与该流关联的所有系统资源。
void	mark(int readlimit)            在此输入流中标记当前的位置。
boolean	markSupported()            测试此输入流是否支持 mark 和 reset 方法。
abstract  int	read()            从输入流中读取数据的下一个字节。
int	read(byte[] b)            从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。如果返回值为-1，则表示已经达到文件末尾。
int	read(byte[] b, int off, int len)            将输入流中最多 len 个数据字节读入 byte 数组。
void	reset()            将此流重新定位到最后一次对此输入流调用 mark 方法时的位置。
long	skip(long n)            跳过和丢弃此输入流中数据的 n 个字节。

　　　　例：

package com.swpu;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputDemo {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("G:\io\test.txt");
            //int n=fis.read();
            int n=0;
//            while (n!=-1){
//            System.out.print((char)n);
//            n=fis.read();
//            }
            //一个一个读
            while((n=fis.read())!=-1){
                System.out.print((char)n);
            }
            //fis.close();
            //利用数组读取
            byte[] b=new byte[100];
            fis.read(b,0,5);
            System.out.println(new String(b));
            fis.close();
            

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

　　2.字节输出流（OutputStream）：

 　　　　成员方法：

方法摘要
void	close()            关闭此输出流并释放与此流有关的所有系统资源。
void	flush()            刷新此输出流并强制写出所有缓冲的输出字节。
void	write(byte[] b)            将 b.length 个字节从指定的 byte 数组写入此输出流。
void	write(byte[] b, int off, int len)            将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
abstract  void	write(int b)            将指定的字节写入此输出流。

package com.swpu;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            //true参数，表示在后面追加
            FileOutputStream fos=new FileOutputStream("G:\io\test.txt",true);
            fos.write(10);
            fos.write('h');
            fos.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch(IOException e){
            e.printStackTrace();
        }
        

    }

}

package com.swpu;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopy {

    public static void main(String[] args) {
        // 文件拷贝
        try {
            FileInputStream fis = new FileInputStream("test.png");
            FileOutputStream fos = new FileOutputStream("testcopy.png");
            int n = 0;
            byte[] b = new byte[1024];
            //可能复制的文件更大，因为最后一次可能没有1024
            while ((n = fis.read(b)) != -1) {
                //fos.write(b);
                //n就是实际读的字节数
                fos.write(b,0,n);
            }
            fis.close();
            fos.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch(IOException e){
            e.printStackTrace();
        }

    }

}

 　　3.缓冲流：(提高性能)　　

　　　　BufferedInputStream:　

　　　　　　BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。　

　　　　BufferedOutputStream：

　　　　　　该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。

package com.swpu;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferFileDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        FileOutputStream fos;
        try {
            fos = new FileOutputStream("test.txt");
            BufferedOutputStream bos=new BufferedOutputStream(fos);
            FileInputStream fis=new FileInputStream("test.txt");
            BufferedInputStream bis=new BufferedInputStream(fis);
            bos.write('h');
            bos.write(22);
            //flush()，close()任意一个方法，强制清空缓冲区（缓冲区未满），写入文件
            bos.flush();
            System.out.println(bis.read());
            System.out.println((char)bis.read());
            fos.close();
            bos.close();
            fis.close();
            bis.close();

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (IOException e){
            e.printStackTrace();
        }

    }

}

　　4.字符流：

　　　　4.1字符输入流：

　　　　4.2字符输出流：

 　　　　4.3字节流和字符流的区别： 　　

　　　　　　用途不同　https://blog.csdn.net/lwang_it/article/details/78886186

　　　　4.4字节字符转换流：

　　　　　　注保持读写数据编码一致，防止乱码。

package com.swpu;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class ReaderDemo {

    public static void main(String[] args) {
        try {
            //注读写数据时要保证编码一致，防止乱码
            FileInputStream fis=new FileInputStream("test.txt");
            InputStreamReader isr=new InputStreamReader(fis); 
            FileOutputStream fos=new FileOutputStream("test2.txt");
            OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");
            int n=0;
            char[] cbuf=new char[10];
//            while((n=fis.read())!=-1){
//                System.out.println((char)n);
//            }
            while((n=isr.read(cbuf))!=-1){
                String str=new String(cbuf,0,n);
                System.out.println(str);
                osw.write(cbuf,0,n);
                osw.flush();
            }
            fis.close();
            fos.close();
            isr.close();
            osw.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch(IOException e){
            e.printStackTrace();
        }
    }

}

 　　　   4.5字符缓冲流：

　　　　　　（1）BufferedReader()：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

　　　　　　（2）BufferedWriter():将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

package com.swpu;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class ReaderDemo {

    public static void main(String[] args) {
        try {
            //注读写数据时要保证编码一致，防止乱码
            FileInputStream fis=new FileInputStream("test.txt");
            InputStreamReader isr=new InputStreamReader(fis); 
            BufferedReader br=new BufferedReader(isr);
            FileOutputStream fos=new FileOutputStream("test2.txt");
            OutputStreamWriter osw=new OutputStreamWriter(fos);
            BufferedWriter bw=new BufferedWriter(osw);
            int n=0;
            char[] cbuf=new char[10];
//            while((n=fis.read())!=-1){
//                System.out.println((char)n);
//            }
            while((n=br.read(cbuf))!=-1){
                String str=new String(cbuf,0,n);
                System.out.println(str);
                bw.write(cbuf,0,n);
                bw.flush();
            }
            fis.close();
            fos.close();
            isr.close();
            osw.close();
            br.close();
            bw.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch(IOException e){
            e.printStackTrace();
        }
    }

}

四.序列化

　　1.ObjectOutputStream 和 ObjectInputStream：

　　　　ObjectOutputStream 和 ObjectInputStream 分别与 FileOutputStream 和 FileInputStream 一起使用时，可以为应用程序提供对对象图形的持久存储。ObjectInputStream 用于恢复那些以前序列化的对象。其他用途包括使用套接字流在主机之间传递对象，或者用于编组和解组远程通信系统中的实参和形参。

　　　　

package com.swpu;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
//实现Serializable接口（序列化接口）
class Good implements Serializable{
    String num;
    String name;
    float price;
    public Good(String num,String name,float price){
        this.num=num;
        this.name=name;
        this.price=price;
    }
    public String getNum() {
        return num;
    }
    public void setNum(String num) {
        this.num = num;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public float getPrice() {
        return price;
    }
    public void setPrice(float price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Good: ["+"num:"+num+",name:"+name+",price:"+price+"]";
    }
    
}
public class FileStreamDemo {

    public static void main(String[] args) {
        Good good=new Good("k1212","手机",2000);
        FileOutputStream fos;
        try {
            fos = new FileOutputStream("test.txt");
            ObjectOutputStream oos=new ObjectOutputStream(fos);
            FileInputStream fis=new FileInputStream("test.txt");
            ObjectInputStream ois=new ObjectInputStream(fis);
            //注意读的顺序和写的顺序要一致
            oos.writeObject(good);
            oos.writeBoolean(true);
            oos.flush();
            try {
                Good goodaf=(Good)ois.readObject();
                System.out.println(goodaf);
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            fos.close();
            fis.close();
            oos.close();
            ois.close();

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }

}