第十一章、IO流技术

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量89 收藏
点赞数
分类专栏： # JAVA专栏 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hbxrm/article/details/120529490
版权

一、输入输出IO流

1、数据源及流的概念

/**
 * 使用try-catch-finally经典语法结构，测试流的使用
 */
public class Test02 {

    public static void main(String[] args) {
        readFile();
        writeFile();
    }

    public static void readFile(){
        FileInputStream fis=null;
        try {
            fis=new FileInputStream("d:/b.txt");
            int s1=fis.read();
            int s2=fis.read();
            int s3=fis.read();
            int s4=fis.read();
            int s5=fis.read();

            System.out.println((char)s1);
            System.out.println((char)s2);
            System.out.println((char)s3);
            System.out.println((char)s4);
            System.out.println(s5); //由于文件内容已经读取完毕，返回-1

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //流对象用完后必须关闭，否则总是占用系统资源
            try {
                if(fis!=null){
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void writeFile(){
        FileOutputStream fos=null;
        try {
            fos=new FileOutputStream("d:/c.txt");
            fos.write('x');
            fos.write('r');
            fos.write('m');

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(fos!=null){
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
/**
 * 使用try-with-resource新语法结构，使用流对象
 */
public class Test03 {

    public static void main(String[] args) {
        readFile();
        writeFile();
    }

    public static void readFile(){
        try(FileInputStream fis=new FileInputStream("d:/b.txt");) {
            int s1=fis.read();
            int s2=fis.read();
            int s3=fis.read();
            int s4=fis.read();
            int s5=fis.read();

            System.out.println((char)s1);
            System.out.println((char)s2);
            System.out.println((char)s3);
            System.out.println((char)s4);
            System.out.println(s5); //由于文件内容已经读取完毕，返回-1

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void writeFile(){
        try(FileOutputStream fos=new FileOutputStream("d:/c.txt");) {
            fos.write('x');
            fos.write('r');
            fos.write('m');

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2、Java中流的概念细分

/**
 * 流的使用，经典代码
 */
public class Test04 {

    public static void main(String[] args) {

        writeFile();
        readFile();
//        copyFile("d:/主图2021年.jpg","d:/主图2021年_copy.jpg");
        copyFileBuffer("d:/主图2021年.jpg","d:/主图2021年_copy2.jpg");
    }

    public static void readFile(){

        try(FileInputStream fis=new FileInputStream("d:/c.txt")){

            StringBuilder sb=new StringBuilder();
            int tmp=0;
            while((tmp=fis.read())!=-1){
                sb.append((char)tmp);
            }

            System.out.println(sb);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static void writeFile(){

        try(FileOutputStream fos=new FileOutputStream("d:/c.txt")){

            fos.write("abcde".getBytes());

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //读一个字节，写一个字节，效率最低的原始版本
    public static void copyFile(String srcPath,String desPath){

        try(FileInputStream fis=new FileInputStream(srcPath);
            FileOutputStream fos =new FileOutputStream(desPath)){

            int tmp=0;
            while((tmp=fis.read())!=-1){
                fos.write(tmp);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //使用缓存，提高读取效率
    public static void copyFileBuffer(String srcPath,String desPath){

        try(FileInputStream fis=new FileInputStream(srcPath);
            FileOutputStream fos =new FileOutputStream(desPath)){

            byte[] buffer=new byte[1024];
            while((fis.read(buffer))!=-1){
                fos.write(buffer);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

二、IO流体系介绍

1、文件字符流

/**
 * 关于文件字符流的测试操作，实现了文本文件的拷贝
 */
public class TestFileReaderWriter {

    public static void main(String[] args) {

        try(FileReader fr=new FileReader("d:/a.txt");
            FileWriter fw=new FileWriter("d:/a_copy.txt");){
            int tmp=0;
            while((tmp=fr.read())!=-1){
                fw.write(tmp);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 2、缓冲字节流

/**
 * 测试缓冲字节流
 */
public class TestBufferInputOutputStream {

    public static void main(String[] args) {

        try(FileInputStream fis=new FileInputStream("d:/反诈视频3.mp4");
            FileOutputStream fos=new FileOutputStream("d:/反诈视频3_copy.mp4");
            BufferedInputStream bis=new BufferedInputStream(fis);
            BufferedOutputStream bos=new BufferedOutputStream(fos);){

            int tmp=0;
            while((tmp=fis.read())!=-1){
                bos.write(tmp);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

3、缓冲字符流

/**
 * 使用缓冲字符流
 */
public class TestBufferReaderWriter {

    public static void main(String[] args) {

        try(BufferedReader br=new BufferedReader(new FileReader("d:/a.txt"));
            BufferedWriter bw=new BufferedWriter(new FileWriter("d:/a2.txt"));){

            String tmpString="";
            while((tmpString=br.readLine())!=null){
                bw.write(tmpString);
                bw.newLine();
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4、字节数组流

/**
 * 使用字节数组流
 */
public class TestByteInputOutputStream {

    public static void main(String[] args) {

        test01("abcdefg".getBytes());
    }

    public static void test01(byte[] bytes){

        int tmp=0;
        int num=0;  //用于表示读取的字节数

        try(ByteArrayInputStream bis=new ByteArrayInputStream(bytes);){

            while((tmp=bis.read())!=-1){
                System.out.println((char)tmp);
                num++;
            }

            System.out.println("读取的字节数是："+num);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5、数据流

/**
 * 使用数据流
 */
public class TestDataInputOutputStream {

    public static void main(String[] args) {
//        writeData();
        readData();
    }

    public static void writeData(){

        try(DataOutputStream dos=new DataOutputStream(new FileOutputStream("d:/data.txt"));){

            dos.writeChar('a');
            dos.writeInt(10);
            dos.writeDouble(Math.random());
            dos.writeBoolean(true);
            dos.writeUTF("你好java!");

            //手动刷新缓冲区，将流中的数据写入到文件
            dos.flush();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void readData(){

        try(DataInputStream dis=new DataInputStream(new FileInputStream("d:/data.txt"))){

            //读取数据时，需要和写入的顺序保持一致！否则不能正确的读取数据
            System.out.println(dis.readChar());
            System.out.println(dis.readInt());
            System.out.println(dis.readDouble());
            System.out.println(dis.readBoolean());
            System.out.println(dis.readUTF());

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

6、对象流 

public class Users implements java.io.Serializable{

    private int id;
    private String uname;
    transient private String pwd;

    public Users() {
    }

    public Users(int id, String uname, String pwd) {
        this.id = id;
        this.uname = uname;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
}

public class TestObjectInputOutputStream {

    public static void main(String[] args) {

        writeObject();
        readObject();
    }

    public static void writeObject(){

        try(ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("d:/object_data.txt"))){

            ArrayList<Users> list=new ArrayList<>();
            list.add(new Users(1001,"张三","123456"));
            list.add(new Users(1002,"李四","123456"));
            list.add(new Users(1003,"王五","123456"));

            oos.writeObject(list);
            oos.flush();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void readObject(){

        try(ObjectInputStream ois=new ObjectInputStream(new FileInputStream("d:/object_data.txt"))){

            ArrayList<Users> list=(ArrayList) ois.readObject();

            for(Users u:list){
                System.out.println(u.getId()+","+u.getUname()+","+u.getPwd());
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

 7、转换流

/**
 * 测试转换流
 */
public class TestInputStreamReader {

    public static void main(String[] args) {

        try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out))){

            String str=br.readLine();

            while(!"exit".equals(str)){
                bw.write("键盘输入："+str);
                bw.newLine();
                bw.flush();

                str=br.readLine();
            }

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

8、任意访问文件流

/**
 * 测试任意访问文件流
 */
public class TestRandomAccessFile {

    public static void main(String[] args) {

        try(RandomAccessFile raf=new RandomAccessFile("d:/data2.txt","rw")){

            int[] data={10,20,30,40,50,60,70,80,90,100};

            for(int i=0;i<data.length;i++){
                raf.writeInt(data[i]);
            }

            //直接从data2.txt中读取数据，位置从第4字节开始
            raf.seek(4);
            System.out.println(raf.readInt());

            //在第8个字节处，插入一个新数据45，替换以前的数据30
            raf.seek(8);
            raf.writeInt(45);

            for(int i=0;i<10;i++){
                raf.seek(i*4);
                System.out.print(raf.readInt()+"\t");
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

三、Apache IO 包的使用

/**
 * 测试Apache Commons组件下的IO工具库
 */
public class TestApacheFileUtils {

    public static void main(String[] args) {

        writeFile();
        readFile();
        readURL();
        fileCopy();
        directoryCopy();
    }

    public static void writeFile(){

        StringBuilder sb=new StringBuilder();

        for(int i=0;i<1000;i++){
            sb.append(Math.random()+"\n");
        }

        try {
            FileUtils.write(new File("d:/apache-test.txt"),sb.toString(),"gbk");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void readFile(){

        try {
            List<String> content=FileUtils.readLines(new File("d:/apache-test.txt"),"gbk");
            for(String temp:content){
                System.out.println(temp);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void readURL(){

        try {

            URL url=new URL("http://www.baidu.com");
            InputStream is=url.openStream();
            String content=IOUtils.toString(is,"UTF-8");

            System.out.println(content);

        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void fileCopy(){
        File srcFile=new File("d:/a.txt");
        File desFile=new File("d:/aa.txt");

        try {
            FileUtils.copyFile(srcFile,desFile);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void directoryCopy(){
         File dir1=new File("d:/tmp");
         File dir2=new File("d:/tmp2");

        try {

            FileUtils.copyDirectory(dir1, dir2, new FileFilter() {
                @Override
                public boolean accept(File pathname) {
                    if(pathname.isDirectory()||pathname.getName().endsWith("jpg")){
                        return true;
                    }else{
                        return false;
                    }
                }
            });


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

hbxrm
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第12章_IO流
一颗_豆芽菜的博客
01-08 72
第12章_IO流
第十一章：C++的IO流
m0_63027727的博客
03-22 1309
第十一章：C++的IO流 1.C语言的输入输出 C语言中我们用到的最频繁的输入输出方式就是scanf ()与printf()。 scanf(): 从标准输入设备(键盘)读取数据，并将值存放在变量中。 printf(): 将指定的文字/字符串输出到标准输出设备(屏幕)。注意宽度输出和精度输出控制。 C语言借助了相应的缓冲区来进行输入与输出。 对输入输出缓冲区的理解： ①可以屏蔽掉低级I/O的实现，低级I/O的实现依赖操作系统本身内核的实现，所以如果能够屏蔽这部分的差异，可以很容易写出可移植的程序。 ②可以使
第十五章、 Io流
qq_64226679的博客
08-29 1063
节点流是直接从特定数据源读写数据的流，它们是I/O系统中的基础流，提供了最基本的读写功能。节点流通常与具体的数据源（如文件、网络连接等）直接相关联，如FileReader、FileWriter。分类字节输入流字节输出流字符输入流字符输出流抽象基类ReaderWriter访问文件FileReaderFlieWriter访问数组访问管道访问字符串处理流是对节点流的包装，它们提供了更高级的功能，如缓冲、行处理、转换等。
第十九章 IO流
你好, 我在学java的博客
12-10 1045
OutputStreamWriter是Writer的子类，实现将OutputStream(字节流)包装成Writer(字符流)；InputStreamReader是Reader的子类，可以将InputStream(字节流)包装成Reader(字符流)当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流。不同分为：字节流(8 bit)对于二进制文件，字符流(按字符) 对应文本文件。不能读取二进制文件【音频，视频，文档，图片】，造成文件损坏；
C++程序设计第11章C++的IO流类库.ppt
11-06
本章主要探讨了C++的IO流库，包括流的概念、格式化输入输出、磁盘文件的I/O以及字符串流和错误处理。 首先，流是C++中用于输入输出的一组类，分为文本流和二进制流。文本流处理的是以字符为单位的数据，而二进制流...
尚硅谷_宋红康_第13章_IO流.pdf
07-05
·自Java语言起源始，循序渐进，知识点剖析细致且每章配备大量随堂练习，让你步步为营，学得透彻、练得明白 ·拒绝晦涩难懂的呆板教学，宋老师语言生动幽默，举例形象生动深入浅出，迅速让你把握问题本质，四两拨千...
java开发实战经典第十一章课后习题答案
05-20
第十一章通常会涉及一些高级话题或实际应用案例，可能是关于集合框架、多线程、网络编程、IO流或者异常处理等内容。课后习题是检验学习成果、提升编程技能的重要环节，通过解答这些问题，初学者可以巩固理论知识，...
《UNIX环境高级编程》笔记 第十八章-终端IO
Nick_Di的博客
11-19 795
1. 终端I/O概述 1.1 规范和非规范模式 终端I/O有两种不同的工作模式： 规范模式输入处理：对终端输入以行为单位进行处理。对于每个读请求，最多返回一行。 非规范模式输入处理：输入字符不装配成行 若不做特殊处理，则终端I/O默认模式是规范模式。处理整个屏幕的程序（如vi编辑器）使用非规范模式。 1.2 特殊输入字符 POSIX.1定义了11个特殊输入字符，例如文件结束符（Ctrl+D）和挂起字符（Ctrl+Z），其中9个可以更改。 1.3 终端设备的输入输出队列 终端设备由位于内核中的终端驱动程序
第十一章1
08-08
德塔编译机起源于德塔Socket流可编程数据库系统的PLSQL编译机，随着时间的推移，它逐渐演变为独立的脚本编码编译机，并在与ETL、TCP等技术的结合中不断扩展功能。在肽化索引之后，德塔编译机还被应用于神经元ETL节点...
spring事务详细讲解-深入浅出
小电玩
09-08 431
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1431
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1361
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 460
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
自定义Stater
m0_63624484的博客
09-07 696
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 503
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
央顺科技官方博客
09-05 560
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
MyBatis面试
Tony_yitao的博客
09-09 563
MyBatis面试
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 311
步骤很详细，直接上教程……
Java第12章：IO流与数据持久化技术详解
总结来说，本章Java第十二章主要讲解了如何使用IO流进行数据操作以及数据持久化在实际项目中的应用，包括数据库连接、文件操作的API和常见用法。熟练掌握这些内容有助于编写高效且可维护的Java程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值