栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

22.IO流

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

22.IO流

IO流

        IO流是用来读写数据的,流使用完就要释放资源,(1024*8)Java默认较好存储单元

        I  :intput 把硬盘文件中的数据读入到内存的过程,称:输入 负责读

        O:output 把内存中的数据写出到硬盘文件的过程,称:输出 负责写

IO流分类

 Windows文件不区分大小写

文件字节输入流:FileInputStream

        以内存为基准,把磁盘文件中的数据以字节的形式读取到内存中

构造对象

读取方法

public class Demo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis1 = new FileInputStream(new File("day11\abc.txt"));
        System.out.println((char) (fis1.read()));
        int b;//单字节循环读文本
        while ((b=fis1.read())!=-1){
            System.out.println((char)b);
        }
        fis1.close();

        System.out.println("------------");

        FileInputStream fis2 = new FileInputStream("day11\DEF.txt");
        System.out.println((char)(fis2.read()));
        int len;//字节数组循环读文本
        byte[] bs = new byte[2];
        while ((len = fis2.read(bs))!=-1){
            System.out.println(new String(bs,0,len));
        }
        fis2.close();
    }
}

1.如何使用字节输入流读取中文内容输出不乱码呢?
        定义一个与文件一样大或者大于的字节数组,一次性读取完文件的全部字节

2.直接把文件数据全部读取到一个字节数组可以避免乱码,是否存在问题?
        如果文件过大,字节数组可能引起内存溢出

        一个字节一个字节读取效率较慢

        一个字节数组一个字节数组读取效率提升

        读取中文字符会乱码

文件字节输出流:FileOutputStream

        以内存为基准,把内存中的数据以字节的形式写出到磁盘文件中去的流

构造对象

写出方法

刷新关闭方法

public class Demo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos1 = new FileOutputStream(new File("day11\dzz1.txt"));
        FileOutputStream fos1_1 = new FileOutputStream(new File("day11\dzz1_1.txt"),true);
        FileOutputStream fos2 = new FileOutputStream("day11\dzz2.txt");
        FileOutputStream fos2_2 = new FileOutputStream("day11\dzz2_2.txt",true);

        fos1.write(65);//写入一个字节

        for (int i = 0 ; i < 10 ;i++) {
            fos1_1.write(97);
        }

        byte[] bs = {'a','b','c','d'};
        fos2.write(bs);//写入一个字节数组
        fos2.flush();
        fos2.write("rn".getBytes());
        fos2.write(bs,1,2);

        fos1.close();
        fos1_1.close();
        fos2.close();
        fos2_2.close();
    }
}

fos1.write("rn".getBytes()) → 换行

文件字符输入流:FileReader

        以内存为基准,把磁盘文件中的数据以字符的形式读取到内存中去

构造对象

读取方法

public class DemoReader {
    public static void main(String[] args) throws IOException {
        method02();
    }
    //字符数组循环读取
    private static void method02() throws IOException {
        //1.创建文件字符输入流FileReader类的对象fr,绑定源文件
        FileReader fr = new FileReader("day12\f2.txt");

        //2.文件字符输入流FileReader类的对象fr调用read方法,以字符的方式读取文件内容
        //定义int变量len,用来保存每次读取到的字符的个数
        int len;

        //定义长度为3的字符数组chs,用来保存每次读取到的多个字符的内容(最多3个)
        char[] chs = new char[3];//{'a','好','大'}

        //从fr关联的文件中读取多个字符(最多3个),存储到方法参数字符数组chs中,
        //返回读取的字符的个数赋值给变量len,
        //最后判断len的值是否不等于-1
        while ((len = fr.read(chs)) != -1) {
            System.out.println(new String(chs,0,len));
        }

        //3.文件字符输入流FileReader类的对象fr调用close方法,关闭流,释放资源
        fr.close();
    }

    //单字符循环读取
    private static void method01() throws IOException {
        //1.创建文件字符输入流FileReader类的对象fr,绑定源文件
        FileReader fr = new FileReader("day12\f2.txt");

        //2.文件字符输入流FileReader类的对象fr调用read方法,以字符的方式读取文件内容
        //定义int变量ch,用来保存每次读取到的一个字符对应的int数字
        int ch;

        //从fr关联的文件中读取一个字符,返回对应的int数字赋值给左侧变量ch
        //最后判断ch的值是否不等于-1
        while ((ch = fr.read()) != -1) {
            System.out.print((char)ch);
        }

        //3.文件字符输入流FileReader类的对象fr调用close方法,关闭流,释放资源
        fr.close();
    }
}

文件字符输出流:FileWriter

        以内存为基准,把内存中的数据以字符的形式写出到磁盘文件中去的流

构造对象

写入方法

刷新关闭方法

public class DemoWriter {
    public static void main(String[] args) throws IOException {
        //1.创建文件字符输出流FileWriter类的对象fw,绑定目标文件
        //没有写第二个参数,默认就是false,覆盖/重新写入
        //每次创建一个新的空的文件f3.txt
        //FileWriter fw = new FileWriter("day12\f3.txt");
        //第二个参数是true,表示追加写入(从文件的末尾开始写)
        FileWriter fw = new FileWriter("day12\f3.txt",true);

        //2.文件字符输出流FileWriter类的对象fw调用write方法,以字符的方式写出内容到文件
        //写出单个字符
        fw.write('a');
        fw.write(98);

        //写出换行
        fw.write("rn");


        //写出一个字符数组
        char[] chs = {'好', '好', '学', '习', '天', '天', '向', '上', '!'};
        fw.write(chs);

        //写出一个字符数组的一部分, 把"天天向上,重新写一遍"
        fw.write(chs,4,5);

        //写出换行
        fw.write("rn");

        //写出一个字符串
        String s = "好想有个女朋友!";
        fw.write(s);

        //写出一个字符串的一部分,把"有个女朋友!"再写一遍
        fw.write(s,2,6);

        //写出换行
        fw.write("rn");

        //3.文件字符输出流FileWriter类的对象fw调用close方法,关闭流,释放资源
        fw.close();
    }
}

fw.write("rn"); → 换行

 缓冲流

        缓冲流也称高效流,或则高级流        字节流也称为原始流

作用:缓冲流自带缓冲区,可以提高原始字节流,字符流读写数据的性能

缓冲区长度1024*8 8192


字节缓冲流

字节缓冲输入流:BufferedInputStream
字节缓冲输出流:BufferedOutputStream

构造对象

提高字节输入输出流读取数据的性能,读写功能上并无变化

字节缓冲流为什么提高了操作数据的性能?
    字节缓冲流自带8KB缓冲区
    可以提高原始字节流、字符流读写数据的性能

public class DemoCopyTxt {
        public static void main(String[] args) throws IOException {
        //1.创建字节缓冲输入流BufferedInputStream类的对象bis,绑定源文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("day11\f4.txt"));

        //2.创建字节缓冲输出流BufferedOutputStream类的对象bos,绑定目标文件
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day11\f5.txt"));
        //3.按行循环读(源文件)写(目标文件)
        //定义int变量len,用来保存每次读取到的一行字节串(不含换行符)
        int len;

        //从bis关联的文件中读取对应的字节数(不包含回车换行符的)返回赋值给int变量len
        //最后判断len的值是否不等于-1
        while ((len = bis.read()) != -1) {
            //把len中保存的字节串内容写出到bos绑定的目标文件中
            bos.write(len);
            //写入换行符
            bos.write("rn".getBytes());
        }
        //4.关闭流,释放资源
        bis.close();
        bos.close();
    }
}

字符缓冲流

字符缓冲输入流:BufferedReader
字符缓冲输出流:BufferedWriter

构造对象

字符缓冲输入流:BufferedReader

 字符缓冲输出流:BufferedWriter

字符缓冲流的功能如何使用?
        public BufferedReader​(Reader r)
        性能提升了,多了readLine()按照行读取的功能

        public BufferedWriter​(Writer w)
        性能提升了,多了newLine()换行的功能

public class DemoCopyTxt {
    public static void main(String[] args) throws IOException {
        //1.创建字符缓冲输入流BufferedReader类的对象br,绑定源文件
        BufferedReader br = new BufferedReader(new FileReader("day12\f4.txt"));

        //2.创建字符缓冲输出流BufferedWriter类的对象bw,绑定目标文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("day12\f5.txt"));

        //3.按行循环读(源文件)写(目标文件)
        //定义String变量line,用来保存每次读取到的一行字符串(不含换行符)
        String line;

        //从br关联的文件中读取一行字符串(不包含回车换行符的)返回赋值给String变量line
        //最后判断line的值是否不等于null
        while ((line = br.readLine()) != null) {
            //把line中保存的字符串内容写出到bw绑定的目标文件中
            bw.write(line);
            //写入换行符
            bw.newLine();
        }
        //4.关闭流,释放资源
        br.close();
        bw.close();
    }
}

转换流

        解决乱码问题

字符输入转换流:InputStreamReader

        可以把原始的字节流按照指定编码转换成字符输入流

字符输入转换流:OutputStreamWriter

        可以把字节输出流按照指定编码转换成字符输出流

public class DemoTransferTest {
    public static void main(String[] args) throws IOException {
        //1.创建InputStreamReader类的对象isr,指定编码表GBK,同时绑定源文件f9_gbk.txt
        InputStreamReader isr = new InputStreamReader(new FileInputStream("day12\f9_gbk.txt"), "GBK");

        //2.创建OutputStreamWriter类的对象osw,指定编码表UTF-8,同时绑定目标文件f13_utf8.txt
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day12\f13_utf8.txt"), "UTF-8");

        //3.字符数组循环读(源文件)写(目标文件)
        int len;
        char[] chs = new char[1024*8];
        while ((len = isr.read(chs)) != -1) {
            osw.write(chs, 0, len);
        }

        //4.关闭流释放资源
        isr.close();
        osw.close();
    }
}

序列化对象

        类要进行序列化 / 反序列化
        必须实现: java.io.Serializable接口 (序列化标记型接口)

对象序列化

作用:

        以内存为基础,把内存中的对象存储到磁盘文件中去,称为对象序列化

对象字节输出流:ObjectOutputStream

构造对象

序列化方法


对象反序列化

作用:

        以内存为基准,把存储到磁盘文件中去的对象数据恢复成内存中的对象,称为对象反序列化

对象字节输入流:ObjectInputStream

构造对象

序列化方法

public class Person implements Serializable {
    //定义一个永不变化的序列号
    //无论如何修改类的信息,该序列号不会发生变化
    private static final long serialVersionUID = 666888999L;
    private String name;

    //private int age;
    public int age;

    //private static int age;//被static修饰的内容,不能序列化
    //private transient int age;//被transient修饰的内容,不能序列化
    //toString方法,空参/满参构造,set/get方法

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

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class DemoReadWriterObject {
    public static void main(String[] args) throws Exception {
        writeObject();
        readObject();
    }
    //从文件读取一个对象出来
    private static void readObject() throws IOException, ClassNotFoundException {
        //1.创建InputStream类的子类FileInputStream对象fis,绑定源文件
        //InputStream is = new FileInputStream("day12\info.txt");
        //2.创建ObjectInputStream类对象,传递fis
        //ObjectInputStream ois = new ObjectInputStream(is);

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day12\info.txt"));

        //3.创建ObjectInputStream类对象调用readObject方法,从文件读取字节封装成对象并返回
        Person p = (Person) ois.readObject();
        System.out.println(p);

        //4.创建ObjectInputStream类对象调用close方法
        ois.close();
    }

    //把对象写出到文件
    private static void writeObject() throws IOException {
        //满参构造创建Person类的对象
        Person p = new Person("张三", 18);

        //1.创建OutputStream类的子类FileOutputStream对象fos,绑定目标文件
        //OutputStream os = new FileOutputStream("day12\info.txt");
        //2.创建ObjectOutputStream类对象,传递fos
        //ObjectOutputStream oos = new ObjectOutputStream(os);

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day12\info.txt"));

        //3.ObjectOutputStream类对象调用writeObject方法,把对象写出到目标文件
        oos.writeObject(p);

        //4.ObjectOutputStream类对象调用close方法
        oos.close();
    }
}

打印流 

作用:

        打印流可以实现方便、高效的打印数据到文件中去。
        可以实现打印什么数据就是什么数据,例如打印整数97写出去就是97;打印boolean的true,写出去就是true

PrintStream

构造对象

方法


PrintWriter

构造对象

方法

1.打印流有几种?各有什么特点?
        打印流一般是指:PrintStream,PrintWriter两个类。
        打印功能2者是一样的使用方式
        PrintStream继承自字节输出流OutputStream,支持写字节
        PrintWrite继承自字符输出流Writer,支持写字符


2.打印流的优势是什么?
        两者在打印功能上都是使用方便,性能高效(核心优势)

public class DemoPrinterWriter {
    public static void main(String[] args) throws FileNotFoundException {

        PrintWriter pw = new PrintWriter("day12\f14.txt");
        //PrintStream ps = new PrintStream("day12\f14.txt");

        //public void print(Xxx yyy): 原样输出不带换行
        pw.print(97);
        pw.print('b');
        pw.print(66.66);
        pw.print(true);
        pw.print("hello");
        //public void println(Xxx yyy): 原样输出带换行
        pw.println();
        pw.println(97);
        pw.println('b');
        pw.println(66.66);
        pw.println(true);
        pw.println("hello");
        //关闭流
        pw.close();
    }
}

commons-io

        commons-io是apache开源基金组织提供的一组有关IO操作的类库

        可以提高IO功能开发的效率,很多有关io操作的类,有两个主要的类FileUtils, IOUtils

作用:

        使用commons-io简化io流读写

使用方式:

        1.在项目中创建一个文件夹:lib
        2.将commons-io-x.x.jar文件复制到lib文件夹
        3.在jar文件上点右键,选择 Add as Library -> 点击OK
        4.在类中导包使用

FileUtils主要有如下方法

两个工具类:
IOUtils
    public static void copy(InputStream is,OutputStream os): 复制文件的
    public static void closeQuietly(...): 关闭资源,内部帮助我们处理异常

FileUtils
    public static void copyDirectoryToDirectory(File srcDir,File destDir): 拷贝文件夹
    public static void writeStringToFile(File file,String str): 写字符串到文本文件中。
    public static String readFileToString(File file): 读取文本文件,返回字符串。

 */
public class Demo05CommonsIO {
    public static void main(String[] args) throws IOException {
        //工具类静态方法,实现文件的复制
        IOUtils.copy(new FileInputStream("day12\io\copy\from\jzc.flv"),new FileOutputStream("day12\io\copy\to\jzc.flv"));

        //工具类静态方法,实现文件夹的复制
        FileUtils.copyDirectoryToDirectory(new File("day12\io"),new File("day12\abc"));

        //工具类静态方法,把字符串直接写入到文件中
        FileUtils.writeStringToFile(new File("day12\f13.txt"),"CommonsIO真TM好用!!!!");

        //工具类静态方法,从文件中读取字符串出来
        String str = FileUtils.readFileToString(new File("day12\f13.txt"));
    }
}

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/984438.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号