java-IO流

本文主要是介绍java-IO流，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

IO流

在这里插入图片描述

1.输入流与输出流

流：数据在数据源（文件）和程序（内存）之间的路径
输入流：数据从数据源（文件）到程序（内存）的路径
输出流：数据从程序（内存）到数据源（文件）的路径

在这里插入图片描述

常用的文件操作

File类实现了Serializable与Comparable接口

File类的构造器

new File（String pathname）//根据路径构建一个File对象

new File（File parent，String pathname）//根据父目录文件+子路径构建一个File对象

new File（String parent，Sting child）//根据父路径+子路径构建一个File对象

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

 public static void main(String[] args) throws IOException, URISyntaxException {
        File file1=new File("d:/news1.txt");
        File file2=new File("d:\\","news2.txt");
        File file3=new File("d:\\");
        File file4=new File(file3,"news3.txt");
        URI uri=new URI("file:///d:/news4.txt");
        File file5= new File(uri);
        //上面的file1、file2..等  只是在java中的一个对象
        //只有执行了 createNewFile（）方法，才会真正在磁盘中创建该文件        if(file1.createNewFile()&&file2.createNewFile()&&file4.createNewFile()&&file5.createNewFile()){
            System.out.println("文件创建成功！");
        }else {
            System.out.println("文件创建失败！");
        }
    }

File对象常用的一些方法

file.getName()//返回由此抽象路径名表示的文件或目录的名称。
file.getAbsoluteFile()//返回此抽象路径名的绝对路径名形式。返回类型是File
file.getAbsolutePath()//返回此抽象路径名的绝对路径名字符串。返回类型是String
file.getParent()//返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null
file.length()//返回由此抽象路径名表示的文件的长度。
file.exists()//测试此抽象路径名表示的文件或目录是否存在。
file.isFile()//测试此抽象路径名表示的文件是否是一个标准文件。
file.isDirectory()//测试此抽象路径名表示的文件是否是一个目录。
file.mkdir()// 创建此抽象路径名指定的目录（一级目录）。
file.mkdir()//创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。(创建多级目录)

流的分类

字节流字符流
输入流 InputStream Reader
输出流 OutputStream Writer

	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

字节输入流（InputStream）常用的子类

FileInputStream:文件输入流
BufferedInputStream:缓冲字节输入流
ObjectInputStream:对象字节输入流

2.字节流

FileInputStream

/**
 * 单个字节读取效率低
 */
public void read01()  {
    String path="d:\\news1.txt";
    FileInputStream fileInputStream=null;
    try {
        fileInputStream=new FileInputStream(path);
        int read = 0;
       while ((read=fileInputStream.read())!=-1){
           System.out.print((char) read);
       }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        //关闭文件流，释放资源
        try {
            fileInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
public void read2(){
    String path="d:\\news1.txt";
    FileInputStream fileInputStream=null;
    //定义字节数组
    byte[] buf=new byte[8];
    try {
        fileInputStream=new FileInputStream(path);
        int readLen= 0;
        //fileInputStream.read(buf) 如果读取正常返回实际读取的字节数  每次最多读8字节
        //如果返回-1，表示读取完毕
        while ((readLen=fileInputStream.read(buf))!=-1){
            System.out.print(new String(buf,0,readLen));
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        //关闭文件流，释放资源
        try {
            fileInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileOutPutStream

public class OutPutStream_ {
    public static void main(String[] args) {
new OutPutStream_().writeFile();
    }
    public void writeFile(){
        String filePath="d:\\news.txt";
        FileOutputStream fos=null;
        try {
            //若没有该文件，则会自动创建
            fos=new FileOutputStream(filePath);
     /**
        * 1、new FileOutputStream(filePath);这种创建方式，当写入内容时，会覆盖其内容
        * 2、new FileOutputStream(filePath，true);这种方式创建，当写入内容时，会以追加的方式，不会覆盖原内容
       */
            //写入一个字节
            fos.write('a');
            String str="wanna";
            //将字符串转化为字符数组  str.getBytes()
            fos.write(str.getBytes());
            /**
             * write(byte[] b, int off, int len)
             * 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
             */
            fos.write(str.getBytes(),0,3);//截取前三个字节写入
        }  catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

两者结合使用拷贝文件

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

public class FileCopy {
    public static void main(String[] args) {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        String filePath="d:\\a.jpg";
        String destFilePath="c:\\a.jpg";
        byte[] bytes=new byte[1024];
        int readLen=0;
        try {
            fis=new FileInputStream(filePath);
            fos=new FileOutputStream(destFilePath);
            while ((readLen=fis.read(bytes))!=-1){
                fos.write(bytes,0,readLen);//一定要使用这个方法
            }
            System.out.println("拷贝完成！");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (fis != null) {
                    fis.close();
                }
            if (fos != null) {
                fos.close();
            }
        }catch (IOException e){
            e.printStackTrace();
            }
        }
    }
}

3.字符流

FileReader与FileWriter

FileReader与FileWriter都是字符流，按照字符操作IO

FileReader

import java.io.FileReader;
import java.io.IOException;

public class FileReader_ {
    public void reader01(){
        FileReader fileReader=null;
        try {
            fileReader=new FileReader("d:\\news.txt");
            int data=0;
            while ((data=fileReader.read())!=-1)
            {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {

                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public void reader02(){
        FileReader fileReader=null;
        try {
            fileReader=new FileReader("d:\\news.txt");
            int data=0;
            char[] chars=new char[5];
            while ((data=fileReader.read(chars))!=-1)
            {
                System.out.print(new String(chars,0,data));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {

                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
new FileReader_().reader02();
    }
}

FileWriter

import java.io.FileWriter;
import java.io.IOException;

public class FileWriter_ {
    public void Writer01(){
        String filePath="d:\\news.txt";
        FileWriter fw=null;
        try {
            fw=new FileWriter(filePath);
            /**
             *
             *  void write(char[] cbuf, int off, int len)
             *           写入字符数组的某一部分。
             *  void write(int c)
             *           写入单个字符。
             *  void write(String str, int off, int len)
             *           写入字符串的某一部分。
             */
            String str="你好这是void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。\n";
            fw.write(str.toCharArray(),0,20);
            fw.write(77);
            fw.write('o');
            fw.write("\n这是FileWriter......");
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                /**
                 * 对于FileWriter，一定要关闭或者刷新流，才能将数据写入文件！！！！
                 * flush()与close()在底层实现上都掉用了writeBytes()  才将数据写入文件
                 */
                fw.flush();
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    public static void main(String[] args) {
        new FileWriter_().Writer01();
    }
}

4.节点流与处理流

基本介绍

1.节点流可以从一个特定的数据源读写数据，如FileReader、FileWriter（对文件读写）等。还有一些是对管道、数组等进行读写操作。

2.处理流也叫包装流是连接已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，如BufferedReader、BufferedWriter。

两者的区别与联系：

节点流是底层流/低级流，直接和数据源相连
处理流包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法完成输入输出。
处理流（也叫包装流）是对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连。

字符处理流：

BufferedReader与BufferedWriter属于字符流，按照字符来读取数据。所以不适合读取二进制文件。

BufferedReader

package Reader_;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BufferedReader_ {
    public static void main(String[] args) {
        String filePath="d:\\news.txt";
        BufferedReader bufferedReader=null;
        try {
             bufferedReader = new BufferedReader(new FileReader(filePath));
            String line;//按行读取
            /**
             * bufferedReader.readLine  按行读取
             * 当返回为null时读取完毕
             */
         ;
            while (( line=bufferedReader.readLine())!=null){
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                /**
                *这里不需要关闭 FileReader
                *只需要关闭外层包装流，它会调用你穿进来的流的close()方法
                */
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

BufferedWriter

package Writer_;

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

public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath="d:\\news1.txt";
        /**
         * new FileWriter(filePath,true) 是以追加的方式进行写入
         * new FileWriter(filePath)是以覆盖的方式写入
         */
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
        bufferedWriter.write("祝大家百万年薪！！！");
        bufferedWriter.newLine();//插入一个和系统相关的换行
        bufferedWriter.write("我们都是打工人！！！");
        /**
         * 这里关闭外层包装流即可，它会在底层调用 你传进来的流的close方法
         */
       // bufferedWriter.flush();
        bufferedWriter.close();
    }
}

使用BufferedWriter与BufferedReader拷贝文件

package Copy;

import java.io.*;

public class BufferedCopy_ {
    public static void main(String[] args) throws IOException {
        String srcPath="d:\\news.txt";
        String destPath="d:\\news2.txt";
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(destPath));
        BufferedReader bufferedReader=new BufferedReader(new FileReader(srcPath));
        String line=null;
        while ((line=bufferedReader.readLine())!=null){
            //每读入一行就写入 同时加上换行
            bufferedWriter.write(line);
            bufferedWriter.newLine();
        }
        //关闭流
        if (bufferedReader!=null){
            bufferedReader.close();
        }
        if (bufferedWriter!=null){
            bufferedWriter.close();
        }
    }
}

字节处理流：

BufferedInputStream与BufferedOutStream属于字节流，可以用来进行二进制文件（音频、视频、pdf、word…）的读写。

使用BufferedInputStream与BufferedOutStream拷贝文件

package Copy;
import java.io.*;
public class BufferedCopy_02 {
    public static void main(String[] args)  {
        String srcPath="d:\\news.txt";
        String destPath="d:\\news3.txt";
        BufferedOutputStream bos=null;
        BufferedInputStream bis=null;
        try {
            bos=  new BufferedOutputStream(new FileOutputStream(destPath));
            bis =new BufferedInputStream(new FileInputStream(srcPath));
            byte[] bytes=new byte[1024];
            int readline=0;
           while( (readline=bis.read(bytes))!=-1){
               bos.write(bytes,0,readline);
           }
            System.out.println("拷贝完成！！");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                /**
                 * 同理也是关闭外层流
                 */
            if (bis!=null){
                bis.close();
            }if (bos!=null){

                    bos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

5.对象流

对象流：ObjectInputStream和ObjectOutputStream

对一个对象的数据及类型进行保存

这就牵扯到序列化与反序列化

序列化：就是在保存数据时，保存数据的值与数据类型。

反序列化：就是在恢复数据时，恢复数据的值与数据类型。

要让对象支持序列化机制，必须让其类是可序列化的，这个类必须实现以下两个接口之一：

Serializable（推荐使用）：这是一个标记接口，标记该类可以系列化，它里面没有任何方法。
Externalizable：它继承了Serializable接口，有一些扩充方法，需要实现这些方法。

ObjectInputStream提供了对基本类型及对象类型的反序列化功能

ObjectOutputStream提供了对基本类型及对象类型的序列化功能

package Object_;
import java.io.Serializable;
public class Dog implements Serializable {
    private String name;
    private int age;
    //serialVersionUID 序列化的版本号，可以提供兼容性
    private static final long serialVersionUID=1l;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Dog() {
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

对对象的写入（序列化形式）

package Object_;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectOutputStream_ {
    public static void main(String[] args) {
        String ObjPath="d:\\dog.dat";
        ObjectOutputStream oos=null;
        try {
        oos = new ObjectOutputStream(new FileOutputStream(ObjPath));
            oos.writeObject(new Dog("小花",5));
            System.out.println("写入完成(序列化形式)...");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (oos!=null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

对对象的读取

package Object_;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectInputStream_ {
    public static void main(String[] args) {
        String ObjPath="d:\\dog.dat";
        ObjectInputStream ois=null;
        try {
          ois = new ObjectInputStream(new FileInputStream(ObjPath));
            Dog o = (Dog)ois.readObject();
            System.out.println(o);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        finally {
            if (ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

注意事项

读写顺序要一致。

要求实现序列化或反序列化对象，需要实现Serializable接口。

序列化的类中建议添加SerialVersionUID,提高版本兼容性。

序列化对象时，默认将里面的所有属性都进行序列化，但除了static或transient修饰的成员。

（1）为什么要用transient关键字？
在持久化对象时，对于一些特殊的数据成员（如用户的密码，银行卡号等），我们不想用序列化机制来保存它。为了在一个特定对象的一个成员变量上关闭序列化，可以在这个成员变量前加上关键字transient。

（2）transient的作用
transient是Java语言的关键字，用来表示一个成员变量不是该对象序列化的一部分。当一个对象被序列化的时候，transient型变量的值不包括在序列化的结果中。而非transient型的变量是被包括进去的。

序列化对象时，要求里面属性的类型也需要实现序列化接口。

序列化具有可继承性，某类实现了序列化，则它的所有子类默认实现了序列化。

6.标准输入输出流

	类型	默认设备
System.in 标准输入	InputStream	键盘
System.out 标准输出	PrintStream	显示器

package Standard;

import java.io.InputStream;
import java.util.Scanner;

public class InputAndOutput {
    public static void main(String[] args) {
        /**
         * public final static InputStream in = null;
         * 1.编译类型是InputStream
         * 2.运行类型是BufferedInputStream
         * 表示的是标准输入  ->键盘
         */
        System.out.println(System.in.getClass());
        Scanner scanner = new Scanner(System.in);//例如
        /**
         *public final static PrintStream out = null;
         * 1.编译类型是PrintStream
         * 2.输出类型是PrintStream
         * 表示的是默认输出  ->显示器
         *
            */
        System.out.println(System.out.getClass());
        System.out.println("你真帅！");//例如

    }
}

7.转换流

转换流：InputStreamReader与OutputStreamWriter

作用是将字节流转换为字符流（解决字符乱码问题）

介绍：

InputStreamReader是Reader的子类，可以将InputStreamReader（字节流）包装（转换）成Reader（字符流）
OutputStreamWriter是Writer的子类，可以将OutputStreamWriter（字节流）包装（转换）成Writer（字符流）
当处理纯文本数据时，使用字符流效率更高，并且可以有效解决中文乱码问题，所以建议将字节流转化为字符流
可以在使用时制定编码格式（例如：utf-8,gbk,gb2312等）

未更改文件的字符编码时

[ 在这里插入图片描述

更改后：出现乱码
在这里插入图片描述

演示InputStreamReader_解决中文乱码问题

package transformation;

import java.io.*;

/**
 * 演示InputStreamReader_解决中文乱码问题
 */
public class InputStreamReader_ {
    public static void main(String[] args) throws IOException {
        String filePath="d:\\news1.txt";
        /**
         * 1.将FileInputStream转化为InputStreamReader
         * 2.指定编码格式
         */
        InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "gbk");
         //3.将InputStreamReader传入BufferedReader
        BufferedReader bufferedReader=new BufferedReader(isr);
        /**
         * 将2.3步结合到一起
         *   BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"gbk"));
         */
        //4.读取
        String s=bufferedReader.readLine();
        System.out.println(s);
        //5.关闭外层流
        bufferedReader.close();


    }
}

演示使用OutputStreamWriter 使用指定编码写入文件

package transformation;

import java.io.*;

/**
 * 演示使用OutputStreamWriter 使用指定编码写入文件
 */
public class OutputStreamWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath="d:\\news.txt";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), "gbk");
        osw.write("转换流写入");
        osw.close();
        System.out.println("写入成功");
    }
}

8.打印流

PrintStream（字节流）与PrintWriter（字符流）

打印流只有输出流没有输出流

字节打印流PrintStream

package Writer_;

import java.io.IOException;
import java.io.PrintStream;

/**
 * 演示PrintWriter（字节打印流）
 */
public class PrintStream_ {
    public static void main(String[] args) throws IOException {
        PrintStream ps=System.out;
        //在默认情况下 PrintStream的输出位置是 标准输出，即显示器 控制台
        ps.print("这是标准输出！！！");
        //因为print的底层是write，所以可以直接调用write
        ps.write("这是标准输出！！！".getBytes());
        ps.close();
        //修改打印位置
        System.setOut(new PrintStream("d:\\news.txt"));
        System.out.println("你好！PrintStream");
    }
}

字符打印流PrintWriter

package Writer_;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class PrintWriter_ {
    public static void main(String[] args) throws IOException {
        //修改打印位置
        PrintWriter pw=new PrintWriter(new FileWriter("d:\\news.txt"));
//        PrintWriter pw=new PrintWriter(System.out);
        pw.write("你好  java~~~~");
        pw.close();
    }
}

9.使用IO读取properties配置文件

在这里插入图片描述

例如读取连接数据库的配置文件

package properties_;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
*这是使用传统方式进行读取
*比较繁琐
*若只需要某一个值，例如ip  还需要进一步判断
*/
public class properties01 {
    public static void main(String[] args) throws IOException {
        //读取myql.properties并得到 ip user pw
        BufferedReader br = new BufferedReader(new FileReader("src\\properties_\\mysql.properties"));
        String line=null;
        while ((line=br.readLine())!=null){
            String[] spLit=line.split("=");
            System.out.println(spLit[0]+"的值是"+spLit[1]);
        }
        br.close();
    }
}

使用properties类读取配置文件

介绍：

专门读取配置文件的集合类

配置文件的格式：

键=值

键=值

注意：键值对不需要有空格，值不需要用引号。默认类型是String

`String`	getProperty(String key)	用指定的键在此属性列表中搜索属性。
`String`	getProperty(String key ,String defaultValue)	用指定的键在属性列表中搜索属性。
`void`	list(PrintStream out)	将属性列表输出到指定的输出流
`void`	list(PrintWriter out)	将属性列表输出到指定的输出流。
`void`	load(InputStream inStream)	从输入流中读取属性列表（键和元素对）。
`void`	load(Reader reader)	按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
`Object`	setProperty(String key, String value)	调用 `Hashtable` 的方法 `put`。
`void`	store(OutputStream out, String comments)	以适合使用 load(InputStream) 方法加载到 `Properties` 表中的格式，将此 `Properties` 表中的属性列表（键和元素对）写入输出流。
`void`	store(Writer writer, String comments)	以适合使用 load(Reader) 方法的格式，将此 `Properties` 表中的属性列表（键和元素对）写入输出字符。

package properties_;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Parameter;
import java.util.Properties;

public class properties02 {
    public static void main(String[] args) throws IOException {
        /**
         * 使用Properties读取mysql.properties文件
         */
        //1.创建Properties对象
        Properties properties=new Properties();
        //2.加载指定配置文件
        properties.load(new FileReader("src\\properties_\\mysql.properties"));
        //3.把k-v现实至打印台
        properties.list(System.out);
        //4.根据k获取v
        System.out.println("账号是"+properties.getProperty("user"));
        System.out.println("密码是"+properties.getProperty("pwd"));
    }
}

使用Properties创建修改配置文件

package properties_;

import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class properties03 {
    public static void main(String[] args) throws IOException {
        //Properties创建配置文件，修改配置文件内容
        //Properties的父类就是HashTable，底层就是HashTable核心方法
        Properties properties=new Properties();
        //创建
        //如果该文件没有key则为创建  有key则为修改
        properties.setProperty("user","汤姆");//注意使用FileOutputStream保存时，保存的是中文的unicode码值
        properties.setProperty("pwd","123");
        properties.setProperty("charset","utf8");
        //将k-v存储到文件中即可  中文注释在存储时也会保存的是unicode码
        properties.store(new FileOutputStream("src\\properties_\\mysql.properties"),"这个是注释");
        System.out.println("保存配置成功~");
    }
}

10.使用io进行文件夹的拷贝

package Copy;

import java.io.*;

public class copyDirectoryDemo {

    public static void main(String[] args) {
        File srcFolder = new File("C:\\Users\\xuanlong\\Desktop\\日语");
        File destFolder = new File("C:\\Users\\xuanlong\\Desktop\\日语Copy");
        fun(srcFolder, destFolder);
    }

    public static void fun(File srcFolder, File destFolder) {
        File[] fileArray = srcFolder.listFiles();
        if (!destFolder.exists()) {
            destFolder.mkdir();
        }
        for (File file : fileArray) {
            if (file.isDirectory()) {
                String folderName = file.getName();
                File newDestFolder = new File(destFolder, folderName);
                fun(file, newDestFolder);
            } else {
                String fileName = file.getName();
                File destFile = new File(destFolder, fileName);
                copy(file, destFile);
            }
        }
    }

    public static void copy(File file, File destFile) {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream(file));
            bos = new BufferedOutputStream(new FileOutputStream(destFile));
            byte[] bys = new byte[1024];
            int len = 0;
            while ((len = bis.read(bys)) != -1) {
                bos.write(bys, 0, len);

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

        }
    }
}

这篇关于java-IO流的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

java-IO流

IO流

1.输入流与输出流

常用的文件操作

File类的构造器

2.字节流

3.字符流

4.节点流与处理流

字符处理流：

字节处理流：

5.对象流

6.标准输入输出流

7.转换流

8.打印流

9.使用IO读取properties配置文件

10.使用io进行文件夹的拷贝

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯