JAVA进阶学习13

最新推荐文章于 2024-09-12 11:08:51 发布
最新推荐文章于 2024-09-12 11:08:51 发布
阅读量745 收藏 26
点赞数 9
文章标签： java 学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62770407/article/details/140568407
版权

文章目录

本文接上篇 进阶12所写，继续学习IO流

2.2.3 综合输入和输出方法进行文件拷贝

public static void main(String[] args) {
       /*
       * 利用try...catch...finally捕获拷贝文件中代码出现的异常
       */

        //1.创建对象
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("D:\\itheima\\movie.mp4");
            fos = new FileOutputStream("myio\\copy.mp4");
            //2.拷贝
            int len;
            byte[] bytes = new byte[1024 * 1024 * 5];//5M每次的存取
            while((len = fis.read(bytes)) != -1){
                fos.write(bytes,0,len);
            }
        } catch (IOException e) {
            //e.printStackTrace();
        } finally {
            //3.释放资源
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
  • 在代码中做了对异常的基本处理，不再是一般的抛出形式
  • 此处不管运行过程中代码是否出现异常都需要资源的释放，固应该将资源释放部分放在finally中执行
  • 在JAVA的后期版本中有资源自动释放的接口AutoCloseable，可避免麻烦的处理

2.2.4 字节流读取时乱码的问题

字符集概述

  1. 计算机中的字符存储单位是字节
  2. 最简单的字符集是ASCII字符集，每个字符占一个字节
    • 高位以0开头
  3. 早期我国针对汉字和日文韩文推出了GBK字符集
    • GBK字符集是完全兼容ASCII字符集的
    • 每个字符占两个字节，告位以1开头
  4. 在Uncode字符集中（万国码），包含了大多国家的文字
    • 针对该字符集有多种编码方式，最为常见的就是UTF-8编码方式
    • 在Unicode字符集的UTF-8编码时，汉字用三个字节进行存储

由上面的描述不难看出，在文件读取时出现乱码的肯能原因主要有：

  1. 一次读取一个字节的文件信息，并没有完全读取一个字符
  2. 在写文件和读文件时的编码方式不相同

由以下的字符串案例进行展示

public static void main(String[] args) throws UnsupportedEncodingException {
       /*
       以下的字符串函数
       Java中编码的方法
            public byte[] getBytes()                        使用默认方式进行编码
            public byte[] getBytes(String charsetName)      使用指定方式进行编码

        Java中解码的方法
            String(byte[] bytes)                            使用默认方式进行解码
            String(byte[] bytes, String charsetName)        使用指定方式进行解码
        */

       //1.编码
        String str = "我爱学JAVA";
        byte[] bytes1 = str.getBytes();
        System.out.println(Arrays.toString(bytes1));

        byte[] bytes2 = str.getBytes("GBK");
        System.out.println(Arrays.toString(bytes2));

        //2.解码
        String str2 = new String(bytes1);
        System.out.println(str2);

        String str3 = new String(bytes1,"GBK");
        System.out.println(str3);

    }

2.3 字符流的方法概述

在这里插入图片描述

2.3.1 FileReader方法

在这里插入图片描述

public static void main(String[] args) throws IOException {
        /*
            第一步：创建对象
            public FileReader(File file)        创建字符输入流关联本地文件
            public FileReader(String pathname)  创建字符输入流关联本地文件

            第二步：读取数据
            public int read()                   读取数据，读到末尾返回-1
            public int read(char[] buffer)      读取多个数据，读到末尾返回-1

            第三步：释放资源
            public void close()                 释放资源/关流
        */
        //1.创建对象并关联本地文件
        FileReader fr = new FileReader("myio\\a.txt");
        //2.读取数据 read()
        //如果遇到中文就会一次读取多个，GBK一次读两个字节，UTF-8一次读三个字节
        int ch;
        while((ch = fr.read()) != -1){
            System.out.print((char)ch);//用类型强制转换可以将十进制数转换成对应的中文字符
        }

        //3.释放资源
        fr.close();
    }

运行时的细节：

  1. read():默认也是一个字节一个字节的读取的,如果遇到中文就会一次读取多个
  2. 在读取之后，方法的底层还会进行解码并转成十进制,并返回十进制数
    这个十进制的数据也表示在字符集上的数字
    英文：文件里面二进制数据 0110 0001
    read方法进行读取，解码并转成十进制97
    中文：文件里面的二进制数据 11100110 10110001 10001001
    read方法进行读取，解码并转成十进制27721

对于字符流的read方法在底层中是存在一个缓冲区的

  • 当首次运行read方法，系统会读取文件，试图将这个数组类型的缓冲区装满
  • 每次read就从缓冲区中取出一个字符的数据
  • 当缓冲区全部读完后，由会第二次打开文件将剩余的内容再次读入到缓冲区中

2.3.2 FileWriter方法

FileWriter构造方法
在这里插入图片描述
FileWriter成员方法
在这里插入图片描述

在fileWriter中也存在着缓冲区每次书写并不是直接写入到文件中而是先写在缓冲区中

2.3.3 小结

字符流不同于字节流在读写的时候是以字符为单位的，所有有必要为他们设置一个缓冲区，将原本的字节信息放入到缓冲区中再进行编码操作在进行下一步的处。
字节流：字节信息–>处理
字符流：字节信息–>编码–>处理

三、高级IO流

高级的IO流是主要是对普通文件流的包装使之具有一定的特性

3.1 缓冲流

在普通IO流的基础上加入缓冲区

在这里插入图片描述

3.1.1 字节缓冲流

在这里插入图片描述
该类是在基本流的基础上创建的

public static void main(String[] args) throws IOException {
        //1.创建缓冲流的对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myio\\a.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myio\\copy.txt"));
        //2.循环读取并写到目的地
        int b;
        //byte[] buytes= new byte[10]
        //while ((b = bis.read(bytes)) != -1) {每次多字节读取
        while ((b = bis.read()) != -1) {
            bos.write(b);
        }
        //3.释放资源
        bos.close();
        bis.close();
    }

加快读取速度的原理
在这里插入图片描述
每次读取在缓冲区中最多读取8192个字节，通过变量b进行转存，避免了每次读取的磁盘访问，而将操作全部转移至内存中进行。

3.1.2 字符缓冲流

构造方法
在这里插入图片描述
同字节缓冲流
字符缓冲流的特殊方法
在这里插入图片描述
注意：

  • readline方法在读取时不会读入换行符
  • newline方法为了实现跨平台书写换行符，因为不同的操作系统文件的换行符不一致

缓冲流总结：

  • 缓冲流在输出流中要实现续写，应该将续写布尔值写在被包装类中
  • 字节缓冲流与字符缓冲流的缓冲区类型和大小不一致，一个是字节（byte）为单位，一个是字符（char）为单位

3.2 转换流

是字节流和字符流之间的转换桥梁，可以让字节流在存储时具有字符流的特性（根据字符集不同一次读取多个字节，读取数据时不会乱码）

在这里插入图片描述
注意：在命名时前半部分是字节流命名，后半部分是字符流命名
且转换流本身就是一种字符流，也可以使用字符流的方法

文件类型转换代码示例

public static void main(String[] args) throws IOException {
        /*
            将本地文件中的GBK文件，转成UTF-8
        */
        ///1.JDK11以前的方案
       InputStreamReader isr = new InputStreamReader(new FileInputStream("myio\\b.txt"),"GBK");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myio\\d.txt"),"UTF-8");

        int b;
        while((b = isr.read()) != -1){
            osw.write(b);
        }

        osw.close();
        isr.close();

        //2.替代方案
        FileReader fr = new FileReader("myio\\b.txt", Charset.forName("GBK"));
        FileWriter fw = new FileWriter("myio\\e.txt",Charset.forName("UTF-8"));
        int b;
        while ((b = fr.read()) != -1){
            fw.write(b);
        }
        fw.close();
        fr.close();
    }

public static void main(String[] args) throws IOException {
        /*
            利用字节流读取文件中的数据，每次读一整行，而且不能出现乱码

            //1.字节流在读取中文的时候，是会出现乱码的，但是字符流可以搞定
            //2.字节流里面是没有读一整行的方法的，只有字符缓冲流才能搞定
        */
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("myio\\a.txt")));
        String line;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
        br.close();
    }

总结：当字节流中需要使用到字符流的方法时需要引入转换流作为中间的桥梁

3.3 序列化流

序列化流为了将对象存储在文件当中，防止恶意的修改等事件的发生
它是字节流的高级流

3.3.1 序列化流

public static void main(String[] args) throws IOException {
        /*
           构造方法：
                public ObjectOutputStream(OutputStream out)         把基本流变成高级流

           成员方法：
                public final void writeObject(Object obj)           把对象序列化（写出）到文件中去

        */
        //1.创建对象
        Student stu = new Student("zhangsan",23);

        //2.创建序列化流的对象/对象操作输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));

        //3.写出数据
        oos.writeObject(stu);

        //4.释放资源
        oos.close();
    }

注意：序列化存储对象之前要将对象实现Serializable接口

3.3.2 反序列化流

public static void main(String[] args) throws IOException, ClassNotFoundException {
        /*
           构造方法：
                public ObjectInputStream(InputStream out)         把基本流变成高级流
           成员方法：
                public Object readObject()                        把序列化到本地文件中的对象，读取到程序中来
        */
        //1.创建反序列化流的对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myio\\a.txt"));

        //2.读取数据
        Student o = (Student) ois.readObject();

        //3.打印对象
        System.out.println(o);

        //4.释放资源
        ois.close();
    }

注意：如果多个对象需要读取，每次ois.readObject()读取一个对象

ArrayList<Student> list =(ArryList<Student>) ois.readObject();
 
for(Student stu : list){
	System.out.println(stu);
}

3.4 打印流

打印流不能读只能写，并且可以支持数据的原样写出

3.4.1 字节打印流

基本的构造方法
在这里插入图片描述
加上自动刷新可以边打印边查看
成员方法
在这里插入图片描述
数据原样写出：是指数据在写入文件时不会将数据转为对应的ASCII写入文件，而是将形参中传递的变量原封不动地直接写入文件
代码举例

public static void main(String[] args) throws FileNotFoundException {
    
        //1.创建字节打印流的对象
        PrintStream ps = new PrintStream(new FileOutputStream("进阶13附加//a.txt"), true, Charset.forName("UTF-8"));
        //2.写出数据
        ps.println(97);//写出 + 自动刷新 + 自动换行 直接写入97
        ps.print(true); //直接没写入true
        ps.println();
        ps.printf("%s爱上了%s","阿珍","阿强");
        //3.释放资源
        ps.close();

    }

3.4.2 字符打印流

构造方法
在这里插入图片描述
常用第三个构造方法
成员方法
与字节打印流的成员方法一致

在平时我们最常用的System.out.println()就是一种打印流
System.out就是获取打印流对象，只不过这个对象由虚拟机自动初始化
println便是打印流方法，将传入的参数打印在终端界面上
在使用后一般不会关闭该系统打印流（标准打印流），否则需要重启虚拟机以再次开启该流

3.5 压缩流

在这里插入图片描述

压缩流是字节流的子类解压的过程是读，压缩的过程是写

3.5.1 解压流

压缩包中每个文件是一个zipentry对象，解压时就是将该对象转化为原本的类型并存在一个指定的文件夹中

public static void unzip(File src,File dest) throws IOException {
        //解压的本质：把压缩包里面的每一个文件或者文件夹读取出来，按照层级拷贝到目的地中
        //创建一个解压缩流用来读取压缩包中的数据
        ZipInputStream zip = new ZipInputStream(new FileInputStream(src));
        //要先获取到压缩包里面的每一个zipentry对象
        //用压缩流来获取压缩包中的对象，并将它转为原文件
        ZipEntry entry;
        while((entry = zip.getNextEntry()) != null){
            System.out.println(entry);//entry对象中不仅包含着当前的文件名称，还有它完整的路径，如aaa/bbb.txt
            if(entry.isDirectory()){
                //文件夹：需要在目的地dest处创建一个同样的文件夹
                File file = new File(dest,entry.toString());
                file.mkdirs();
            }else{
                //文件：需要读取到压缩包中的文件，并把他存放到目的地dest文件夹中（按照层级目录进行存放）
                FileOutputStream fos = new FileOutputStream(new File(dest,entry.toString()));
                int b;
                while((b = zip.read()) != -1){
                    //写到目的地
                    fos.write(b);
                }
                fos.close();
                //表示在压缩包中的一个文件处理完毕了。
                zip.closeEntry();
            }
        }
        zip.close();
    }

3.5.2 压缩流

  public static void toZip(File src,File dest) throws IOException {
        //1.创建压缩流关联压缩包，在其内部中为一个压缩包的文件路径
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(new File(dest,"a.zip")));
        //2.创建压缩包中的内容->创建ZipEntry对象，表示压缩包里面的每一个文件和文件夹
        //参数：压缩包里面的路径
        ZipEntry entry = new ZipEntry("aaa\\bbb\\a.txt");
        //3.把ZipEntry对象放到压缩包当中
        zos.putNextEntry(entry);
        
        //4.把src文件中的数据写到压缩包的对象中
        //创建输入流读取源文件中字节，用来向内写入数据
        FileInputStream fis = new FileInputStream(src);
        int b;
        while((b = fis.read()) != -1){
            zos.write(b);//向entry中写入数据
        }
        zos.closeEntry();
        zos.close();
        
    }

总结：该过程整体分为两步

  1. 首先是获取压缩包的相关流
  2. 创建压缩包对象用来接收或向压缩包输入文件

3.5.3 将文件夹转换为压缩包

public static void main(String[] args) throws IOException {
        //1.创建File对象表示要压缩的文件夹
        File src = new File("D:\\aaa");
        //2.创建File对象表示压缩包放在哪里（压缩包的父级路径）
        File destParent = src.getParentFile();//D:\\
        //3.创建File对象表示压缩包的路径
        File dest = new File(destParent,src.getName() + ".zip");
        //4.创建压缩流关联压缩包
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(dest));
        //5.获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中
        toZip(src,zos,src.getName());//aaa
        //6.释放资源
        zos.close();
    }

    public static void toZip(File src,ZipOutputStream zos,String name) throws IOException {
        //1.进入src文件夹
        File[] files = src.listFiles();
        //2.遍历数组
        for (File file : files) {
            if(file.isFile()){
                //3.判断-文件，变成ZipEntry对象，放入到压缩包当中
                //此处不能用files.toString()的方法，该方法获取的是绝对路径
                //故采用文件名逐级增加的方式
                ZipEntry entry = new ZipEntry(name + "\\" + file.getName());//aaa\\no1\\a.txt
                zos.putNextEntry(entry);
                //读取文件中的数据，写到压缩包
                FileInputStream fis = new FileInputStream(file);
                int b;
                while((b = fis.read()) != -1){
                    zos.write(b);
                }
                fis.close();
                zos.closeEntry();
            }else{
                //4.判断-文件夹，递归
                toZip(file,zos,name + "\\" + file.getName());
                //     no1        aaa   \\   no1
            }
        }
    }
皮皮虾在睡觉
关注
Java进阶学习
m0_67403013的博客
07-30 805
这里的意思是，第五章的那些API你不要去记也没必要，你只要知道它有这么个用途，能决绝什么问题就可以了，具体的API说个名字或者名字说不出来也没关系，面试官一般不会纠结与API的名字，更想提到你对某个知识点自己的理解。——这本书通俗易懂，第5章可以不看，其余建议看。——更重要的是，如果面试官在问你设计模式的时候，你能详细说出几种常用的设计模式，并且给出在JDK或spring或其他框架源码中的应用，以及该模式解决了什么问题之类的，这肯定是加分项，面试官会认为你知识体系结构很完善，对你的印象肯定更加深刻。...
java进阶学习3
m0_74270947的博客
10-28 754
集合基础+学生信息管理系统 一、ArrayList 1、对象数组：以对象为元素的数组 (1)类是对象的抽象，因此先定义一个类，创建对象，将对象装进数组容器 (2)格式：类 [] 数组名=new 类[L](L表示数组长度，即数组存储的对象个数) €1 数组对象创建以及遍历练习 分析： (1)首先定义类封装需求中的数据(属性) (2)动态初始化数组，数组类型跟类相同 (3)创建对象，存入数组 (4)遍历数组，取出每一个对象 (5)调用get方法实现 解决方法：
Java进阶学习之路
m0_50249028的博客
03-04 888
Java进阶学习之路：也是博主学习整理的东西，目前还在跟进中，主要包含java基础，java进阶，javaWeb，框架：ssm，springMvc，SpringBoot
java进阶学习
weixin_45990682的博客
06-25 836
学习Java进阶知识需要系统地了解和掌握一些高级概念和技术，这些包括但不限于多线程、集合框架、输入输出、网络编程、数据库连接、JVM原理等。以下是一个详细的学习路线和资源建议，帮助您更好地掌握Java的高级部分。
Java进阶学习资料.zip
06-21
在Java进阶学习中，你需要掌握以下几个关键的知识点： 1. 高级数据结构与算法：理解并能熟练运用ArrayList、LinkedList、HashMap等集合框架，深入研究Set、Queue、Stack等接口及其实现类。同时，学习并应用高级排序...
java进阶13天资料.zip
08-08
Java进阶13天资料 day01-复习回顾、静态、继承、引用类型使用 day02-抽象类、接口、代码块，final、单例、枚举 day03-多态、包、权限修饰符、内部类，Object类，Date类 day04-常用API、正则表达式，泛型、Collection...
java工程师进阶学习资料
03-03
在Java工程师的进阶学习中，理解SQL语言的基本语法和高级特性至关重要，包括DML（数据操作）、DDL（数据定义）和DCL（数据控制）。此外，掌握事务处理、存储过程、索引优化、查询优化等技能，能有效提升应用程序的...
Java进阶学习网络服务器编程.rar
07-10
在Java进阶学习网络服务器编程的过程中，我们将会深入探讨如何使用Java语言来构建高效、可靠的网络应用程序和服务。网络服务器编程是软件开发中的一个重要领域，它涉及到客户端与服务器之间的通信，数据传输，以及...
spring事务详细讲解-深入浅出
小电玩
09-08 497
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1481
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
yang_brother的博客
09-10 548
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
基于SpringBoot的旅游管理系统
heye0910032的博客
09-08 475
随着科技的发展，旅游管理系统的信息化成为提升旅游服务效率的关键。本系统采用JSP技术和SpringBoot框架，结合MySQL数据库，旨在实现一个功能全面、操作简便、安全可靠的旅游管理平台。系统通过需求分析、系统设计、功能实现和测试，确保了良好的用户体验和数据处理能力，为旅游业务的现代化管理提供了强有力的技术支持。本研究成功开发了一个基于SpringBoot的旅游管理系统，该系统通过集成多种旅游管理功能，显著提高了旅游服务的效率和质量。系统的用户友好界面和强大的后端功能，使得管理员和用户都能从中受益。
自定义Stater
m0_63624484的博客
09-07 734
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 583
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
MyBatis面试
Tony_yitao的博客
09-09 747
MyBatis面试
Linux服务器Java启动脚本
Jack魏
09-08 560
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 346
步骤很详细，直接上教程……
Springboot废品回收系统---附源码86799
weixin_BYSJ1987的博客
09-07 1307
在系统的设计与实现中，本论文主要包括以下几个方面：首先，设计了系统的功能模块，包括用户注册登录、商品信息发布、回收订单管理等；其次，利用SpringBoot的特性，搭建了系统的后端框架，并实现了相应的业务逻辑；最后，使用前端技术，设计了用户友好的界面，使用户可以方便地使用系统。
C#基础（11）函数重载
最新发布
a6s686的博客
09-12 514
我们通过这些例子的学习，想毕你一定已经掌握了函数重载的相关内容，我相信你只要稍加练习，便能达到很熟练的程度。不过不管知识点难或者简单，还是那句话，学习路上，戒骄戒躁，脚踏实地。请期待我的下一篇博客！
Java进阶学习路线
08-16
Java进阶学习路线通常包括以下几个阶段： 1. **基础知识**： - 学习基础语法：变量、数据类型、运算符、流程控制（如条件、循环）、数组、集合等。 - 熟悉面向对象编程（OOP）概念：类、对象、封装、继承、多态。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值