JAVA IO流使用之字节流、字符流、缓冲流、转换流、打印流、序列化流（长文预警！）

最新推荐文章于 2022-11-12 10:09:01 发布
最新推荐文章于 2022-11-12 10:09:01 发布
阅读量396 收藏 1
点赞数 2
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43878332/article/details/106175629
版权

学习IO流

以下均为个人手写整理，如果有什么纰漏，希望可以帮忙指出~
个人博客文章地址

一、IO流概念

我们把计算机中，数据的传输（比如复制粘贴）看作是数据的流动，IO流：
I即是Input，输入流；O即是Output，输出流。
我们可以站在电脑内存的角度去理解这个输入输出的意思。
Input输入流：我们可以理解为把磁盘中的数据输入到内存中；
Output输出流：同样的，就是把内存的数据输出到磁盘中。

在这里插入图片描述

Java 中的IO流:Java 对于IO流的操作，Jvm不是直接操作我们的磁盘
流程为：代码 ->Jvm（运行在内存中） -> Os(当前操作系统) -> 进行文件操作

二、字节流

字节流，顾名思义，就是传输的都是一个个的字节，而我们所有的文件在存储中都是一个个的字节组成的。故字节流可以传输一切文件。

2.1 字节输出流（OutputStream）

将指定的数据输出到磁盘中，其有很多子类，以下用FileOutputStream举例

FileOutputStream(File file) ：指定一个File文件作为输出数据的目的地
FileOutputStream(String name) ： 直接指定路径作为输出数据的目的地
如果指定的文件不存在，则会直接自动创建该文件
另外
输出数据到文件（输出流）方法 write()有以下几种
write(int b) ：将指定的字节写入
write(byte[] b) ：将指定数组写入，效率高
write(byte[] b, int off, int len) ：将指定数组写入，off为改数组写入开始点（偏移量），len为长度。效率高，并且灵活

作用：调用write()方法，写入一个字节

import java.io.FileOutputStream;
import java.io.IOException;

public class UseIO {
    public static void main(String[] args) throws IOException {
        //指定输入的文件路径到当前文件夹（相对路径）
        FileOutputStream Os = new FileOutputStream("test.txt");

        Os.write(65);//写入的是字节

        Os.close();
    }
}

结果：
在这里插入图片描述
注意:

1.使用完输入输出流，一定要记得使用close()方法释放资源，以免造成系统资源的浪费
2.这种方法会将当前文件中的原数据进行覆盖，如果希望保留文件原来的数据，只是在文件后面追加数据，我们可以使用

FileOutputStream(File file, boolean append) ： 创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(String name, boolean append) ： 创建文件输出流以指定的名称写入文件。
例如上述例子中创建输出流改为
FileOutputStream Os = new FileOutputStream(“test.txt”, true);
即可实现追加数据

3.我们写入的是字节，系统的文件查看器，会参照Ascil表，将输入的字节转为字符，而65对应的就是字母A。那么怎么才能得到65呢？我们可以直接使用String中的getBytes()方法获取字节。请看：

public class UseIO {
    public static void main(String[] args) throws IOException {
        //指定输入的文件路径到当前文件夹（相对路径）
        FileOutputStream Os = new FileOutputStream("test.txt");

        String str = "65";
        Os.write(str.getBytes());//用String中的getBytes()方法，即可获取当前字符串的字节

        Os.close();
    }
}

结果:
在这里插入图片描述
以下还提供了比较简单的直接保存数据方式（无需转为字节保存）

2.1.1 采用打印流直接保存输入的数据

我们平常所用的System.out.println()或者System.out.println()都是来自于
PrintStream类，构造方法如下：
PrintStream(String fileName) ： 使用指定的文件名创建一个新的打印流。
我们的println方法默认是打印在控制台上的，只要我们改变一下该数据流的流向，即可得到我们想要的功能

代码：

import java.io.FileNotFoundException;
import java.io.PrintStream;

public class Print {
    public static void main(String[] args) throws FileNotFoundException {
        //新建一个打印流
        PrintStream ps = new PrintStream("print.txt");

        //改变打印流流向
        System.setOut(ps);

        //打印我们需要的数据，将会打印到到指定的文件中
        System.out.println("测试数据");

    }
}

效果： 控制台无显示，数据在指定的文件中显示
在这里插入图片描述
在这里插入图片描述

2.2 字节输入流（InputStream）

即是将磁盘文件输入到内存中（读取磁盘文件），相对的，以 FileInputStream示例

read() ： 从输入流读取数据的一个字节，然后指针会自动移到下一个字节位置，当无数据时，返回值为-1。
read(byte[] b) ： 从输入流中按字节数组取出数据，并将它们存储到字节数组 b中，效率更高 。
原理：每一次调用read()都会返回文件中的一个字节。从第一个字节开始，使用了read()后，会返回第一个字节，然后指针会自动指向下一个字节。
返回过程：磁盘->OS(操作系统)->jvm
下图以之前生成的test.txt为例
在这里插入图片描述

文件：
在这里插入图片描述
代码： 用输入流获取文件中的数据

import java.io.FileInputStream;
import java.io.IOException;

public class UseIO {
    public static void main(String[] args) throws IOException {
        //指定文件路径到当前文件夹（相对路径）
        FileInputStream Os = new FileInputStream("test.txt");

        /*
        从read()方法的原理中，我们知道每次调用read(),都会使指针自动指向下一个字节，
        再次使用read()将无法获取当前一个字节
        所以我们需要定义一个数来接收返回的字节
         */
        int data = 0;
        while ((data = Os.read()) != -1){
            System.out.println("返回的字节为" + data + "，转型后为" + (char)data);
        }


        Os.close();//释放资源
    }
}

结果：
在这里插入图片描述

2.3 使用字节输入输出流实现的文件的复制粘贴功能

因为字节流是可以传输所有类型的文件，这里我们用图片文件

该图片（pic.jpg）的字节大小：
在这里插入图片描述

代码: 建立字节输入和输出流将E盘的图片文件复制到D盘下

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class UseIO {
    public static void main(String[] args) throws IOException {
        // 记录开始时间
        long start = System.currentTimeMillis();

        //将文件复制到D盘，创建输入流获取文件（复制）
        FileInputStream Fis = new FileInputStream("E:\\pic.jpg");
        //创建输出流输出文件到磁盘（粘贴），指定粘贴的路径
        FileOutputStream Fos = new FileOutputStream("D:\\newPic.jpg");

        int data = 0;
        while ((data = Fis.read()) != -1){
            Fos.write(data);
        }





		//使用完后释放资源
        Fis.close();
        Fos.close();
        // 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("完成字节流所用复制时间:"+(end - start)+" 毫秒");

    }
}

结果：
在这里插入图片描述
在这里插入图片描述

如何提高复制效率？

前面已经讲到，我们直接用字节数组Byte[] 进行输入输出流操作，可以提高效率

read(byte[] b) ： 从输入流中按字节数组取出数据，并将它们存储到字节数组 b中，效率更高 。
write(byte[] b, int off, int len) ：将指定数组写入，off为改数组写入开始点（偏移量），len为长度。效率高，并且灵活

代码：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class UseIO {
    public static void main(String[] args) throws IOException {
        // 记录开始时间
        long start = System.currentTimeMillis();

        //将文件复制到D盘
        FileInputStream Fis = new FileInputStream("E:\\pic.jpg");
        FileOutputStream Fos = new FileOutputStream("D:\\newPic.jpg");

        //用做演示，byte[]里的字节数可以填更大，2的n次方
        byte[] data = new byte[1024];

        //用作记录每次读完后，返回的字节长度，如果读完后，将返回-1
        int len = 0;

        //先对文件进行输入流中的read(byte[] b)，会将读取到的字节存在data[]中，并且放回数组中的字节长度
        while ((len = Fis.read(data)) != -1){
            //输出流操作，将data[]中的字节输出到文件中，从data[0]开始，直到data[len]
            Fos.write(data , 0 , len);
        }

        Fis.close();
        Fos.close();
        // 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("完成字节流所用复制时间:"+(end - start)+" 毫秒");

    }
}

效果：
在这里插入图片描述
如果需要继续提高速度，我们就可以用到下面讲到的缓冲流

三、字符流

字符流是为了解决，我们使用字节输入输出流进行对带字符的文件，进行输入输出时，如果文件中带有中文（中文在UTF-8编码中占3个字节），使用字节流读取一个字节就输出的话，就会出现乱码的现象(只获取了1/3个字符)，而字符流则是以一个字符为单位进行输入输出操作，就可以解决这种问题。

3.1 Writer/Reader（字符输出输入流）

它们子类都将以字符为单位，进行文件的输出，以下用FileWriter/FileReader进行举例，
FileWriter流与其它的流都有相似的方法，值得注意的是，它还有个
flush() 刷新该流的缓冲。
这个方法是将缓冲区的字符写入到文件中（或者直接调用close()方法也可以，该方法的存在是为了将已经写好的字符先刷到文件中，然后可以继续进行字符流的操作，而不需要关闭流）
FileReader类的使用与FileInputStream 相似，但是如果使用数组进行读取的话，传入的是字符数组 char[] ，而不是byte[]

直接用代码进行说明:

import java.io.FileInputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class UseWRS {
    public static void main(String[] args) throws IOException {
        //创建一个字符输出流.传入需要输出（写入）文件的名称，也可以是一个文件对象
        FileWriter fileWriter = new FileWriter("newTest.txt");
        //创建一个字符输入流.传入需要输入（读取）文件的名称，也可以是一个文件对象
        FileReader fileReader = new FileReader("newTest.txt");

        //创建一个字节输入流，用作测试对比
        FileInputStream fileInputStream = new FileInputStream("newTest.txt");

        //使用FileWriter中的write方法，将需要的字符写到缓冲区中
        fileWriter.write("测试");

        /*
        这里我们测试如果没有使用flush()或者close()方法，字符是否已经写入文件中
        使用了字符输入流中的read方法，读取的使用方式与FileInputStream相同
        */
        System.out.println("使用flush()方法前：");
        int str1;
        while((str1 = fileReader.read()) != -1){
            System.out.println("一次读取到的字节："+str1+"，转换为字符"+(char)str1);
        }


        /*
        这里我们测试使用flush()方法后读取到的数据，字符是否已经写入文件中
        使用了字符输入流中的read方法，读取的使用方式与FileInputStream相同
        */
        System.out.println("使用flush()方法后：");
        fileWriter.flush();
        int str2;
        while((str2 = fileReader.read()) != -1){
            System.out.println("一次读取到的字节："+str2+"，转换为字符："+(char)str2);//一次性读取了三个字节，所以可以直接显示一个中文
        }

        //如果使用字节输入流读取该文件
        System.out.println("使用字节输入流读取后显示：");
        int str3;
        while((str3 = fileInputStream.read()) != -1){
            System.out.println("一次读取到的字节："+str3+"，转换为字符："+(char)str3);//一次获取一个字节，但一个中文是三个字节，故出现乱码
        }

        //使用FileWriter中的write方法，将需要的字符写到缓冲区中
        fileWriter.write("关闭");
        //直接关闭流也会自动执行flush()
        System.out.println("直接执行close()显示：");
        fileWriter.close();
        int str4;
        while((str4 = fileReader.read()) != -1){
            System.out.println("一次读取到的字节："+str4+"，转换为字符："+(char)str4);
        }

        //使用完流操作都需要close()释放资源
        fileReader.close();

    }
}

四、缓冲流

缓冲流，可以提高读写效率的效率，可以理解为是以上四种流的加强版
字节缓冲流：
BufferedInputStream ( FileInputStream的加强版)
BufferedOutputStream ( FileOutputStream的加强版)
字符缓冲流：
BufferedReader （FileReader的加强版）
BufferedWriter （FileWriter的加强版）
在使用时，我们传入的是对应的流对象，相当于给基本流穿上装备
BufferedInputStream(InputStream in) ：创建一个新的缓冲输入流。
BufferedOutputStream(OutputStream out) ： 创建一个新的缓冲输出流。
BufferedReader(Reader in) ：创建一个 新的缓冲输入流。
BufferedWriter(Writer out) ： 创建一个新的缓冲输出流。

4.1 字节缓冲流

我们直接用之前的文件复制进行示例

代码：

import java.io.*;

public class UseIO {
    public static void main(String[] args) throws IOException {
        // 记录开始时间
        long start = System.currentTimeMillis();

        //创建缓冲流测试效率
        BufferedInputStream Bis = new BufferedInputStream(new FileInputStream("E:\\pic.jpg"););
        BufferedOutputStream Bos = new BufferedOutputStream(new FileOutputStream("D:\\newPic.jpg"););

        //用做演示，byte[]里的字节数可以填更大
        byte[] data = new byte[1024];

        //用作记录每次读完后，返回的字节长度，如果读完后，将返回-1
        int len = 0;

        //先对文件进行输入流中的read(byte[] b)，会将读取到的字节存在data[]中，并且放回数组中的字节长度
        while ((len = Bis.read(data)) != -1){
            //输出流操作，将data[]中的字节输出到文件中，从data[0]开始，直到data[len]
            Bos.write(data , 0 , len);
        }
		//关闭缓冲流即可释放资源
        Bis.close();
        Bos.close();

        // 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("完成缓冲字节流所用复制时间:"+(end - start)+" 毫秒");

    }
}

由之前复制实践中，未使用缓冲流所用时间：
在这里插入图片描述

使用缓冲流后： 由于文件比较小，所有差距比较小，但是在大文件中更为明显，可自行测试
在这里插入图片描述

4.2 字符缓冲流

这个主要需要了解的是，它比起普通的字符流，有着两个特有方法
readLine() : 读一行文字,并返回一个字符串。
newLine() : 写一行行分隔符,由系统属性定义符号（比方说Window系统为：\r\n Linux系统为\n）。

代码示例：

public class BuffTest {
    public static void main(String[] args) throws IOException {
        // 创建缓冲字符输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("test.txt"));
        // 创建缓冲字符输入流对象
        BufferedReader br = new BufferedReader(new FileReader("test.txt"));

        //我们先对文件进行输出（写入）数据
        bw.write("写");
        bw.newLine();//插入换行
        bw.write("数");
        bw.write("据");

        //如果暂时不需要关闭输出流，我们需要调用flush（）将数据从缓冲区写入
        bw.flush();

        // 定义字符串,保存读取的一行文字
        String line = null;
        // 循环读取,读取到最后返回null
        while ((line = br.readLine())!=null) {
            System.out.println(line);
            System.out.println("——————————");//分割显示每一行
        }
        // 释放资源
        br.close();
        bw.close();
    }
}

test文件：
在这里插入图片描述
运行显示：
在这里插入图片描述

五、转换流

转换流，就是可以转换我们数据的编码格式
例如，我们的文件保存的编码格式为GBK，如果我们用UTF-8的编码格式打开的话，将会显示乱码：
新建一个系统默认文本文件（window默认编码格式为ANSL GBK），然后在IDE（默认格式为UTF-8）打开查看会显示乱码（直接用字节流/字符流读取也会是乱码）：
新建文件：
在这里插入图片描述
在IDE中显示出现乱码：
在这里插入图片描述
这时，我们就可以使用转换流来进行格式的转换,以下为方法，使用方式其实都与输入输出流差不多，只是新增了一个指定编码格式
InputStreamReader(InputStream in) : 创建一个使用默认字符集的字符流。
InputStreamReader(InputStream in, String charsetName) : 创建一个指定字符集的字符流
OutputStreamWriter(OutputStream in) : 创建一个使用默认字符集的字符流。
OutputStreamWriter(OutputStream in, String charsetName) : 创建一个指定字符集的字符流。

代码：

public class Change {
    public static void main(String[] args) throws IOException {
        //新建输入转换流,注意，选取的编码格式必须是文件的原格式
        InputStreamReader tsr = new InputStreamReader(new FileInputStream("test.txt"),"GBK");

        //新建一个输出流，将获取到的输入流中的数据，转换成指定的编码格式，并保存
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("newTest.txt"),"UTF-8");

        //与复制粘贴过程类似，读取文件中的数据，然后输出
        int len = 0;

        while((len = tsr.read()) != -1){
            osw.write(len);
        }

        //使用完后释放资源
        tsr.close();
        osw.close();
    }
}

结果成功读取：
在这里插入图片描述

六、序列化流

序列化，主要用作保存对象，并且可以将对保存后的字节数据重新转换为对象，以字节表示对象
即：对象 —> 字节文件 ， 字节文件—>对象，对象转换为字节文件叫做对象的序列化，反之，则叫反序列化
序列化有什么用（参考）？
1、当你想把的内存中的对象保存到一个文件中或者数据库中时候；
2、当你想用套接字在网络上传送对象的时候；
3、当你想通过RMI传输对象的时候；
构造方法：
ObjectOutputStream(OutputStream out) ： 创建一个指定OutputStream的ObjectOutputStream
writeObject (Object obj) : 将指定的对象输出到文件。
ObjectInputStream(InputStream in) ： 创建一个指定InputStream的ObjectInputStream。
readObject () : 读取一个对象。

直接在代码中说明：
目录：
在这里插入图片描述
Person类：

import java.io.Serializable;

//对象的序列化，必须实现Serializable接口
public class Person implements Serializable {
    /*
    序列化后，如果我们对对象的文件进行更改，然后再进行反序列化操作，将会出现
    ClassNotFoundException异常，找不到class文件（class文件已经被修改，序列号会改变，所以找不到）
    为了防止这种情况的发生，我们可以直接固定序列号
     */
    //加入序列版本号，修改class文件后，反序列化也不会出现异常
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    //加入transient属性，可以使该属性无法被序列化
    private transient String sex;


    public Person() {
    }

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

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

TestSer测试类：

import java.io.*;

public class TestSer {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //新建序列化输出流
        ObjectOutputStream Oos = new ObjectOutputStream(new FileOutputStream("test.txt"));

        //新建序列化输入流
        ObjectInputStream Ois = new ObjectInputStream(new FileInputStream("test.txt"));

        //实例化对象
        Person person = new Person("张三",18,"男");

        //序列化对象
        Oos.writeObject(person);

        //反序列化
        Person TestPerson;
        TestPerson = (Person) Ois.readObject();

        //查看是否反序列化成功，因为sex属性已经用transient修饰，所以不会被序列化，故返回为null值
        System.out.println(TestPerson.toString());

        //关闭流
        Ois.close();
        Oos.close();
    }
}

运行结果：
在这里插入图片描述
序列化文件无法直接查看
在这里插入图片描述

We Der
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
万字长文！详细解析字节跳动Java后端社招面试题（3年经验）
bug_product的博客
05-30 2397
哈喽。我又来为大家更新面经资料了。今天继续为大家更新字节跳动社招的面经资料。 （我发现我特别喜欢更新字节的。。。） 时长2H。应用+原理理解；Java后端社招+3年经验 1、自我介绍 2、JVM组成部分 （1）堆 （2）方法区（元数据区） （3）程序计数器 （4）本地方法栈 （5）虚拟机栈 3、虚拟机栈和本地方法栈区别（线程私有，每个线程都有一个） （1）本地方法栈和虚拟机栈的作用相同，用来描述方法执行的内存模型； （2）即每个方法执行都会在栈上创建一个栈帧,存放方法的出入口,局部变量表和操.
一文带你彻底理解Java序列化和反序列化
09-07
Java序列化和反序列化是Java开发中常用的技术，它允许我们将Java对象转换成字节流，以便于存储、在网络中传输或在不同时间点重建对象。这一过程对于实现某些关键功能至关重要，如持久化数据、分布式计算和跨进程通信...
万字长文+思维导图帮你梳理 Java IO 流，还学不会你来打我（值得收藏）
a1405的专栏
05-15 2275
File 在正式的介绍IO流之前，我觉得应该介绍一下File类，该类主要是对文件和目录的抽象表示，因为学习io流第一反应就是文件，该类提供了对文件的创建、删除、查找等操作。主要有以下特点 java的世界万物皆对象，文件和目录就可抽象为File对象 对于File而言，封装的并不是真正的文件，封装的仅仅是一个路径名，磁盘文件本身可以存在，也可以不存在 文件的内容不能用File读取，而是通过流来读取，File对象可以作为流的来源地和目的地 File类的常用构造方法 构造方法
【JAVA SE】JAVA中的IO流
crisp0530的博客
06-21 140
大家好呀，我是crisp制药呀💊，今天来给大家讲解JAVA中IO流的相关的知识，万字长文希望大家可以收藏起来慢慢看，作为初学者我也是写来方便日后的复习，制药和大家一起学习一起加油！😀下图是我自制的有关IO流的思维导图，将各种流分类梳理了一遍。代码示例： 2.2 路径分类 相对路径：相较于某个路径下，指明的路径。 绝对路径：包含盘符在内的文件或文件目录的路径。 说明：windows和DOS系统默认使用 来表示UNIX和URL使用 来表示Java程序支持跨平台运行，因此路径分隔符要慎用。为了解决这个..
就这一次彻底把I/O搞懂！万字长文详解JavaI/O流！（建议收藏）
weixin_50205273的博客
09-14 309
Java IO 是一个庞大的知识体系，很多人学着学着就会学懵了，包括我在内也是如此，所以本文将会从 Java 的 BIO 开始，一步一步深入学习，引出 JDK1.4 之后出现的 NIO 技术，对比 NIO 与 BIO 的区别，然后对 NIO 中重要的三个组成部分进行讲解（缓冲区、通道、选择器），最后实现一个简易的客户端与服务器通信功能。 传统的 BIO Java IO流是一个庞大的生态环境，其内部提供了很多不同的输入流和输出流，细分下去还有字节流和字符流，甚至还有缓冲流提高 IO 性能，转换流将字节
万字长文|一文了解基于Flink构建流批一体数仓的技术点
http://www.54tianzhisheng.cn/
01-21 510
基于Flink构建流批一体的实时数仓是目前数据仓库领域比较火的实践方案。随着Flink的不断迭代，其提供的一系列技术特性使得用户构建流批一体的应用变得越来越方便。本文将以Flink1.1...
1.6 万字长文带你读懂 Java IO
图灵教育
09-11 353
Java IO 是一个庞大的知识体系，很多人学着学着就会学懵了，包括我在内也是如此，所以本文将会从 Java 的 BIO 开始，一步一步深入学习，引出 JDK1.4 之后出现的 NIO ...
文本流和过滤器
Cool2Feel的博客
09-14 651
概述 本教程将介绍过滤器，您可以构建复杂的管道 来使用过滤器处理文本。您将学习如何显示文本，对它排序，统计字数和行数，以及翻译字符等。您还将学习如何使用流编辑器 sed。 在本教程中，您将学习以下主题： 通过文本实用工具过滤器发送文本文件和输出流，以修改输出使用 GNU textutils 包中的标准 UNIX 命令使用编辑器 sed 将复杂的更改编写到文本文件中 本教程可帮助您针
【Java虚拟机】万字长文，搞定Java虚拟机方方面面！
互联网小阿祥
11-12 870
万字总结JVM全部知识点，原理图解到案例实战，使学习JVM不在枯燥无味
明晰 | Java序列化与反序列化
mySoul
08-19 188
小小开始写作，这是本周的第三篇这是小小本周的第三篇 最近事情有点多，多的让人有点受不了本篇将会分为实战和理论两部分，依次进行讲解。实战含义序列化：对象写入IO流中，实现对象变成文件。反序...
流系统Spark/Flink/Kafka/DataFlow端到端一致性实现对比
01-07
长文预警, 全文两万五千多字, 37页word文档的长度 （略有杂乱，有些非常复杂的地方可能需要更多的例子来说明，使得初学者也能很容易看懂，但是实在花的时间已经太多太多了，留待后边利用起碎片时间一点点修改吧。。...
​OFFSET，动态统计函数之王，长文预警，新手勿看！
03-25
OFFSET函数是判断Excel函数使用者是否进阶的一个重要函数之一。在实际工作中，如果你需要对工作中的数据文件进行系统化、自动化的建模，那么势必会使用这个函数。 【功能及语法】 OFFSET函数的功能是，以指定的...
数据治理怎么做？这篇万字长文终于讲清楚了!.docx
06-17
这篇万字长文终于讲清楚了!.docx数据治理怎么做？这篇万字长文终于讲清楚了!.docx数据治理怎么做？这篇万字长文终于讲清楚了!.docx数据治理怎么做？这篇万字长文终于讲清楚了!.docx数据治理怎么做？这篇万字长文终于...
万字长文详解如何使用 Swift 提高代码质量.pdf
最新发布
02-18
万字长文详解如何使用 Swift 提高代码质量
Eclipse导入一个JAVA web项目详解（附web项目源码）
热门推荐
weder的博客
04-08 2万+
前言 对于初学者来说，导入一个Java web项目经常会遇到各种各样的问题，以下为导入一个Java web项目（网上找的图书馆管理系统）的全过程，以供参考 工具 Eclipse（以配置好tomcat） Mysql server 5.5 Mysql workbench 一、导入项目中的sql文件 一个现成的Java web项目一般会附带一个sql文件，如图 1.打开workbench 如上...
Springboot连接Redis超时问题解决
weder的博客
02-22 1万+
一、问题出现 在使用Springcloud整合Redis作为缓存时，一段时间不去操作，再次刷新会出现连接超时的问题，具体如下： io.lettuce.core.RedisCommandTimeoutException: Command timed out after 5 second(s) 二、原因 springboot 2.x 默认采用了lettuce作为连接池，但是lettuce是不会进行“心跳”操作的，也就是说，它不会保持连接，导致了连接超时。 三、解决 我们可以将连接池修改为jedis，jedis是
JAVA通过反射机制访问/修改私有变量、方法（实现在其它类中访问/修改对象的私有变量、方法）
weder的博客
07-04 6574
平常访问/修改类对象的私有属性，需要使用gei/set方法访问，这里我们也可以通过反射机制直接访问/修改
通过API接口同步数据到本地数据库工具（Springboot+Mybatis实现）
weder的博客
04-13 3228
1、工具目录结构 2、工具使用application配置（主要配置JsonToSqlUtil） JsonToSqlUtil: # 数据字段名，必须按json中的返回顺序写(英文,隔开) field: id,name,description,pictureUrl,url,testUrl,ttUrl,aaUrl,kakaka,createDate # 格式是时间的字段(英文,隔开) timeField: createDate,updateDate # 是否为时间戳格式 true or
javaio流知识点思维导图
08-27
通过组合和使用不同类型的流和类，您可以实现各种复杂的IO操作，如读写文件、网络通信、序列化对象等。 希望这个简要总结对您有所帮助。如果您有任何更具体的问题，请随时提问。<span class="em">1</span><span ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值