Java基础知识点 IO流（二）

最新推荐文章于 2024-10-11 17:30:36 发布
最新推荐文章于 2024-10-11 17:30:36 发布
阅读量153 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdnnbyyds/article/details/131333579
版权

字节流读写文本文件内容，容易乱码。

字符流适合读取文本文件内容 

每次读取一个字符返回，   public int read()

 public static void main(String[] args) {
        try (Reader fr=new FileReader("java01\\src\\main\\java\\lian02\\b.txt");){
            int c;//记住每次读取的字符编号
            while ((c = fr.read()) !=-1){
                System.out.print((char)c);  //把c强制转换成字符
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

每次用一个字符数组读取数据

public static void main(String[] args) {
        try (Reader fr=new FileReader("java01\\src\\main\\java\\lian02\\b.txt");){
            char[] chars=new char[3];
            int len;  //记住每次读取多少个字符
            while ((len = fr.read(chars)) !=-1){
                //读取多少倒出多少
                System.out.println(new String(chars, 0, len));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

字符输出流

 

 public static void main(String[] args) {
        try(Writer fw = new FileWriter("java01\\src\\main\\java\\lian02\\b.txt",true);) {
            //写入一个字符
            fw.write('a');
            fw.write("\r\n");    //换行符
            fw.write("我爱中国");
            fw.write("\r\n");
            fw.write(97);
            //把字符串一部分长度写出来
            fw.write("我爱中国人",0,2);
            fw.write("\r\n");
            char[] buffer={'我','爱','中','国','a'};
            fw.write(buffer);
            fw.write(buffer,0,3);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

字节流适合做一切文件的拷贝（音视频,文本）；字节流不适合做文本输出

字符流适合做文本文件的操作（读，写）。

缓冲流（对原始流包装，以提高原始流读写数据性能）

 

 字节缓冲流

 public static void main(String[] args) {
        //字节缓冲流
        try( InputStream is = new FileInputStream("java01\\src\\main\\java\\lian02\\b.txt");
             InputStream bis=new BufferedInputStream(is);
             OutputStream os = new FileOutputStream("java01\\src\\main\\java\\lian02\\c.txt");
             OutputStream bos=new BufferedOutputStream(os);
             )
        {
         byte[] bytes=new byte[1024];
         int len;
         while ((len = bis.read(bytes)) != -1){
             bos.write(bytes,0,len);
         }
            System.out.println("复制完成");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

 字符缓冲流输入流

  public static void main(String[] args) {
        try(  Reader fr = new FileReader("java01\\src\\main\\java\\lian02\\b.txt");
              //这里不用多态封装，是因为BufferReader自带有readLine()方法。
              BufferedReader br=new BufferedReader(fr);)
        {
//          char[] buffer=new char[3];
//          int len;
//          while ((len =br.read(buffer)) !=-1) {
//              System.out.println(new String(buffer,0,len));
//          }
            //用BufferReader带有的ReadLine方法
            String line;  //记住每次读取的一行数据
            while (( line = br.readLine()) !=null){
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

字符缓冲输出流

BufferWriter多了新功能换行，newLine()

public static void main(String[] args) {
        try ( Writer fw = new FileWriter("java01\\src\\main\\java\\lian02\\b.txt",true);
              BufferedWriter bw=new BufferedWriter(fw);)
        {
            bw.newLine();
           bw.write('p');
           bw.write('中');
           bw.write("China");
           char[] buffer={'我','爱','中','国'};
           bw.write(buffer);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

 案例-给诗排序

给诗排序，并存到另一个文件中

public static void main(String[] args) {
        try (BufferedReader br=new BufferedReader(new FileReader("java01\\src\\main\\java\\lian02\\b.txt"));
             BufferedWriter bw=new BufferedWriter(new FileWriter("java01\\src\\main\\java\\lian02\\a.txt"));
        )
        {
            List<String> list=new ArrayList<>();
            String line; //按照行读
            while ((line = br.readLine()) != null) {
                list.add(line);
            }
            Collections.sort(list);
            System.out.println(list);
            for (String s : list) {
                bw.write(s);
                bw.newLine();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

原始流和缓冲流性能分析

 private static final String diZhi01 = "D:\\video\\video01.mp4";
    private static final String diZhi02 = "D:\\video00\\video.mp4";
    public static void main(String[] args) {
        copy02();
        copy03();
        copy04();
    }
    //低级字节输出流
    public static void copy01(){
        long startTime = System.currentTimeMillis();
        try(InputStream is=new FileInputStream(diZhi01);
            OutputStream os=new FileOutputStream(diZhi02);
            )
        {
            int b;
            while ((b=is.read()) !=-1){
                os.write(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("低级字节输出流消耗时间为"+(endTime - startTime) / 1000.0 +"s");

    }
    //低级字节数组输出流
    public static void copy02(){
        long startTime = System.currentTimeMillis();
        try( InputStream is=new FileInputStream(diZhi01);
             OutputStream os=new FileOutputStream(diZhi02);)
        {
           byte[] buffer=new byte[1024];
           int len;
           while ((len = is.read(buffer)) !=-1){
               os.write(buffer,0,len);
           }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("低级数组消耗时间"+(endTime-startTime) / 1000.0 +"s");
    }
    //使用高级缓冲字节
    public static void copy03(){
        long startTime = System.currentTimeMillis();
        try ( BufferedReader br = new BufferedReader(new FileReader(diZhi01));
              BufferedWriter bw= new BufferedWriter(new FileWriter(diZhi02));)

        {
            int b;
            while ((b = br.read()) !=-1){
                bw.write(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("高级字节缓冲流消耗时间" + (endTime - startTime) / 1000.0 +"s");
    }
    //高级缓冲字节数组流
    public static void copy04(){
        long startTime = System.currentTimeMillis();
        try( Reader is=new FileReader(diZhi01);
             BufferedReader br=new BufferedReader(is);
             Writer os=new FileWriter(diZhi02);
             BufferedWriter bw=new BufferedWriter(os);
             )
        {
            char[] buffer=new char[1024];
            int len;
            while ((len = br.read(buffer)) !=-1){
                bw.write(buffer,0,len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("高级缓冲数组消耗时间"+(endTime-startTime) / 1000.0 +"s");
    }

 

字符输入转换流（重要）

 把GBK文件读取出来

public static void main(String[] args) {
        try(
             //1.得到文件的原始字节流
             InputStream is=new FileInputStream("java01\\src\\main\\java\\lian02\\b.txt");
             //2.把原始的字节输入流按着指定的字符集编码转换成字符输入流
             Reader isr=new InputStreamReader(is,"GBK");
             //3.把字符输入流包装成缓冲字符输入流
             BufferedReader br=new BufferedReader(isr);)
        {
           String line;
           while ((line = br.readLine()) != null){
               System.out.println(line);
           }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

字符输出转换流

需要控制写出去的字符使用什么字符集编码，该怎么办？

1.调用String的getBytes方法解决

       String data = "我爱你中国";
       byte[] bytes=data.getBytes("GBK");

2.字符输出转换流

public static void main(String[] args) throws UnsupportedEncodingException {
        try ( //1.得到原始的字节输出流
              OutputStream os=new FileOutputStream("java01\\src\\main\\java\\lian02\\b.txt");
              //2.将原始的字节输出流，按着指定编码转换成字符输出流
              Writer writer = new OutputStreamWriter(os, "GBK");
              //3.将字符输出流封装为缓冲字符输出流
              BufferedWriter bw= new BufferedWriter(writer);)
        {
            bw.write("我");
            bw.write("爱");
            bw.write("你");
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

打印流

 public static void main(String[] args) throws UnsupportedEncodingException {
        try (
                PrintStream ps = new PrintStream("java01\\src\\main\\java\\lian02\\b.txt", Charset.forName("GBK"));
        )
        {
            ps.println("wo");
            ps.println("江南江北一条街");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

 PrintStream和PrintWriter用法基本上差不多，打印数据没有区别，写数据上有区别。

  高级流后面不能直接写追加，高级流封装低级流，在低级流中写追加。

数据流

IO-序列化流

对象序列化：把Java对象写入到文件当中去

对象反序列化：把文件里的Java对象读取出来

 

 对象如果需要序列化，必须实现序列化接口

首先创建对象类，必须实现Serializable接口

public class User implements Serializable {
    private String loginName;
    private String userName;
    private int  age;
    private String passWord;

    public User() {
    }

    public User(String loginName, String userName, int age, String passWord) {
        this.loginName = loginName;
        this.userName = userName;
        this.age = age;
        this.passWord = passWord;
    }

    public String getLoginName() {
        return loginName;
    }

    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    @Override
    public String toString() {
        return "User{" +
                "loginName='" + loginName + '\'' +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                ", passWord='" + passWord + '\'' +
                '}';
    }
}

序列化对象三步走

public class Test05 {
    public static void main(String[] args) {
        try (
                //2.创建对象字节输出流包装原始的对象字节输出流
                ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("java01\\src\\main\\java\\lian02\\b.txt"));)
        {
            //1.创建一个java对象
            User user=new User("admin","张三",23,"666777xx");
            //3.序列化对象到文件中去
            os.writeObject(user);
            System.out.println("序列化对象成功");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

对象字节输入流

 

public class Test05 {
    public static void main(String[] args) {
        try {
            //1.建立对象序列化输入流管道，封装原始字节输入流
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("java01\\src\\main\\java\\lian02\\b.txt"));
            User user = (User) ois.readObject();
            System.out.println(user);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

成员变量中，加上transient修饰符，将不参与序列化

先用ArrayList<User> 集合封装对象

 public static void main(String[] args) {
        try( ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("java01\\src\\main\\java\\lian02\\a.txt"));)

        {
            User user1=new User("admin","张三",23,"666777xx");
            User user02=new User("admin2","李四",20,"98980xx");
            User user03=new User("admin3","王五",24,"909000ll");
            ArrayList<User> list=new ArrayList<>();
            list.add(user1);
            list.add(user02);
            list.add(user03);
            oos.writeObject(list);
            System.out.println("序列化成功");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

将ois.readObject（）强制转换成ArrayList<User> 类型

 public static void main(String[] args) {
        try(ObjectInputStream ois = new ObjectInputStream(new FileInputStream("java01\\src\\main\\java\\lian02\\a.txt"));)
        {
            ArrayList<User> o = (ArrayList<User>) ois.readObject();
            for (User user : o) {
                System.out.println(user);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

IO-流框架

 

 静态方法，直接调用

FileUtils.copyFile();   

deidei的小跟班
关注
使用try自动关闭流报错排查
lixiangxiang666的博客
02-12 1445
一、使用try自动关闭流报错 1.附上自己自动关闭流的代码 try (InputStream is = new FileInputStream("D:\\lx-studyResources\\example.xlsx");OutputStream out = new FileOutputStream("D:\\lx-studyResources\\example.xlsx")){ XS...
JavaIO流知识点总结
ojemmm的博客
10-14 1678
知识点 package IO流原理与概念; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.ByteArrayInputStream; import...
【IO】FileInputStream
yhl_jxy的博客
02-11 1405
一 FileInputStream概述 FileInputStream为文件输入流，以字节流的形式读取文件内容，比如图片文件等等。 FileInputStream是InputStream的子类，我们可以把FileInputStream赋值给InputStream使用。 如果我们要以字符流形式读取文件内容，可以使用FileReader类处理。 二 FileInputStream实例分析
java IO流
qq_36827283的博客
12-24 246
java IO流,FIle类,序列化,反序列化
java io难_Java基础IO流 ，文件读取，由易至难
weixin_34858011的博客
02-23 224
最基础的读取文件import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;public class FileIOTest {public static void main(String[] args) {File file = ...
InputStream方法详解
loveyu0428的专栏
01-30 1832
InputStream这个抽象类是所有基于字节的输入流的超类，抽象了Java的字节输入模型。在这个类中定义了一些基本的方法。看一下类的定义： public abstract class InputStream implements Closeable&lt;/span&gt; 首先这是一个抽象类，实现了Closeable接口，也Closeable接口又拓展了AutoCloseable接口，因...
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
Java基础知识总结（2021版）
热门推荐
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
java基础之IO流
06-18
### Java IO流基础知识点 #### 一、IO流概述 - **定义**：在Java中，IO流（Input/Output Streams）是用来处理输入输出的基本工具。流是一种有序的数据集合，通常涉及从源到目的地的数据传输过程。源可以是文件、...
java基础的知识点，到IO流
01-22
"java基础知识点" java是面向对象编程语言，具有封装、...java基础知识点包括类和文件、封装性、参数和实参、值传递和引用传递、方法重载和重写、构造方法、this和super、静态变量和静态方法、单例设计模式、IO流等。
Java基础知识点总结.docx
04-03
以下是对这些知识点的详细说明： 一、Java概述： Java是由Sun Microsystems开发的一种跨平台的编程语言，它具有“一次编写，到处运行”的特性，通过Java虚拟机（JVM）实现平台无关性。Java有丰富的类库支持，适用于...
Java中IO流知识点总结
12-22
　二、流功能分析 　读取流是从输入设备或数据对象中读取数据到程序，用程序进行处理读入的数据，写出流是把程序处理的数据输出到 　输出设备上比如硬盘和控制台。 　字节流读取和写入的数据单位是字节，可以...
java基础 IO流
09-05
通过上述知识点，可以看出文档详细地总结了Java基础中IO流的概念、分类以及使用方法，并通过实际的代码示例加深理解。这些知识对于Java初学者来说是非常重要的，它们不仅涉及到文件的基本操作，还包括了对IO流深入的...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1395
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
JDK1.0主要特性
FoolRabbit的专栏
10-06 759
JDK1.0主要特性。
Backend - Java 基础
最新发布
是萝卜干呀的博客
10-11 442
知识量决定了未来能走多远
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1644
2024最新Java面试题，针对一些小厂，中厂
Spring Boot 整合 Minio
cmh1008611的博客
10-09 904
5‌‌.Optional‌是Java 8引入的一个新的容器对象，它提供了非常丰富的API，主要是为了解决空指针异常的问题。Optional类允许你创建一个可能为null的值的容器，从而避免了直接使用null值可能导致的空指针异常。自动处理异常：在使用 @SneakyThrows 注解的方法中，如果抛出任何类型的检查性异常（即编译器要求显式捕获或声明的异常），Lombok 会自动将其包装成运行时异常（RuntimeException），从而避免了需要显式捕获或声明这些异常的麻烦。可以用于自动装配和依赖注入。
【含开题报告+文档+PPT+源码】基于SSM框架的线上交易商城的设计与实现
码蜂窝编程-全网唯一毕设在线答疑，项目包运行成功，全套教学视频一站式辅导机构。
10-07 737
本课程演示的是一款校园二手交易系统，主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的 Java 学习者。包含：项目源码、项目文档、数据库脚本、软件工具等所有资料带你从零开始部署运行本套系统该项目附带的源码资料可作为毕设使用系统主要功能有：登录注册、公告管理、用户管理、商品管理、商品搜索、购物车、订单管理、用户私聊等模块。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值