java IO流_1

目录

分类

字节流

InputStream

OutputStream

文件拷贝

字符流

FileReader

FileWriter

处理流

BufferedReader

BufferedWriter

文本拷贝

---

        流是从起源到接受的有序数据，通过流的方式允许程序使用相同的方式来访问不同的输入/输出源。        

分类

按数据单位分：字节流(二进制文件)        字符流(文本文件）

按数据流向分：输入流        输出流

按流的角色分：节点流        处理流 

IO流的40多个类都是由这四个抽象基类派生的

字节流

InputStream

常用子类：

1. FileInputStream        文件输入流
2. BufferedInputStream          缓冲字节输入流
3. ObjectInputStream        对象字节输入流             

import java.io.FileInputStream;

public class FileInputStream_ {
    public static void main(String[] args) {
        readFile01();
        System.out.println();
        readFile02();
    }
    public static void readFile01(){
        String path="D:\\javacode\\IO\\src\\test.txt";
        int read;
        FileInputStream fis=null;
        try {
            fis=new FileInputStream(path);
            while((read=fis.read())!=-1)//读取一个字节的数据，读到末尾返回-1
            {
                System.out.print((char)read);//一个一个读
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                fis.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    public static void readFile02(){
        String path="D:\\javacode\\IO\\src\\test.txt";
        byte[] buf=new byte[8];
        FileInputStream fis=null;
        int len;
        try {
            fis=new FileInputStream(path);
            while((len=fis.read(buf))!=-1)//读取一个字节的数据，读到末尾返回-1
            {
                System.out.print((new String(buf,0,len)));//一次最多读入buf.length字节的数据，存入字节数组buf
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                fis.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

OutputStream

子类：FileOutputStream

import java.io.FileOutputStream;

public class FileOutputStream_ {
    public static void main(String[] args) {
        writeFile01();
    }
    public static void writeFile01(){
        String path="D:\\javacode\\IO\\src\\test.txt";
        FileOutputStream fos=null;
        try {
            //fos=new FileOutputStream(path);//覆写
            fos=new FileOutputStream(path,true);//加true,追加文本
            fos.write('6');
            fos.write("helloworld".getBytes());//获取str对应的字节数组
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                fos.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

#字节流中文会乱码，这是因为只能存一个字节一个字节输出 

文件拷贝

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

public class FileCopy {
    public static void main(String[] args) {
        //文件拷贝
        FileInputStream fileInputStream=null;//输入流
        FileOutputStream fileOutputStream=null;//输出流
        //源文件和目标文件
        String srcpath="C:\\Users\\Elysia\\Pictures\\Saved Pictures\\illust_86465238_20210124_003335.jpg";
        String destpath="D:\\javacode\\IO\\src\\pic.jpg";
        try {
            fileOutputStream=new FileOutputStream(destpath,true);
            fileInputStream=new FileInputStream(srcpath);
            byte[] buf=new byte[1024];
            int len;
            while((len=fileInputStream.read(buf))!=-1){
                fileOutputStream.write(buf,0,len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                fileOutputStream.close();
                fileInputStream.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

字符流

FileReader

import java.io.FileReader;

public class FileReader_ {
    public static void main(String[] args) {
        FileReader fileReader=null;
        String path="D:\\javacode\\IO\\src\\test.txt";
        try {
            fileReader=new FileReader(path);
            char[] buf=new char[8];//用char接收
            int len;
            while((len=fileReader.read(buf))!=-1){
                System.out.print(new String(buf,0,len));
            }
//            int read;//单个读取
//            while((read= fileReader.read())!=-1){
//                System.out.print((char)read);
//            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                fileReader.close();//关闭文件
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

FileWriter

import java.io.FileWriter;

public class FileWriter_ {
    public static void main(String[] args) {
        FileWriter fileWriter=null;
        String path="D:\\javacode\\IO\\src\\test.txt";
        try{
            fileWriter=new FileWriter(path,true);//加true表示追加
            fileWriter.write("\n成功写入");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                fileWriter.close();//必须 一定 关闭流，才能真正的写入
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

必须 一定 关闭/flush流，才能真正的写入

 

处理流

        将“流”包装，在其之上为程序提供更强大的读写功能

 节点流的数据源是特定的，而处理流则利用了向上转型，可以封装多种“流”，减小了节点流之间的差异。

优势：

1. 使用处理流进行 读写操作更简单
2. 处理流增加了缓冲，提高效率 

#在关闭包装流的时候，会自动关闭里面封装的字节流

BufferedReader

        从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。

import java.io.BufferedReader;
import java.io.FileReader;

public class BufferedReader_ {
    public static void main(String[] args) throws Exception{
        String path="D:\\javacode\\IO\\src\\test.txt";
        BufferedReader bufferedReader=new BufferedReader(new FileReader(path));
        String line;//按行读取，效率高
        while((line=bufferedReader.readLine())!=null){
            System.out.println(line);//读取一行
        }
        bufferedReader.close();//只需要关闭包装流
    }
}

BufferedWriter

        文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。

import java.io.BufferedWriter;
import java.io.FileWriter;

public class BufferedWriter_ {
    public static void main(String[] args) throws Exception{
        String path="D:\\javacode\\IO\\src\\test.txt";
        BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter(path,true));
        bufferedWriter.newLine();//插入一个换行
        bufferedWriter.write("成功写入");
        bufferedWriter.close();
    }
}

文本拷贝

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

public class TxtCopy {
    public static void main(String[] args) throws Exception{
        String dest="D:\\javacode\\IO\\src\\dest.txt";
        String src="D:\\javacode\\IO\\src\\test.txt";
        BufferedReader bufferedReader=new BufferedReader(new FileReader(src));
        BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter(dest));
        String line;
        while((line=bufferedReader.readLine())!=null){
            bufferedWriter.write(line);//末尾没有换行符
            bufferedWriter.newLine();//每读取一行，插入换行符
        }
        bufferedWriter.close();
        bufferedReader.close();
    }
}