Java输入输出流实例（字节流输入、输出）

字节流常用方法

输入、输出：

read()、write()   :  返回值就是对应的字节

read(byte[] bytes)、write(byte[] bytes)  :  返回值就是读取对应的数组，如果需要查看需要便利

int read（byte【】 b，int off，int len）:  off为读取起始位置，len为读取长度

int available（）：可以从输入流中读取的字节数目

void close()   :   关闭文档流

测试类

public static void main(String[] args) throws FileNotFoundException {
        //新建一个文件对象
        File file = new File("src/byteOut/test.txt");
        try {
            //新建此对象的txt文件
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //判断是否创建成功
        if (file.exists()) {
            //获取文件地址
            String uri=file.getPath();
            Test test=new Test();
            test.write(file,"1a");
            test.write(file,"1a",true);
            test.read(file);
            test.write(file,"2b");
            test.write(file,"2b");
            test.read(uri);
            test.write(file,"abcdefgh",2,3);
            test.read(uri,2,4);
        }else{
            System.out.println("不存在");
        }
    }

//输入类方法，传入文件

    public void read(File file){
        //新建一个空文件流，防止关闭输入流时作用域报错
        InputStream inputStream = null;
        try {
            //导入文件
            inputStream=new FileInputStream(file);
            //打印文件大小：字节
//            System.out.println(inputStream.available());
            int leng = 0;
            //判断文件内容是否为空，-1为空
            //leng得到的是read方法获得的字节数量，如果没有则为-1
            while ((leng = inputStream.read()) != -1) {
                //打印输入到内存的内容，强转换为字符串类型
                System.out.println((char) leng);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭输入流
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

//输入类方法，传入文件地址

    public void read(String uri){
        //新建一个空文件流，防止关闭输入流时作用域报错
        InputStream inputStream = null;
        try {
            //导入文件
            inputStream = new FileInputStream(uri);
            //打印文件大小：字节
//            System.out.println(inputStream.available());
            //定义一个长度为文件字节大小的数组，一次性读取出来
            byte[] bytes=new byte[inputStream.available()];
            //inputStream.read(bytes)得到的是read方法获得的字节数量，如果没有则为-1
            while ((inputStream.read(bytes)) != -1) {
                //定义字符遍历数组
                String str=new String(bytes);
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

//输入类方法，传入文件地址，start为读取起始位置，len为读取长度

    public void read(String uri,int start,int len){
        InputStream inputStream =null;
        try {
            inputStream = new FileInputStream(uri);
//            System.out.println(inputStream.available());
            //定义一个1024长度的数组，每次读取1024字节
            byte[] bytes=new byte[1024];
            //判断读取字节数量是否为空，为空则为-1
            while ((inputStream.read(bytes,start,len)) != -1) {
                //使用循环遍历数组，打印输入的文档
                for (int i = 0; i < bytes.length; i++) {
                    //判断是否为空
                    if (bytes[i]==0){
                        continue;
                    }
                    System.out.println((char)bytes[i]);
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

//写入类方法，传入文件地址，和写入字符串

    public void write(File file,String string){
        OutputStream outputStream=null;
        try {
            outputStream=new FileOutputStream(file);
            //将想要输入的字符写入bytes数组，文件编码为UTF-8
            byte[] bytes=string.getBytes(StandardCharsets.UTF_8);
            //写入数组
            outputStream.write(bytes);
            //刷新缓存
            outputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

//写入类方法，传入文件地址，和写入字符串，是否覆盖：true为不覆盖

    public void write(File file,String string,boolean choose){
        OutputStream outputStream=null;
        try {
            outputStream=new FileOutputStream(file,choose);
            byte[] bytes=string.getBytes(StandardCharsets.UTF_8);
            outputStream.write(bytes);
            outputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

//写入类方法，写入文件地址，写入字符，start为写入起始位置，len为写入长度

    public void write(File file,String string,int off,int len){
        OutputStream outputStream=null;
        try {
            outputStream=new FileOutputStream(file);
            byte[] bytes=string.getBytes(StandardCharsets.UTF_8);
            outputStream.write(bytes,off,len);
            outputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

//文档复制方法，file为源文件，file1为被覆盖文件

    public void copy(File file,File file1){
        InputStream inputStream=null;
        OutputStream outputStream=null;
        try {
            inputStream=new FileInputStream(file);
            outputStream=new FileOutputStream(file1);
            //单字节复制效率较慢
//            int leng=0;
//            while ((leng=inputStream.read())!=-1){
//                outputStream.write(leng);
//            }
            //整体复制
            byte[] bytes=new byte[inputStream.available()];
            inputStream.read(bytes);
            outputStream.write(bytes);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                outputStream.close();
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }