IO

• 文件专属
• • FileInputStream-FileOutputStream
  • FileReader-FileWriter
• 转化流
• 缓冲流BufferedWriter-BufferedReader
• 数据流专属
• 标准输出流
• File类
• 文件拷贝

文件专属

java.io.FileInputStream;

java.io.FileOutputStream;


java.io.FileReader;

java.io.FileWriter;

要自行构造基本数据类型数组，来进行读写，如char[] int[]
前面两个有Stream的是对字节做处理，可以处理文本文档（所有能被写字板打开的文件）、照片、视频、音频等。
要注意的一点是Stream在写入一个文件时，要将文件目录到具体文件名，不然将会拒绝访问

然后每次对文件进行处理如写入新的内容时，要对文件进行刷新——.flush()
在try语句中，最后要在finally处判断文件是否为空，不为空时要将文件关闭，不然太占内存。

FileInputStream-FileOutputStream

字节流

package com.hdujavaTest.IOTest;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;
/*文件专属
* 读取字节流  不仅能处理文本文档 还可以读取写入图像等格式 因为底层是对字节做处理
*
* */
public class FileInputStreamTest01 {
    public static void main(String[] args) {
        //文件字节输入流  读取文件
        String txt="C:\\Users\\wish_cai\\Pictures\\大学\\psb.jpg";
        fileInputStreamfuntion(txt);

        //文件写入
        /*String txtwrite="D:\\JAVA\\java_test\\IOTest02.txt";
        fileOutputStreamfuntion(txtwrite);*/

        //复制 文本文档 还行 但是涉及图片就拒绝访问
        //之前的复制 是FileOutputStream是涉及到文件夹路径C:\Users\wish_cai\Pictures\作业，而FileOutputStream是写入文件，所以要到具体的文件名
        String txtwritecopy="C:\\Users\\wish_cai\\Pictures\\作业\\新建文本文档.jpg";
        fileCopy(txt,txtwritecopy);
    }
    //读  输入   硬盘到内存
    public static String fileInputStreamfuntion(String txt){
        //idea的默认路径是在Project下
        //如果文件在其他模块下，那么应该读取时   模块\\src(根据实际)\\文件名
        //文档字节输入流
        String s=null;
        FileInputStream fileInputStream=null;
        try{
            /*read()一次读取一个字节 并以int形式返回*/
            /*
            System.out.println("一次读取一个字节 并以int形式返回");
            fileInputStream=new FileInputStream(txt);
            int filer;
            while ((filer=fileInputStream.read())!=-1){
                System.out.print(filer+" ");
            }
            */

            /*设置一个字节数组 用read(byte[]) 读取字节，返回的是数量*/
            //前面读取完 之后需要重新新建一个FileInputStream对象
            //当最后数组不够时，会覆盖前面的，后面数组部分依旧会保留
            /*
            System.out.println('\n'+"设置一个字节数组 用read(byte[]) 读取字节，返回的是数量:");
            fileInputStream=new FileInputStream(txt);
            byte[] bytesarr=new byte[6];
            int num;
            while ((num=fileInputStream.read(bytesarr))!=-1){
                //System.out.println(num);
                String s=new String(bytesarr,0,num);
                System.out.print(s);
                //System.out.print(new String(bytesarr,0,num));
            }
             */

            //.available();//表示还有多少字节可用
            //System.out.println('\n'+"表示还有多少字节可用");
            fileInputStream=new FileInputStream(txt);
            //fileInputStream.available();//表示还有多少字节可用
            System.out.println(fileInputStream.available());
            byte[] bytesarr2=new byte[fileInputStream.available()];
            fileInputStream.read(bytesarr2);
            String s2=new String(bytesarr2,0,bytesarr2.length);
            //System.out.println(s2);
            s=s2;

            //跳过多少字节
           /* System.out.println("跳过多少字节");
            fileInputStream=new FileInputStream(txt);
            fileInputStream.skip(8);
            byte[] bytesarr3=new byte[fileInputStream.available()];
            fileInputStream.read(bytesarr3);
            String s3=new String(bytesarr3,0,bytesarr3.length);
            System.out.println(s3);*/

            //
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileInputStream!=null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return s;
    }

    //写 输出  内存到硬盘  此处txt是我们的路径
    public static void fileOutputStreamfuntion(String txt){

        FileOutputStream fileOutputStream=null;
        try{
            //谨慎使用  文件不存在 会自动新建立路径和内容  文件之前存在 会覆盖原内容
            fileOutputStream=new FileOutputStream(txt);
            System.out.println("输入需要写的内容：");
            Scanner scanner=new Scanner(System.in);
            String s=scanner.next();
            //String s="xinjianyigwenjianj.tsg";
            //s.getBytes();转byte数组
            fileOutputStream.write(s.getBytes());

            //追加写入
            fileOutputStream=new FileOutputStream(txt,true);
            System.out.println("追加写入输入需要写的内容：");
            Scanner scanner1=new Scanner(System.in);
            String s2=scanner1.next();
            //String s="xinjianyigwenjianj.tsg";
            //s.getBytes();转byte数组
            fileOutputStream.write(s2.getBytes());

            //前面追加
            //没有快捷键，那我的想法是 先读取之前文件的，然后写入我想加在开头的，然后再将之前的写入

            //写完之后要刷新
            fileOutputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileOutputStream!=null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //文件的复制
    public static void fileCopy(String txtread,String txtwrite){
        FileInputStream fileInputStream=null;
        FileOutputStream fileOutputStream=null;
        try{
            //先输入一个流对象
            fileInputStream=new FileInputStream(txtread);//读
            fileOutputStream=new FileOutputStream(txtwrite);//写

            //那就一边读  一边写
            int r;
            byte[] bytes=new byte[1024*1024];
            while ((r=fileInputStream.read(bytes))!=-1){
                fileOutputStream.write(bytes,0,r);
            }
        }catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileInputStream!=null){
                try{
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fileOutputStream!=null){
                try{
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileReader-FileWriter

字符流
用字符流 读取文本文件
但是只能处理文本文档

package com.hdujavaTest.IOTest;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
/*文件专属
用字符流  读取文本文件（能用记事本打开的） 复制文本文件
但是只能处理文本文档
* */
public class Fileread01 {
    public static void main(String[] args) {
        /*String txt="D:\\JAVA\\java_test\\IOTest04copy.txt";
        FileReadfun(txt);*/

        /*String txt1="C:\\Users\\wish_cai\\Pictures\\作业\\Write12.txt";
        FileWriterfun(txt1);*/

        String txt="D:\\JAVA\\java_test\\IOTest04copy.txt";
        String tet2="D:\\JAVA\\java_test\\IOrTow001.txt";
        CopyFile(txt,tet2);
    }

    public static void FileReadfun(String txt){
        FileReader fileReader=null;
        try{
            fileReader=new FileReader(txt);
            char[] chars=new char[30];
            int readnum;
            fileReader.read(chars);
            for (char c:chars) {
                System.out.print(c);
            }

            fileReader=new FileReader(txt);
            char[] chars2=new char[30];
            while ((readnum=fileReader.read(chars2))!=-1){
                System.out.println(new String(chars2,0,readnum));
            }

            fileReader=new FileReader(txt);
            while ((readnum=fileReader.read())!=-1){
                System.out.println(readnum);
            }

            fileReader=new FileReader(txt);

        }catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileReader!=null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //只能写入普通文本  因为处理的是字符    ，前面流是处理字节
    public static void FileWriterfun(String txt){
        FileWriter fileWriter=null;
        try{
            fileWriter=new FileWriter(txt);
            System.out.println("input need your contents");
            Scanner scanner=new Scanner(System.in);
            String x=scanner.nextLine();
            fileWriter.write(x);
            fileWriter.flush();
            FileReadfun(txt);//要刷新之后才能读取
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileWriter!=null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //复制   只能拷贝普通文本  先读取 再写入
    public static void CopyFile(String readtxt,String writetxt){
        FileReader fileReader=null;
        FileWriter fileWriter=null;
        try{
            fileReader=new FileReader(readtxt);
            fileWriter=new FileWriter(writetxt);

            char[] rTow=new char[30];
            int numread=0;
            while ((numread=fileReader.read(rTow))!=-1){
                fileWriter.write(rTow);
            }
            fileWriter.close();

            FileReadfun(writetxt);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

        }
    }

}

转化流

将字节流转化为字符流

后面实用缓冲流的时候
我们可以不必自定义数组来辅助读写
而缓冲流的构造方法的参数是

 public BufferedReader(Reader in) {
        this(in, defaultCharBufferSize);
    }
public BufferedWriter(Writer out) {
        this(out, defaultCharBufferSize);
    }

可见是Reader和Writer类型，而在字符流和字节流中，只有字符流 FileWriter和FileReader是符合的。
如果我们想要在缓冲流的构造方法参数中传入字节流 就要用到转换流

OutputStreamWriter(new FileOutputStream("txt"))
InputStreamReader(new FileInputStream("txt"));

缓冲流BufferedWriter-BufferedReader

**
缓冲流专属

• 不需要自定义char数组，byte数组，自带缓冲
• 将字符流 ————Reader下面的类FileReader 传入包装流的构造方法
• FileReader extends InputStreamReader ;;;;; InputStreamReader extends Reader
• 而如果是字节流 FileInputStream 如何传入呢
• 通过转换流 转化
• 可以一行一行读
  **

package com.hdujavaTest.IOTest;

import java.io.*;


/*
* 缓冲流专属
* 不需要自定义char数组，byte数组，自带缓冲
* 将字符流 ————Reader下面的类FileReader  传入包装流的构造方法
* FileReader extends InputStreamReader         ;;;;; InputStreamReader extends Reader
*
* 而如果是字节流 FileInputStream  如何传入呢
* 通过转换流 转化
 * 可以一行一行读
* */
public class Buffered01 {
    public static void main(String[] args) throws IOException {
        //缓冲流  读  不需构造特定数组
        String txt="D:\\JAVA\\java_test\\IOTest\\out\\production\\IOTest\\com\\hdujavaTest\\IOTest\\Fileread01.class";
        Bufferread(txt);

        //缓冲流 写 也不需构造特定数组
        String txtwrite="C:\\Users\\wish_cai\\Pictures\\作业\\tete.txt";
        Bufferwirte(txtwrite);
    }

    public static void Bufferread(String txt) throws IOException {
        //字符流传入缓冲流

        BufferedReader bufferedReader=null;
        FileReader fileReader=new FileReader(txt);
        bufferedReader=new BufferedReader(fileReader);
        //String x=bufferedReader.readLine();
        String x;
        while ((x=bufferedReader.readLine())!=null){
            System.out.println(x);
        }
        bufferedReader.close();

        //字节流传入缓冲流  通过转化流
        FileInputStream in=new FileInputStream(txt);//********字节流
        InputStreamReader inputStreamReader=new InputStreamReader(in);//***********通过转换流 转化为字符流
        BufferedReader bufferedReader1=null;
        bufferedReader1=new BufferedReader(inputStreamReader);//*****传入
        bufferedReader1.close();
        /*在new 后面的构造方法参数里 就是一个节点流
        * 用哪个构造方法 其引用就是一个包装流
        * */
        
        /*合并写*/
        BufferedReader bufferedReader2=new BufferedReader((new InputStreamReader(new FileInputStream(txt))));
    }

    public static void Bufferwirte(String txt) throws IOException {
        BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter(txt));//字符流
        bufferedWriter.write("qweqhuiwfhais.!!!");
        //对文件作出修改 记得刷新
        bufferedWriter.flush();
        bufferedWriter.close();

        /*转换流*/
        BufferedWriter bufferedWriter1=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(txt,true)));//true  追加
        bufferedWriter1.write("\n"+"1111111111");
        bufferedWriter1.flush();
        bufferedWriter1.close();

    }
}

数据流专属

能够保存数据类型+实际内容
且只能用对应的数据流读写
DataOutputStream

package com.hdujavaTest.IOTest;

import java.io.*;

public class DataStream01 {
    public static void main(String[] args) throws IOException {
        String txt1="D:\\bilibili\\JJDown\\Download\\Java零基础教程视频（适合Java 0基础，Java初学入门）\\Data）";
        DataOutputStream(txt1);

        DataInputStream(txt1);
    }

    //数据字节输入流  且带有数据基本类型
    //且只能通过对应的DataInputstream打开
    public static void DataOutputStream(String txt) throws IOException {
        DataOutputStream dataOutputStream=new DataOutputStream(new FileOutputStream(txt));
        int a=1;
        int b=2;

        dataOutputStream.writeInt(a);
        dataOutputStream.writeInt(b);
        dataOutputStream.flush();
        dataOutputStream.close();
    }

    //读取专属数据流
    //而且要知道其专门的顺序
    public static void DataInputStream(String txt) throws IOException {
        DataInputStream dataInputStream=new DataInputStream(new FileInputStream(txt));
        int x=dataInputStream.readInt();
        int y=dataInputStream.readInt();

        System.out.println(x);
        System.out.println(y);
    }
}

标准输出流

直接写入到文件中

package com.hdujavaTest.IOTest;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
//不需要手动关闭close
public class PrintStream01 {
    public static void main(String[] args) throws FileNotFoundException {
        System.out.println("标准输出流——print");
        PrintStream ps=System.out;
        ps.println("adsad");
        ps.println(1);
        ps.println(true);

        //写入到固定路径的文件中
        PrintStream ps1=new PrintStream(new FileOutputStream("D:\\bilibili\\JJDown\\Download\\Java零基础教程视频（适合Java 0基础，Java初学入门）\\ad"));
        ps1.println(11111);
        ps1.println("ahuidqaas");
    }
}

File类

File和四大家族没什么关系，所以File不能完成文件的读和写
*File对象代表什么？

• C:\ddd
• C:\dasdf\asf\asfasf\asfa.txt
• File对象可能是对应的目录也可能是文件
• File只是一个路径的抽象表示形式
  在对于文件的处理上也十分便捷。
  提供了判断文件路径是否存在，不存在时新建，返回上一次修改的时间，删除文件路径、返回路径的绝对形式、返回文件名、返回所有子文件的文件名（listFiles）等。

public class File01 {
    public static void main(String[] args) {
        File file=new File("C:\\Users\\wish_cai\\Pictures\\作业\\");
        System.out.println("文件是否存在："+file.exists());
        System.out.println(file.length());
        //不存在 以文件形式新建
        File file1=new File("C:\\Users\\wish_cai\\Pictures\\作业\\xinjian");
        if(!file1.exists()) {
            try {
                file1.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        File file2=new File("C:\\Users\\wish_cai\\Pictures\\a\\b\\c\\");
        if(!file2.exists())
            file2.mkdirs();//mkdirs建立多重目录  否则 mkdir只能新建一个，在多重目录要求下 没有s将不会建立。
    }
}

文件拷贝

java|IO流实现文件拷贝

package com.hdujavaTest.IOTest;

import java.io.*;

/**
 *问题一：得到子文件夹的目录之后，因为FileInputStream  需要读到文件名 所以其拒绝访问————递归调用
 * 涉及到 新建目录
 *
 * */
public class CopyFile01 {
    public static void main(String[] args) {
        File filesrc=new File("C:\\Users\\wish_cai\\Pictures\\作业");
        File filedest=new File("D:\\bilibili\\JJDown\\Download\\Java零基础教程视频（适合Java 0基础，Java初学入门）\\copy\\");
        CopyDir(filesrc,filedest);
    }

    private static void CopyDir(File filesrc, File filedest){
        if(filesrc.isFile()){
            //是文件先拷贝，再跳出该次递归，否则即为目录，进入目录操作。
            //System.out.println(filesrc.getAbsolutePath());
            //是文件就进行拷贝处理
            copyfile(filesrc,filedest);
            return;
        }
        File temFile=null;

        File[] files=filesrc.listFiles();
        for (File f:files) {//文件或目录

            File newdest=null;
            File newsrc=null;

            if(f.isDirectory()){
                /*当f是目录中的一个子目录时 进入*/
                String name=f.getName();
                String destDir=filedest.getAbsolutePath().endsWith("\\")?(filedest.getAbsolutePath()+name):(filedest.getAbsolutePath()+"\\"+name);
                /*System.out.println(destDir);*/
                //在拷贝路径中生成新的目录
                newdest=new File(destDir);
                if(!newdest.exists())
                    newdest.mkdirs();

                /*String srcDir=f.getAbsolutePath().endsWith("\\")?f.getAbsolutePath():(f.getAbsolutePath()+"\\");*/
                String srcDir=f.getAbsolutePath();
                System.out.println(srcDir);
                newsrc=new File(srcDir);
                temFile=newdest;//更新拷贝路径
                CopyDir(newsrc,temFile);

            }
            //temFile=newdest;
            /*当目录下的是一个文件时  进入下一次循环，然后直接拷贝*/
            if(!(f.isDirectory())){
                CopyDir(f,filedest);
            }

        }
    }

   private static void copyfile(File src,File dest){
        FileInputStream fileInputStream=null;
        FileOutputStream fileOutputStream=null;
        String txt=dest.getAbsolutePath().endsWith("\\")?dest.getAbsolutePath():(dest.getAbsolutePath()+"\\")+src.getName();
       System.out.println(txt);
        try{
            fileInputStream=new FileInputStream(src);
            fileOutputStream=new FileOutputStream(txt);

            byte[] bytes=new byte[1024*1024];
            int readcount;
            while ((readcount=fileInputStream.read(bytes))!=-1){
                fileOutputStream.write(bytes,0,readcount);
            }

            fileOutputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileInputStream!=null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fileOutputStream!=null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
   }
}