【Java从入门到大牛】IO流下篇

这篇具有很好参考价值的文章主要介绍了【Java从入门到大牛】IO流下篇。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

🔥 本文由 程序喵正在路上 原创,CSDN首发!
💖 系列专栏:Java从入门到大牛
🌠 首发时间:2023年8月31日
🦋 欢迎关注🖱点赞👍收藏🌟留言🐾
🌟 一以贯之的努力 不得懈怠的人生

IO流-字符流

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

文件字符输入流-读字符数据进来

FileReader(文件字符输入流)

作用:以内存为基准,可以把文件中的数据以字符的形式读入到内存中去
【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

具体应用

测试文本文件

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

代码实现

import java.io.FileReader;
import java.io.Reader;

/**
 * 目标:掌握文件字符输入流
 */
public class FileReaderTest1 {
    public static void main(String[] args)  {
        try (
                // 1、创建一个文件字符输入流管道与源文件接通
                Reader fr = new FileReader("io-app2/src/test01.txt");
                ){
            // 2、读取文本文件的内容,每次读取一个字符,性能较差
//            int c; // 记住每次读取的字符编号
//            while ((c = fr.read()) != -1){
//                System.out.print((char) c);
//            }


            // 3、每次读取多个字符,性能还行
            char[] buffer = new char[3];
            int len; // 记住每次读取了多少个字符
            while ((len = fr.read(buffer)) != -1){
                System.out.print(new String(buffer, 0, len));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

执行结果

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

文件字符输出流-写字符数据出去

FileWriter(文件字符输出流)

作用:以内存为基准,把内存中的数据以字符的形式写出到文件中去

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

字符输出流使用时的注意事项

字符输出流写出数据后,必须刷新流,或者关闭流,写出去的数据才能生效,具体方法如下
【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

字节流、字符流的使用场景小结:

  • 字节流适合做一切文件数据的拷贝(音视频或文本);字节流不适合读取中文内容输出
  • 字符流适合做文本文件的操作(读或写)

具体应用

import java.io.FileWriter;
import java.io.Writer;

/**
 * 目标:掌握文件字符输出流:写字符数据出去
 */
public class FileWriterTest2 {
    public static void main(String[] args) {
        try (
                // 创建一个文件字符输出流管道与目标文件接通
                // 覆盖管道
                // Writer fw = new FileWriter("io-app2/src/itheima02out.txt");

                // 追加管道
                Writer fw = new FileWriter("io-app2/src/test02out.txt", true);
                ){
            // 1、public void write(int c):写一个字符出去
            fw.write('a');
            fw.write(97);
            fw.write('好'); // 写一个字符出去
            fw.write("\r\n"); // 换行

            // 2、public void write(String c)写一个字符串出去
            fw.write("我爱你中国abc");
            fw.write("\r\n");

            // 3、public void write(String c ,int pos ,int len):写字符串的一部分出去
            fw.write("我爱你中国abc", 0, 5);
            fw.write("\r\n");

            // 4、public void write(char[] buffer):写一个字符数组出去
            char[] buffer = {'你', '好', '1', '2', '3'};
            fw.write(buffer);
            fw.write("\r\n");

            // 5、public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
            fw.write(buffer, 0, 2);
            fw.write("\r\n");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

IO流-缓冲流

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

对原始流进行包装,以提高原始流读写数据的性能

字节缓冲流

字节缓冲流的作用

提高字节流读写数据的性能

字节缓冲流的原理

字节缓冲输入流自带了 8KB 缓冲池;字节缓冲输出流也自带了 8KB 缓冲池

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

具体应用

import java.io.*;
/**
 * 目标:掌握字节缓冲流的作用
 */
public class BufferedInputStreamTest1 {
    public static void main(String[] args) {
        try (
                InputStream is = new FileInputStream("io-app2/src/test01.txt");
                // 1、定义一个字节缓冲输入流包装原始的字节输入流
                InputStream bis = new BufferedInputStream(is);

                OutputStream os = new FileOutputStream("io-app2/src/test01copy.txt");
                // 2、定义一个字节缓冲输出流包装原始的字节输出流
                OutputStream bos = new BufferedOutputStream(os);
        ){
            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer, 0, len);
            }
            System.out.println("复制完成!!");

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

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

字符缓冲流

BufferedReader(字符缓冲输入流)

作用:自带 8K(8192)的字符缓冲池,可以提高字符输入流读取字符数据的性能
【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

字符缓冲输入流新增的功能:按照行读取字符
【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

字符缓冲输入流具体应用

import java.io.*;

/**
 * 目标:掌握字符缓冲输入流的用法
 */
public class BufferedReaderTest2 {
    public static void main(String[] args)  {
        try (
                Reader fr = new FileReader("io-app2\\src\\test02.txt");
                // 创建一个字符缓冲输入流包装原始的字符输入流
                BufferedReader br = new BufferedReader(fr);
        ){
            String line; // 记住每次读取的一行数据
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

BufferedWriter(字符缓冲输出流)

作用:自带 8K(8192)的字符缓冲池,可以提高字符输出流写字符数据的性能
【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

字符缓冲输出流新增的功能:换行
【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

字符缓冲输出流具体应用

import java.io.*;

/**
 * 目标:掌握字符缓冲输出流的用法
 */
public class BufferedWriterTest3 {
    public static void main(String[] args) {
        try (
                Writer fw = new FileWriter("io-app2/src/test03out.txt", true);
                // 创建一个字符缓冲输出流管道包装原始的字符输出流
                BufferedWriter bw = new BufferedWriter(fw);
        ){
            bw.write('a');
            bw.write(97);
            bw.write('好');
            bw.newLine();

            bw.write("我爱你中国abc");
            bw.newLine();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

原始流、缓冲流的性能分析 [重点]

测试用例:

分别使用原始的字节流以及字节缓冲流复制一个很大的视频

测试步骤:

  1. 使用低级的字节流按照一个一个字节的形式复制文件
  2. 使用低级的字节流按照字节数组的形式复制文件
  3. 使用高级的缓冲字节流按照一个一个字节的形式复制文件
  4. 使用高级的缓冲字节流按照字节数组的形式复制文件

代码实现

import java.io.*;

/**
    目标:观察原始流和缓冲流的性能
 */
public class TimeTest4 {
    // 复制的视频路径
    private static final String SRC_FILE = "D:\\resource\\test.mp4";
    // 复制到哪个目的地
    private static final String DEST_FILE = "D:\\";

    public static void main(String[] args) {
        copy01();   // 低级字节流一个一个字节的赋值,慢的简直让人无法忍受,直接淘汰!
        copy02();   // 低级的字节流流按照一个一个字节数组的形式复制,速度较慢!
        copy03();   // 缓冲流按照一个一个字节的形式复制,速度较慢,直接淘汰!
        copy04();   // 缓冲流按照一个一个字节数组的形式复制,速度极快,推荐使用!
    }

    private static void copy01() {
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                OutputStream os = new FileOutputStream(DEST_FILE + "1.mp4");
        ){
            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");
    }

    private static void copy02() {
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                OutputStream os = new FileOutputStream(DEST_FILE + "2.mp4");
        ){
            byte[] buffer = new byte[1024*64];
            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");
    }

    private static void copy03() {
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                BufferedInputStream bis = new BufferedInputStream(is);
                OutputStream os = new FileOutputStream(DEST_FILE + "3.mp4");
                BufferedOutputStream bos = new BufferedOutputStream(os);
        ){

            int b;
            while ((b = bis.read()) != -1){
                bos.write(b);
            }

        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("缓冲流一个一个字节复制耗时:" + (endTime - startTime) / 1000.0 + "s");
    }

    private static void copy04() {
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                BufferedInputStream bis = new BufferedInputStream(is, 64 * 1024);
                OutputStream os = new FileOutputStream(DEST_FILE + "4.mp4");
                BufferedOutputStream bos = new BufferedOutputStream(os, 64 * 1024);
        ){
            byte[] buffer = new byte[1024 * 64]; // 32KB
            int len;
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer, 0, len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("缓冲流使用字节数组复制耗时:" + (endTime - startTime) / 1000.0 + "s");
    }
}

执行结果

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

结论

建议使用字节缓冲输入流和字节缓冲输出流,结合字节数组的方式,目前看来是性能最优的组合

IO流-转换流

引出问题:不同编码读取时会乱码

  • 如果代码编码和被读取的文本文件的编码是一致的,使用字符流读取文本文件时不会出现乱码
  • 如果代码编码和被读取的文本文件的编码是不一致的,使用字符流读取文本文件就会出现乱码

字符输入转换流

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

InputStreamReader(字符输入转换流)

  • 解决不同编码时,字符流读取文本内容乱码的问题
  • 解决思路:先获取文件的原始字节流,再将其按真实的字符集编码转成字符输入流,这样字符输入流中的字符就不会乱码了

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

具体应用

import java.io.*;

/**
 * 目标:掌握字符输入转换流的作用
 */
public class InputStreamReaderTest2 {
    public static void main(String[] args) {
        try (
                // 1、得到文件的原始字节流(GBK的字节流形式)
                InputStream is = new FileInputStream("io-app2/src/inputStreamReaderTest.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 = "我爱你中国abc";
    byte[] bytes = data.getBytes("GBK");
    
  2. 使用 “字符输出转换流” 实现

OutputStreamWriter字符输出转换流

  • 作用:可以控制写出去的字符使用什么字符集编码
  • 解决思路:获取字节输出流,再按照指定的字符集编码将其转换成字符输出流,以后写出去的字符就会用该字符集编码了

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

具体应用

import java.io.*;

/**
 * 目标:掌握字符输出转换流的使用
 */
public class OutputStreamWriterTest3 {
    public static void main(String[] args) {
        // 指定写出去的字符编
        try (
                // 1、创建一个文件字节输出流
                OutputStream os = new FileOutputStream("io-app2/src/outputStreamWriterTest.txt");
                // 2、把原始的字节输出流,按照指定的字符集编码转换成字符输出转换流
                Writer osw = new OutputStreamWriter(os, "GBK");
                // 3、把字符输出流包装成缓冲字符输出流
                BufferedWriter bw = new BufferedWriter(osw);
                ){
            bw.write("我是中国人abc");
            bw.write("我爱你中国123");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

IO流-打印流

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

PrintStream/PrintWriter(打印流)

作用:打印流可以实现更方便、更高效地打印数据出去,能实现打印啥出去就是啥出去

PrintStream提供的打印数据的方案

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

PrintStream和PrintWriter的区别

  • 打印数据的功能上是一模一样的,都是使用方便、性能高效
  • PrintStream 继承自字节输出流 OutputStream,因此支持写字节数据的方法
  • PrintWriter 继承自字符输出流 Writer,因此支持写字符数据出去

具体应用

import java.io.*;

/**
 * 目标:掌握打印流:PrintStream/PrintWriter的用法
 */
public class PrintTest1 {
    public static void main(String[] args) {
        try (
                // 创建一个打印流管道
//                PrintStream ps =
//                        new PrintStream("io-app2/src/testPrint.txt", Charset.forName("GBK"));
//                PrintStream ps =
//                        new PrintStream("io-app2/src/testPrint.txt");
                PrintWriter ps =
                        new PrintWriter(new FileOutputStream("io-app2/src/testPrint.txt", true));
                ){
                ps.println(97);
                ps.println('a');
                ps.println("我爱你中国abc");
                ps.println(true);
                ps.println(99.5);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

打印流的一种应用:输出语句的重定向

可以把输出语句的打印位置改到某个文件中去

PrintStream ps = new PrintStream("文件地址");
System.setOut(ps);
import java.io.PrintStream;

/**
 * 目标:了解下输出语句的重定向
 */
public class PrintTest2 {
    public static void main(String[] args) {
        try ( PrintStream ps = new PrintStream("io-app2/src/testPrint.txt"); ){

            // 把系统默认的打印流对象改成自己设置的打印流
            System.setOut(ps);

            System.out.println("烈士暮年");
            System.out.println("壮心不已");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

IO流-数据流

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

DataOutputStream(数据输出流)

允许把数据和其类型一并写出去

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

import java.io.*;

/**
 * 目标:数据输出流
 */
public class DataOutputStreamTest1 {
    public static void main(String[] args) {
        try (
                // 1、创建一个数据输出流包装低级的字节输出流
                DataOutputStream dos =
                        new DataOutputStream(new FileOutputStream("io-app2/src/testDataOutputStream.txt"));
                ){
            dos.writeInt(97);
            dos.writeDouble(99.5);
            dos.writeBoolean(true);
            dos.writeUTF("一二三456");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

DataInputStream(数据输入流)

用于读取数据输出流写出去的数据

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

import java.io.*;

/**
 * 目标:使用数据输入流读取特定类型的数据
 */
public class DataInputStreamTest2 {
    public static void main(String[] args) {
        try (
                DataInputStream dis =
                        new DataInputStream(new FileInputStream("io-app2/src/testDataOutputStream.txt"));
                ){
            int i = dis.readInt();
            System.out.println(i);

            double d = dis.readDouble();
            System.out.println(d);

            boolean b = dis.readBoolean();
            System.out.println(b);

            String rs = dis.readUTF();
            System.out.println(rs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

IO流-序列化流

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

ObjectOutputStream(对象字节输出流)

可以把 Java 对象进行序列化:把 Java 对象存入到文件中去

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

注意:对象如果要参与序列化,必须实现序列化接口(java.io.Serializable

import java.io.Serializable;

// 注意:对象如果需要序列化,必须实现序列化接口
public class User implements Serializable {
    private String loginName;
    private String userName;
    private int age;
    // transient 表示这个成员变量将不参与序列化
    private transient 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 + '\'' +
                '}';
    }
}
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
 * 目标:掌握对象字节输出流的使用:序列化对象
 */
public class Test1ObjectOutputStream {
    public static void main(String[] args) {
        try (
                // 2、创建一个对象字节输出流包装原始的字节 输出流
                ObjectOutputStream oos =
                        new ObjectOutputStream(new FileOutputStream("io-app2/src/testObjectOutput.txt"));
                ){
            // 1、创建一个Java对象
            User u = new User("admin", "张三", 32, "666888xyz");

            // 3、序列化对象到文件中去
            oos.writeObject(u);
            System.out.println("序列化对象成功!!");

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

ObjectInputStream(对象字节输入流)

可以把 Java 对象进行反序列化:把存储在文件中的 Java 对象读入到内存中来

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

如果要一次序列化多个对象,该怎么办呢 ?

用一个 ArrayList 集合存储多个对象,然后直接对集合进行序列化即可

注意:ArrayList 集合已经实现了序列化接口

import java.io.FileInputStream;
import java.io.ObjectInputStream;

/**
 * 目标:掌握对象字节输入流的使用:反序列化对象
 */
public class Test2ObjectInputStream {
    public static void main(String[] args) {
        try (
                // 创建一个对象字节输入流管道,包装低级的字节输入流与源文件接通
                ObjectInputStream ois =
                        new ObjectInputStream(new FileInputStream("io-app2/src/testObjectOutput.txt"));
                ){
            User u = (User) ois.readObject();
            System.out.println(u);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

IO框架

什么是框架 ?

  • 解决某类问题,编写的一套类、接口等,可以理解成一个半成品,大多框架都是第三方研发的
  • 好处:在框架的基础上开发,可以得到优秀的软件架构,并能提高开发效率
  • 框架的形式:一般是把类、接口等编译成 class 形式,再压缩成一个 .jar 结尾的文件发行出去

什么是IO框架 ?

封装了 Java 提供的对文件、数据进行操作的代码,对外提供了更简单的方式来对文件进行操作,对数据进行读写等

Commons-io

比较常用的有 Commons-io 框架,Commons-io 是 apache 开源基金组织提供的一组有关 IO 操作的小框架,目的是提高 IO 流的开发效率

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

Commons-io的下载

由于 Commons-io 框架是第三方开发的,所有我们需要进行下载才能使用

下载很简单,进入其官网下载即可,点击此处进入官网,下载图中这一个即可,然后解压缩

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

在解压后的文件夹中找到图中这一个,这个压缩包就是我们开发时会使用到的

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java
下一步我们需要将这个压缩包导入到要使用的项目中去,步骤如下

  1. 在项目中创建一个文件夹 lib,用来放置压缩包
  2. 找到压缩包复制一下,然后粘贴到 lib 文件夹下
  3. 在 lib 文件夹下右键点击压缩包,选择 Add as Library,再点击 OK 即可
  4. 在类中导包使用

如下图这样即为成功

【Java从入门到大牛】IO流下篇,Java从入门到大牛,java

Commons-io的具体应用文章来源地址https://www.toymoban.com/news/detail-686669.html

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;

/**
 * 目标:使用CommonsIO框架进行IO相关的操作
 */
public class CommonsIOTest1 {
    public static void main(String[] args) throws Exception {
        FileUtils.copyFile(new File("io-app2\\src\\test01.txt"), new File("io-app2/src/a.txt"));
//        FileUtils.copyDirectory(new File("D:\\resource\\test1"), new File("D:\\resource\\test2"));
//        FileUtils.deleteDirectory(new File("D:\\resource\\test2"));

        // Java官方提供的原生的一行代码搞定很多事情
//         Files.copy(Path.of("io-app2\\src\\test01.txt"), Path.of("io-app2\\src\\b.txt"));
//        System.out.println(Files.readString(Path.of("io-app2\\src\\test01.txt")));
    }
}

到了这里,关于【Java从入门到大牛】IO流下篇的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 从零开始学习 Java:简单易懂的入门指南之IO字节流(三十)

    生活中,你肯定经历过这样的场景。当你编辑一个文本文件,忘记了 ctrl+s ,可能文件就白白编辑了。当你电脑上插入一个U盘,可以把一个视频,拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢?键盘、内存、硬盘、外接设备等等。 我们把这种数据的传输,可以看做

    2024年02月08日
    浏览(43)
  • 从零开始学习 Java:简单易懂的入门指南之IO字符流(三十一)

    当使用字节流读取文本文件时,可能会有一个小问题。就是遇到中文字符时,可能不会显示完整的字符,那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类,以字符为单位读写数据,专门用于处理文本文件。 java.io.Reader 抽象类是表示用于读取字符流的

    2024年02月08日
    浏览(46)
  • 从零开始学习 Java:简单易懂的入门指南之IO缓冲流、转换流(三十二)

    缓冲流,也叫高效流,是对4个基本的 FileXxx 流的增强,所以也是4个流,按照数据类型分类: 字节缓冲流 : BufferedInputStream , BufferedOutputStream 字符缓冲流 : BufferedReader , BufferedWriter 缓冲流的基本原理,是在创建流对象时,会创建一个内置的默认大小的缓冲区数组,通过缓冲

    2024年02月08日
    浏览(73)
  • 太牛了! GitHub大牛呕心沥血整理的5000页Java学习手册文档

    写在前面 今天整理了一套 5000 页的 Java 学习手册,,新鲜出炉,分享给大家!此手册内容专注 Java技术,包括 JavaWeb,SSM,Linux,Spring Boot,MyBatis,MySQL,Nginx,Git,GitHub,Servlet,IDEA,多线程,集合,JVM,DeBug, Dubbo,Redis,算法,面试题等相关内容。 添加图片注释,不超过 140

    2024年02月03日
    浏览(42)
  • 从零开始学习 Java:简单易懂的入门指南之IO序列化、打印流、压缩流(三十三)

    Java 提供了一种对象 序列化 的机制。用一个字节序列可以表示一个对象,该字节序列包含该 对象的数据 、 对象的类型 和 对象中存储的属性 等信息。字节序列写出到文件之后,相当于文件中 持久保存 了一个对象的信息。 反之,该字节序列还可以从文件中读取回来,重构对

    2024年02月08日
    浏览(55)
  • Java ConcurrentHashMap 高并发安全实现原理解析,字节大牛耗时八个月又一力作

    //下一个哈希表 private transient volatile NodeK,V[] nextTable; //计数的基准值 private transient volatile long baseCount; //控制变量,不同场景有不同用途,参考下文 private transient volatile int sizeCtl; //并发搬运过程中CAS获取区段的下限值 private transient volatile int transferIndex; //计数cell初始化或者扩容

    2024年04月15日
    浏览(37)
  • 【Java系列】详解多线程(三)—— 线程安全(下篇)

    个人主页:兜里有颗棉花糖 欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 兜里有颗棉花糖 原创 收录于专栏【Java系列专栏】【JaveEE学习专栏】 本专栏旨在分享学习Java的一点学习心得,欢迎大家在评论区交流讨论💌 我们先来看一下什么是内存可见性问题,通过一段代码来进

    2024年02月04日
    浏览(44)
  • 15年大牛用140多个实战案例深入讲解Java微服务架构实战:SpringBoot +SpringCloud +Docker +RabbitMQ

    第一部分,springboot篇; 第1章SpringBoot编程起步; 1.SpringBoot提倡的是一种简洁的开发模式,可保证用户不被大量的配置文件和依赖关系所困扰。 2.SpringBoot开发需要Maven或 Gradle构建工具支持。 3.SpringBoot使用一系列的注解来简化开发过程。 第2章SpringBoot程序开发; 1. SpringBoot的依赖

    2024年04月09日
    浏览(51)
  • 【Java基础篇 | 面向对象】—— 聊聊什么是接口(下篇)

    个人主页:兜里有颗棉花糖 欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 兜里有颗棉花糖 原创 收录于专栏【JavaSE_primary】 本专栏旨在分享学习JavaSE的一点学习心得,欢迎大家在评论区交流讨论💌 上篇(【Java基础篇 | 面向对象】—— 聊聊什么是接口(上篇))中我们已经

    2024年02月05日
    浏览(32)
  • 【Java系列】详解多线程(二)——Thread类及常见方法(下篇)

    个人主页:兜里有颗棉花糖 欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 兜里有颗棉花糖 原创 收录于专栏【Java系列专栏】【JaveEE学习专栏】 本专栏旨在分享学习Java的一点学习心得,欢迎大家在评论区交流讨论💌 在操作系统中创建线程时,通常会同时创建相应的PCB并将其

    2024年02月04日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包