Java流的体系结构（一）

最新推荐文章于 2024-05-18 16:42:38 发布
最新推荐文章于 2024-05-18 16:42:38 发布
阅读量172 收藏 1
点赞数 1
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lalalalalab/article/details/133293219
版权

文章目录

提示：以下是本篇文章正文内容，下面案例可供参考

一、文件读写操作FileReader和FileWriter

1.main()

public static void main(String[] args) {
        File file = new File("hello.txt");  //相较于当前工程
        System.out.println(file.getAbsolutePath());

        File file1 = new File("day04\\hello.txt");
        System.out.println(file.getAbsolutePath());
    }

2.FileReader

1.说明：

1.将hello.txt文件内容读入到程序中，并输出到控制台4
2…read()的处理，返回读入的一个字符，如果达到文件末尾，返回-1
3.异常的处理：为了保证流资源一定可以执行关闭操作，需要使用try-catch-finally处理
4.读入的文件一定要存在，否则就会报FileNotFoundException.

2.代码案例

public void testFileReader()  {
        FileReader fr = null;
        try{
            //1.实例化File类的对象，指明要操作的文件
            File file = new File("hello.txt"); //相较于当前Module
            //System.out.println(file.getAbsolutePath());

            //2.提供具体的流
            fr = new FileReader(file);

            //3.数据的读入
            //read():返回读入的一个字符。如果到达文件末尾，返回-1.
//        方式一：
//        int data = fr.read();
//        while(data != -1){
//            System.out.print((char)data);
//            data = fr.read();
//        }

            //方式二： 语法上针对于方式一的修改
            int data;
            while((data = fr.read())!=-1){
                System.out.println((char)data);
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally {
            //4.流的关闭操作
            try{
                if(fr!=null)
                    fr.close();
            }catch(IOException e){
                e.printStackTrace();
            }

        }
    }

3.对read()操作升级：使用read的重载方法

public void testFileReader1() {
        FileReader fr = null;
       try{
           //1.File类的实例化
           File file = new File("hello.txt");

           //2.FileReader流的实例化
            fr = new FileReader(file);

           //3.读入的操作
           //read(char[] cbuf) :返回每次读入到cbuf数组中的字符的个数。
           //如果达到文件末尾，返回-1。
           char[] cbuf = new char[5];
           int len;
           while((len = fr.read(cbuf))!=-1){
               //错误的写法
//               for(int i = 0;i < cbuf.length;i++){
//                   System.out.print(cbuf[i]);
//               }
                //方式一：
//               for (int i = 0; i < len; i++) {
//                   System.out.print(cbuf[i]);
//
//               }

               //方式二：错误！
//               String str = new String(cbuf);
//               System.out.println(str);

               //正确
               String str = new String(cbuf,0,len);
               System.out.print(str);

           }
       }catch(IOException e){
           e.printStackTrace();
       }finally {
           //4.流的关闭操作
           try{
               if(fr!=null)
                   fr.close();
           }catch(IOException e){
               e.printStackTrace();
           }
       }
    }

4.FileWriter的使用

1.说明

1.从内存中写出数据到硬盘的文件里。
2.输出操作，对应的File可以不存在的，并不会报异常
3.File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件
4.File对应的硬盘中的文件如果存在，
//如果流使用的构造器是： FileWriter(file,false)/(FileWriter(file))：对原有文件的覆盖
//如果流使用的构造器是：FileWriter(file,true)：不会对原有文件覆盖，而是追加。

2.代码

public void testFileWriter()  {
        FileWriter fw = null;

        try{
            //1.提供File类的对象，指明写出到的文件
            File file = new File("hello1.txt");

            //2.提供FileWriter的对象，用于数据的写出
            fw = new FileWriter(file,true);

            //3.写出的操作
            fw.write("I have a dream!\n");
            fw.write("you need to have a dream!");
        }catch(IOException e){
            e.printStackTrace();
        }
        finally {
            //4.流的关闭操作
            try{
                if(fw!=null)
                    fw.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }

    }

4.FileReader和FileWriter综合使用

public void testFileReaderFileWriter(){
        FileReader fr = null;
        FileWriter fw = null;
        try{
            //1.创建File类的对象，指明读入和写出的文件
            File srcFile = new File("hello.txt");
            File destFile = new File("hello2.txt");

            //不能使用字符流来处理图片等字节数据
//            File srcFile = new File("111.jpg");
//            File destFile = new File("2.jpg");

            //2.创建输入流和输出流的对象
            fr = new FileReader(srcFile);
            fw = new FileWriter(destFile);

            //3.数据的读入和写出操作
            char[] cbuf = new char[5];
            int len;//记录每次读入到cbuf数组中的字符的个数
            while((len = fr.read(cbuf))!= -1){
                //每次写出len个字符
                fw.write(cbuf,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //4.关闭数据流
            try{
                if(fw!=null)
                    fw.close();
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                try{
                    if(fr!=null)
                        fr.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

二、使用步骤

1.引入库

代码如下（示例）：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import  ssl
ssl._create_default_https_context = ssl._create_unverified_context

二、测试FileInputStream和FileOutputStream的使用

1.结论

1.对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理
2.对于非文本文件(.jpg,.mp3,.mp4,.avi.doc,.ppt,…)，使用字节流处理

2.使用字节流FileInputStream处理文本文件，可能出现乱码

public void testFileInputStream(){
        FileInputStream fis = null;
        try{
            //1.造文件
            File file = new File("hello.txt");
            //2.造流
             fis = new FileInputStream(file);

            //3.读数据
            byte[] buffer = new byte[5];
            int len; //记录每次读取的字节的个数
            while((len = fis.read(buffer)) != -1){
                String str = new String(buffer,0,len);
                System.out.println(str);
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(fis != null){
                    fis.close();
                }
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }

3.实现对图片的复制操作

public void testFileInputOutputStream(){
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try{
            File srcFile = new File("111.jpg");
            File destFile = new File("2.jpg");

            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);

            //复制的过程
            byte[] buffer = new byte[5];
            int len;
            while((len = fis.read(buffer))!= -1){
                fos.write(buffer,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fos != null){
                try{
                    fos.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }


    }

3.指定路径下的文件的复制

public void copyFile(String srcPath,String destPath){
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try{
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);

            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);

            //复制的过程
            byte[] buffer = new byte[1024];
            int len;
            while((len = fis.read(buffer))!= -1){
                fos.write(buffer,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fos != null){
                try{
                    fos.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }


    @Test
    public void testCopyFile(){
        long start = System.currentTimeMillis();
        String srcPath = "C:\\Users\\asus\\Desktop\\1.mp4";
        String destPath = "C:\\Users\\asus\\Desktop\\2.mp4";

        copyFile(srcPath,destPath);

        long end = System.currentTimeMillis();
        System.out.println("复制操作花费的时间为："+(end-start));

    }

三、处理流之一：缓冲流的使用

1.缓冲流

BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter

2.作用

提供流的读取、写入的速度
提高读写速度的原因，内部提供了一个缓冲区

3.处理流，就是“套接”在已有的流的基础上

4.实现非文本文件的复制BufferedInputStream和BufferedOutputStream

public void BufferedStreamTest(){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try{
            //1.造文件
            File srcFile = new File("111.jpg");
            File destFile = new File("222.jpg");

            //2.造流
            //2.1  造节点流
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2造缓冲流
             bis  = new BufferedInputStream(fis);
             bos = new BufferedOutputStream(fos);

            //3.复制的细节：读取、写入
            byte[] buffer = new byte[10];
            int len;
            while((len = bis.read(buffer))!=-1){
                bos.write(buffer,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。
            //关于内层流的关闭，我们可以省略
            if(bos!= null){
                try{
                    bos.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            if(bis!=null){
                try{
                    bis.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

5.实现文件复制的方法BufferedInputStream和BufferedOutputStream

public void copyFileWithBufferd(String srcPath,String destPath){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try{
            //1.造文件
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);

            //2.造流
            //2.1  造节点流
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2造缓冲流
            bis  = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //3.复制的细节：读取、写入
            byte[] buffer = new byte[1024];
            int len;
            while((len = bis.read(buffer))!=-1){
                bos.write(buffer,0,len);

//                bos.flush();//刷新缓冲流
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。
            //关于内层流的关闭，我们可以省略
            if(bos!= null){
                try{
                    bos.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            if(bis!=null){
                try{
                    bis.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
public void testCopyFileWithBuffered(){
        long start = System.currentTimeMillis();
        String srcPath = "C:\\Users\\asus\\Desktop\\1.mp4";
        String destPath = "C:\\Users\\asus\\Desktop\\3.mp4";

        copyFileWithBufferd(srcPath,destPath);

        long end = System.currentTimeMillis();
        System.out.println("复制操作花费的时间为："+(end-start));
    }

6.使用BufferedReader和BufferedWriter实现文本文件的复制

public void testBufferedReaderBufferedWriter(){
        BufferedReader br = null;
        BufferedWriter bw = null;
       try{
           //1.创建文件和相应的流
            br = new BufferedReader(new FileReader(new File("hello.txt")));
            bw = new BufferedWriter(new FileWriter(new File("hello3.txt")));

           //2.读写操作
           //方式一：
//           char[] cbuf = new char[1024];
//           int len;
//           while((len = br.read(cbuf))!=-1){
//               bw.write(cbuf,0,len);
            bw.flush();
//           }

           //方式二：
           String data;
           while((data = br.readLine())!=null){
               //方法一：
//               bw.write(data+"\n");  //data不包含换行符
               //方法二：
               bw.write(data);
               bw.newLine();  //提供换行的操作

           }


       }catch(IOException e){
           e.printStackTrace();
       }finally {
           //3.关闭资源
           try{
               if(bw!=null)
                   bw.close();
           }catch (IOException e){
               e.printStackTrace();
           }
           try{
               if(br!=null)
                   br.close();
           }catch (IOException e){
               e.printStackTrace();
           }
       }
    }

四、处理流之二：转换流的使用

1.概念：

转换流:属于字符流
InputstreamReader: 将一个字节的输入流转换为字符的输入流Outputstreamwriter: 将一个字符的输出流转换为字节的输出流

2.作用

提供字节流与字符流之间的转换

3.InputStreamReader

//此时处理异常的话，仍然应该使用try-catch-finally
    //InputStreamReader的使用，实现字节的输入流到字符的输入流的转换

    @Test
    public void test1() throws IOException {
        FileInputStream fis = new FileInputStream("hello.txt");
//        InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集
    //参数2指明了字符集，具体使用哪个字符集，取决于文件hello.txt保存时使用的字符集
    InputStreamReader isr = new InputStreamReader(fis,"UTF-8");

    char [] cbuf = new char[20];
    int len;
    while((len = isr.read(cbuf))!=-1){
        String str = new String(cbuf,0,len);
        System.out.print(str);
    }

    isr.close();
    }

4.InputStreamReader和OutputStreamWriter

 //此时处理异常的话，仍然应该使用try-catch-finally
    //综合使用InputStreamReader和OutputStreamWriter
    @Test
    public void test2() throws IOException {
        //1.造文件  造流
        File file1 = new File("hello.txt");
        File file2 = new File("hello_gbk.txt");

        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

        //读写过程
        char [] cbuf = new char[20];
        int len;
        while((len = isr.read(cbuf))!=-1){
            osw.write(cbuf,0,len);
        }

        //3.关闭资源
        isr.close();
        osw.close();


    }

五、流的分类以及流的体系结构

在这里插入图片描述

六、输入、输出的标准化过程

1.输入

在这里插入图片描述

2.输出

在这里插入图片描述

IT女孩儿
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java IO层次体系结构
徐冉的博客
10-10 4480
在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader；一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了       Java I/O主要包括如下几个层次，包含三个部分：    1.流式部分――IO的主体部分；    2.非流式...
Java IO流体系继承结构图_动力节点Java学院整理
08-30
主要介绍了Java IO流体系继承结构图,非常不错，具有参考借鉴价值，需要的朋友可以参考下
Java IO流体系结构
weixin_44016361的博客
08-03 154
IO流体系结构 一般情况下在程序中使用缓冲流 抽象基类 InputStream OutputStream Reader Writer 文件流 FileInputStream FileOutputStream FileReader FileWriter 缓冲流：提高程序的流读写速度。分为处理字节和处理字符的缓冲流。 能够提高读写速度的原因：缓冲流提供了一个缓冲区，将读到的字节存放在缓冲区中，直到缓冲区达到一定的量后一次性写入文件，减少了写入次数，所以提高了写入速度。 flush方法，刷新缓冲区，当
java io体系_java IO流的体系结构图
weixin_30391353的博客
02-13 125
常用字节流字符流字节流 InputStream 字符流 ReaderFileInputStream ...
Java IO流的层次结构
keep on moving
12-03 2468
1.字节I/O流结构 (1)InputStream的结构 字节输入流 InputStream是一个抽象父类，不可以直接使用，我们使用的是它的子类： 1. ByteArrayInputStream 从byte[]数组中以字节的方式读取 2. FileInputStream 从文件中以字节为单位读取 3. FilterInputStream 用来封装其他输入流 1. BufferInputStrea...
【Java.IO】I/O 流的类体系结构
王晓斌的专栏
09-26 3585
。。。
Java IO流体系结构图
qq_44972915的博客
03-29 791
Java IO流体系结构图 留个坑吧，等面上工作有时间后把IO的各个原理详细理一遍
简述java异常体系_Java异常体系结构 .
weixin_30002151的博客
02-24 1942
一、 异常的概念和Java异常体系结构异常是程序运行过程中出现的错误。本文主要讲授的是Java语言的异常处理。Java语言的异常处理框架，是Java语言健壮性的一个重要体现。Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。Java异常体系结构...
IO流体系继承结构图_动力节点Java学院整理
10-25
Java IO体系结构看似庞大复杂,其实有规律可循,要弄清楚其结构,需要明白两点: 1. 其对称性质:InputStream 与 OutputStream, Reader 与 Writer,他们分别是一套字节输入-输出,字符输入-输出体系 2. 原始处理器(适配器)...
01 JVM 与 Java 体系结构.pptx
06-10
Java 技术体系和 JVM 整体概览. 对 JVM 有一个整体认知， 打好 JVM 学习的基础。内容包括体系结构， JVM相关基础知识和流行的 JVM 介绍。
586.584.JAVA基础教程_IO流-IO流的体系结构(586).rar
11-09
586.584.JAVA基础教程_IO流-IO流的体系结构(586).rar
CS结构的TCP服务器-Java代码.rar
07-10
CS结构的TCP服务器-Java代码，TCP服务器端代码如下： 　public class SocketServerDemo{ 　int port=2345; //端口号 　ServerSocket serverSocket; //服务器套接字 　public SocketServerDemo(){ 　try{ 　 ...
Java学习(尚硅谷)IO流学习之流的体系结构(节点流+缓冲流)
m0_55895641的博客
05-01 209
package com.atguigu.java; import org.junit.Test; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; /** * 一、流的分类 * 1.操作数据单位不同：字节流、字符流 * 2.数据的流向：输入流、输出流 * 3.流的角色：节点流、处理流 * <p> * 二、流的体系结构 *.
jar包增量更新分析
junlaiyan的专栏
05-16 263
借助jdeps分析出jar包的增量文件
SpringBoot接入Knife4j接口文档
最新发布
博主是个二次元死肥宅~
05-18 680
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
java实现拼图小游戏
monkey108的博客
05-16 622
本文主要提供用java实现的拼图小游戏源代码。
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 914
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
命令执行漏洞（二）
XLbb的博客
05-15 906
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 248
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
InputStream体系结构图？
12-09
根据引用[2]所述，Java的流相关的类都封装在java.io包中，而且每个数据流都是一个对象。所有输入流类都是InputStream抽象类（字节输入流）和Reader抽象类（字符输入流）的子类。其中InputStream类是字节输入流的抽象...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值