【JAVA IO流】

已于 2022-04-24 21:56:13 修改
阅读量394 收藏
点赞数 3
分类专栏： Java IO流 文章标签： java intellij-idea
于 2022-04-24 21:53:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rita_zf/article/details/124392878
版权

目录

IO导学

File类： 用于描述一个文件或者目录的。

通过File对象我们可以读取文件或者目录的属性数据，如果我们需要读取文件的内容数据，那么我们需要使用IO流技术。

IO流（Input Output）

IO流解决问题： 解决设备与设备之间的数据传输问题。 内存—>硬盘 硬盘—>内存

IO流技术：

IO流分类：
如果是按照数据的流向划分：

     输入流


     输出流

如果按照处理的单位划分：

     字节流： 字节流读取得都是文件中二进制数据，读取到的二进制数据不会经过任何的处理。


     字符流： 字符流读取的数据是以字符为单位的。 字符流也是读取文件中的二进制数据，不过会把这些二进制数据转换成我们能识别 的字符。
                字符流= 字节流 + 解码
如果按照处理的功能和位置划分：

     节点流：


     处理流：

输入字节流：
----------| InputStream 所有输入字节流的基类 抽象类
--------------| FileInputStream 读取文件数据的输入字节流

使用FileInputStream读取文件数据的步骤：
1. 找到目标文件
2. 建立数据的输入通道。
3. 读取文件中的数据。
4. 关闭 资源。

File类

方法描述
File对象.exists()获取文件或目录
File对象.getName()获取文件或目录的名字
File对象.createNewFile()创建一个新文件
File对象.mkdir()创建一个新的目录（但是不能递归创建）
File对象.mkdirs()创建递归目录
File对象.delete()删除文件或目录
File对象.deleteOnExit()文件或目录程序退出时删除
File对象.isDirectory()判断是否是目录
File对象.isFile()判断是否是文件
File对象.listFiles()获取指定目录的所有目录及文件
Arrays.asList()把某一个数组当作集合

File对象判断文件是否存在

使用file.exists()判断文件是否存在

public class FileTest {
    @Test
    public void test01(){
        // 根据路径创建File对象
        File file = new File("src/main/resources/笔记.txt");
        // 判断文件或目录是否存在
        boolean exists = file.exists();
        try {
            assert exists = true;
            System.out.println(file.getName()+"存在");
        }catch (AssertionError e){
            System.out.println(file.getName()+"不存在");
        }
    }
}

resources中有笔记.txt输出

笔记.txt存在

File对象创建目录或文件

File对象创建文件

使用file.createNewFile()创建一个新文件

public class FileTest {
@Test
    public void test02() {
        // 根据路径创建File对象
        File file = new File("src/main/resources/a.txt");
        // 判断文件或目录是否存在
        if (!file.exists()){
            try {
                file.createNewFile();
                System.out.println("文件"+file.getName()+"创建成功");
            } catch (IOException e) {
                System.out.println("文件"+file.getName()+"创建失败");
                throw new RuntimeException(e);
            }
        }else {
            System.out.println(file.getName()+"已存在，终止创建过程！！！");
        }
    }
}

输出

文件a.txt创建成功

在这里插入图片描述

在这里插入图片描述

File对象创建目录

使用file.mkdir()创建目录 但不能递归创建

public class FileTest {
@Test
    public void test03() {
        // 根据路径创建File对象
        File file = new File("src/main/resources/资料");
        // 判断文件或目录是否存在
        if (!file.exists()){
            // 创建目录 但不能递归创建
            if (file.mkdir()){
                System.out.println("目录"+file.getName()+"创建成功");
            }else {
                System.out.println("目录"+file.getName()+"创建失败");
            }
        }else {
            System.out.println(file.getName()+"已存在，终止创建过程！！！");
        }
    }
}

输出

目录资料3创建成功

递归创建目录

public class FileTest {
 @Test
    public void test04() {
        // 根据路径创建File对象
        File file = new File("src/main/resources/资料/day33");
        // 判断文件或目录是否存在
        if (!file.exists()){
            // 递归创建
            if (file.mkdirs()){
                System.out.println("目录"+file.getName()+"创建成功");
            }else {
                System.out.println("目录"+file.getName()+"创建失败");
            }
        }else {
            System.out.println(file.getName()+"已存在，终止创建过程！！！");
        }
    }
}

输出

目录day33创建成功

File对象删除目录和文件

删除目录

public class FileTest {
 @Test
    public void test05() {
        // 根据路径创建File对象
        // File file = new File("src/main/resources/资料/day33");
         File file = new File("src/main/resources/资料");
        // 判断文件或目录是否存在
        if (file.exists()){
            // 删除目录
            if (file.delete()){
                System.out.println("目录" + file.getName()+"删除成功");
            }else {
                System.out.println("目录" + file.getName()+"删除失败");
            }
        }else {
            System.out.println(file.getName()+ "不存在！！！");
        }
    }
 }

输出

目录资料删除成功

删除文件

public class FileTest {
@Test
    public void test06() {
        // 根据路径创建File对象
        File file = new File("src/main/resources/a.txt");
        // 判断文件或目录是否存在
        if (file.exists()){
            // 删除文件
            if (file.delete()){
                System.out.println("文件" + file.getName()+"删除成功");
            }else {
                System.out.println("文件" + file.getName()+"删除失败");
            }
        }else {
            System.out.println(file.getName()+ "不存在！！！");
        }
    }
}

输出

文件a.txt删除成功

File对象程序运行结束之后删除目录和文件

public class FileTest {
 @Test
    public void test07() {
        // 根据路径创建File对象
        File file = new File("src/main/resources/a.txt");
        // 判断文件或目录是否存在
        if (file.exists()){
            // 程序运行结束之后删除文件或目录
            try {
                file.deleteOnExit();
                Thread.sleep(1000*10);
                System.out.println("文件" + file.getName()+"删除成功");
            } catch (InterruptedException e) {
               throw new RuntimeException(e);
            }
        }else {
            System.out.println(file.getName()+ "不存在！！！");
        }
    }
}

10秒之后删除输出

文件a.txt删除成功

File对象判断resources中的是目录还是文件

根据路径判断resources中的是目录还是文件

如:路径是src/main/resources/资料

public class FileTest {
 @Test
    public void test08() {
        // 根据路径创建File对象
        File file = new File("src/main/resources/资料");
        // 判断文件或目录是否存在
        if (file.exists()){
            // 根据路径判断resources中的是目录还是文件
            System.out.println(file.isDirectory());
            System.out.println(file.isFile());
        }else {
            System.out.println(file.getName()+ "不存在！！！");
        }
    }
}

输出

true
false

如:路径是src/main/resources/笔记.txt

public class FileTest {
@Test
    public void test09() {
        // 根据路径创建File对象
        File file = new File("src/main/resources/笔记.txt");
        // 判断文件或目录是否存在
        if (file.exists()){
            // 根据路径判断resources中的是目录还是文件
            System.out.println(file.isDirectory());
            System.out.println(file.isFile());
        }else {
            System.out.println(file.getName()+ "不存在！！！");
        }
    }
}

输出

false
true

File对象遍历输出目录名和文件名

File对象遍历输出目录名和文件名

public class FileTest {
@Test
    public void test10() {
        // 根据路径创建File对象
        File file = new File("src/main/resources");
        // 获取所有目录和文件数组
        File[] files = file.listFiles();
        // 遍历输出目录名和文件名
        for (File newFile : files) {
            if (newFile.isDirectory()){
                System.out.println("目录 >>> "+newFile.getName());
            }else if (newFile.isFile()){
                System.out.println("文件 >>> "+newFile.getName());
            }
        }
    }
}

输出

文件 >>> 笔记.txt
目录 >>> 资料

File对象lambda表达式遍历输出目录名和文件名

public class FileTest {
 @Test
    public void test11() {
        // 根据路径创建File对象
        File file = new File("src/main/resources");
        // 获取所有目录和文件数组
        File[] files = file.listFiles();
        // lambda表达式遍历输出目录名和文件名
        List<File> fileList = Arrays.asList(files);
        fileList.forEach(newFile ->{
            if (newFile.isDirectory()){
                System.out.println("目录 >>> "+newFile.getName());
            }else if (newFile.isFile()){
                System.out.println("文件 >>> "+newFile.getName());
            }
        });
    }
}

输出

文件 >>> 笔记.txt
目录 >>> 资料

File对象StreamAPI过滤输出目录名

public class FileTest {
 @Test
    public void test12() {
        // 根据路径创建File对象
        File file = new File("src/main/resources");
        // 获取所有目录和文件数组
        File[] files = file.listFiles();
        // StreamAPI过滤输出目录名
        List<File> fileList = Arrays.asList(files);
        fileList.stream().filter(newFile -> newFile.isDirectory()).forEach(newFile -> System.out.println("目录 >>> "+newFile.getName()));
    }
}

输出

目录 >>> 资料

IO类（Input Output）

方法描述
File对象.length()获取在内存中的大小
inputStream.read()读取文件内容
outputStream.write()写入的字符串
outputStream.flush()刷新写入内容

File对象获取文本内容在内存中的存储大小

在resources里新建一个b.txt文件并输入内容
在这里插入图片描述获取b.txt文本内容在内存中的存储大小

public class Stream01Test {
    @Test
    public void test01(){
        File file = new File("src/main/resources/b.txt");
        // 获取在内存中的大小
        System.out.println(file.length());
    }
}

输出

3

FileInputStream读取文本内容

在resources里新建一个b.txt文件并输入内容
在这里插入图片描述

FileInputStream读取文本内容

public class Stream01Test {
 @Test
    public void test03(){
        // 声明文件位置
        File file = new File("src/main/resources/b.txt");
        // 声明字节输入流
        InputStream inputStream = null;
        try {
            // 实例化FileInputStream
            inputStream = new FileInputStream(file);
            // 使用read方法读取文件内容
            int read = inputStream.read();
            System.out.println((char) read);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

输出

a

FileInputStream循环读取文本内容

public class Stream01Test {
@Test
    public void test04(){
        // 声明文件位置
        File file = new File("src/main/resources/b.txt");
        // 声明字节输入流
        InputStream inputStream = null;
        try {
            // 实例化FileInputStream
            inputStream = new FileInputStream(file);
            // 使用read方法读取文件内容
            int read = -1;
            while ((read=inputStream.read())!=-1){
                System.out.print((char) read);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

输出

abc

FileInputStream利用数组循环读取文本内容

在resources里新建一个b.txt文件并输入内容
在这里插入图片描述
声明一个数组，使在读取字节的时候一次读取1024个字节

public class Stream01Test {
 @Test
    public void test08(){
        // 声明文件位置
        File file = new File("src/main/resources/b.txt");
        // 声明字节输入流
        InputStream inputStream = null;
        try {
            // 实例化FileInputStream
            inputStream = new FileInputStream(file);
            byte[] b = new byte[1024];
            // 使用read方法读取文件内容
            int read = -1;
            while ((read=inputStream.read(b))!=-1){
                System.out.print(new String(b,0,read));
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

输出

love爱love

FileOutputStream写入文件

把输出的内容变成getBytes数组
FileOutputStream目标文件后面加true就可以追加要写入的内容
在这里插入图片描述

public class Stream02Test {
    @Test
    public void tes01(){
        try {
            // 目标文件
            OutputStream outputStream = new FileOutputStream("src/main/resources/c.txt");
            // 准备写入的字符串
            String content = "I love you";
            byte[] bytes = content.getBytes(StandardCharsets.UTF_8);
            outputStream.write(bytes);
            outputStream.flush();
            System.out.println("写入成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void tes02(){
        try {
            // 目标文件
            OutputStream outputStream = new FileOutputStream("src/main/resources/c.txt",true);
            // 准备写入的字符串
            String content = "\nI love you too";
            byte[] bytes = content.getBytes(StandardCharsets.UTF_8);
            outputStream.write(bytes);
            outputStream.flush();
            System.out.println("写入成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void tes03(){
        try {
            // 目标文件
            OutputStream outputStream = new FileOutputStream("src/main/resources/c.txt",true);
            // 准备写入的字符串
            String content = "\n桃李不言下自成蹊";
            byte[] bytes = content.getBytes(StandardCharsets.UTF_8);
            outputStream.write(bytes);
            outputStream.flush();
            System.out.println("写入成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出

写入成功

写入后的c.txt中的内容
在这里插入图片描述

字节输入输出流

字节输入输出流实现文件复制

public class Stream03Test {
    @Test
    public void test01(){
        try {
            // 原文件
            InputStream inputStream = new FileInputStream("src/main/resources/c.txt");
            // 目标文件
            OutputStream outputStream = new FileOutputStream("src/main/resources/a.txt");
            int b = -1;
            while ((b = inputStream.read())!=-1){
                outputStream.write(b);
            }
            outputStream.flush();
            System.out.println("复制完成");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

输出

复制完成

在这里插入图片描述

字节输入输出流复制二进制文件

public class Stream03Test {
@Test
    public void test02(){
        try {
            // 原文件
            InputStream inputStream = new FileInputStream("src/main/resources/9.jpg");
            // 目标文件
            OutputStream outputStream = new FileOutputStream("src/main/resources/9.png");
            int b = -1;
            while ((b = inputStream.read())!=-1){
                outputStream.write(b);
            }
            outputStream.flush();
            System.out.println("复制完成");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

输出

复制完成

在这里插入图片描述

字节输入输出流实现文件的加密与解密

加密
public class Stream03Test {
 @Test
    public void test03(){
        try {
            // 原文件
            InputStream inputStream = new FileInputStream("src/main/resources/9.jpg");
            // 目标文件
            OutputStream outputStream = new FileOutputStream("src/main/resources/9.bmp");
            int b = -1;
            while ((b = inputStream.read())!=-1){
                outputStream.write(b ^ 123);
            }
            outputStream.flush();
            System.out.println("复制完成");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

输出

复制完成

在这里插入图片描述

解密
public class Stream03Test {
@Test
    public void test04(){
        try {
            // 原文件
            InputStream inputStream = new FileInputStream("src/main/resources/9.bmp");
            // 目标文件
            OutputStream outputStream = new FileOutputStream("src/main/resources/99.bmp");
            int b = -1;
            while ((b = inputStream.read())!=-1){
                outputStream.write(b ^ 123);
            }
            outputStream.flush();
            System.out.println("复制完成");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

输出

复制完成

在这里插入图片描述

字节输入输出流增加缓存复制文件

public class Stream03Test {
@Test
    public void test05(){
        try {
            // 原文件
            InputStream inputStream = new FileInputStream("pom.xml");
            // 目标文件
            OutputStream outputStream = new FileOutputStream("pom.txt");
            byte[] bytes = new byte[1024 * 8];
            int b = -1;
            while ((b = inputStream.read(bytes))!=-1){
                outputStream.write(bytes,0,b);
            }
            outputStream.flush();
            System.out.println("复制完成");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

输出

复制完成

在这里插入图片描述

带缓存的字节输入输出流

public class Stream04Test {
    @Test
    public void test01(){
        InputStream in = null;
        OutputStream out = null;
        InputStream input = null;
        OutputStream output = null;
        try {
            // 使用字节输入流读取文件
            in = new FileInputStream("pom.xml");
            // 使用字节输出流写入文件
            out = new FileOutputStream("pom.pom");
            // 使用带有缓存的字节输入流
            input = new BufferedInputStream(in);
            // 使用带有缓存的字节输出流
            output = new BufferedOutputStream(out);
            int b = -1;
            while ((b = input.read())!=-1){
                output.write(b);
            }
            output.flush();
            System.out.println("写入完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出

写入完成

在这里插入图片描述
BufferedInputStream缓存大小是8192
在这里插入图片描述
BufferedOutputStream缓存大小是8192
在这里插入图片描述

字符输入输出流

public class ReaderAndWriterTest {
    @Test
    public void test01(){
        Reader reader = null;
        try {
            reader = new FileReader("pom.xml");
            int read = -1;
            while ((read = reader.read())!=-1){
                System.out.print((char) read);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void test02(){
        Writer writer = null;
        try {
            writer = new FileWriter("pom.pom");
            String content = "桃李不言下自成蹊";
            writer.write(content);
            writer.flush();
            System.out.println("写入完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void test03(){
        Reader reader = null;
        Writer writer = null;
        try {
            reader = new FileReader("pom.xml");
            writer = new FileWriter("pom.pom");
            int read = -1;
            while ((read = reader.read())!=-1){
                writer.write(read);
            }
            writer.flush();
            System.out.println("写入完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void test04(){
        Reader reader = null;
        Writer writer = null;
        try {
            reader = new FileReader("pom.xml");
            writer = new FileWriter("pom.pom");
            char[] chars = new char[1024 * 8];
            int read = -1;
            while ((read = reader.read(chars))!=-1){
                writer.write(chars,0,read);
            }
            writer.flush();
            System.out.println("写入完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void test05(){
        Reader in = null;
        Writer out = null;
        Reader reader = null;
        Writer writer = null;
        try {
            in = new FileReader("pom.xml");
            out = new FileWriter("pom.pom");
            reader = new BufferedReader(in);
            writer = new BufferedWriter(out);
            int read = -1;
            while ((read = reader.read())!=-1){
                writer.write(read);
            }
            writer.flush();
            System.out.println("写入完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出

写入完成

字节流与字符相互转换

 @Test
    public void test06(){
        // 输入
        // 字节输入流
        InputStream in = null;
        // 输入处理流
        Reader input = null;
        // 缓存的字符输入流
        BufferedReader reader = null;

        // 输出
        // 字节输出流
        OutputStream out = null;
        // 输出处理流
        Writer output = null;
        // 缓存的字符输出流
        BufferedWriter writer = null;
        try {
            // 输入
            in = new FileInputStream("pom.xml");
            input = new InputStreamReader(in);
            reader = new BufferedReader(input);
            // 输出
            out = new FileOutputStream("pom.pom");
            output = new OutputStreamWriter(out);
            writer = new BufferedWriter(output);
            // 一次读取一行 但是读取不到文本分隔符 返回一个字符串
            String content = null;
            while ((content = reader.readLine())!= null){
                writer.write(content + "\n");
            }
            writer.flush();
            System.out.println("写入成功");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

输出

写入成功
Rita_zzf
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java IO流详细笔记
07-12
Java IO流详解
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
Java基础：IO流浅解
sinat_40265490的博客
05-17 176
在看了几篇关于IO流的文章之后，想记录一下自己的理解，于是便有了这篇文件，如有什么错误还望各位指出以便改正，谢谢。 一、IO流的概念 一个IO流可以理解为java内存中对一段数据序列的一次读写操作（数据序列和读写操作缺一不可）。 二、IO流的分类 对IO流的分类，有许多前辈已经做的很好了，我直接搬来过来，就不班门弄斧了。 按照数据流的方向不同可以分为：输入流和输出流。 按照处理数...
Maven项目读取resources下文件报java.io.FileNotFoundException: .\src\main\resources\template\.....(系统找不到指定的路径)
发则韩的博客
04-28 8153
开发工具：IDEA 错误信息： java.io.FileNotFoundException: .\src\main\resources\template[Table2]Service.java (系统找不到指定的路径。) at java.io.FileInputStream.open0(Native Method) at java.io.FileInputStream.open(FileInpu...
Java程序，使用字符输入、输出流读取文件，将一段文字加密后存入文件，然后再读取，并将加密前和加密后的文件输出。
程序研博客
09-21 1173
11
Java io流 详解
m0_68987535的博客
06-11 4549
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
java IO流
D大调奏鸣曲_第七序章_de博客
11-11 8万+
目录 序 一、IO流开篇 1、概念 2、流的分类 3、IO流的作用 4、IO流的使用场景 二、字节流 1、字节流抽象基类 2、字节流写数据 （1）基本步骤 （2）三种方式 （3）两个问题 （4）异常处理 3、字节缓冲流 （1）基本分类&概述 （2）构造方法 （3）代码演示 三、字符流 1、概念 2、分类 （1）字符流体系图 （2）字符输入流（Reader） （3）字符输出流（Writer） 3、字符缓冲流 （1）概念 （2）构造方法 （3）...
Java IO流（超详细！）
一只小菜鸡
05-07 5万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
Java IO流详解
ss810540895的博客
04-21 1万+
原文 Java IO流详解 1.什么是IO Java中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。 IO又分为流IO（java.io）和块IO(java.nio) Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的
Java IO流的种类
程序员
02-20 3204
Java IO流的种类
java IO流之BufferedReader和BufferedWriter
学习笔记，相关教程 分享
04-03 6230
笑霸能看懂的学习笔记
javaIO流javaIO流javaIO流
07-02
Java IO流是Java平台中用于处理输入输出操作的核心机制，它允许程序与各种数据源（如文件、设备、网络）进行交互。Java IO流体系结构是基于“流”的概念，流是一组有序的数据序列，可以是字节流或字符流。Java IO库...
java IO流文件的读写具体实例
09-04
Java IO流是Java平台中用于处理输入输出的重要机制，它允许程序与各种数据源和目的地进行交互，包括文件、网络连接、系统硬件等。在Java中，IO流分为四个主要类别，分别是字节流（处理二进制数据）、字符流（处理...
Java IO流 文件传输基础
09-02
Java IO流是Java平台中用于处理输入输出的重要机制，它涉及到数据从源到目标的传输。文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，...
配置Java开发环境
Broken_x的博客
07-10 1262
Java开发环境配置
java集合工具类
最新发布
hejiefeng111的博客
07-12 125
【代码】java集合工具类。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 231
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 390
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
javaio流电子书整理面试必考io流帮助你入职阿里腾讯
03-12
"Java IO流是Java编程中用于处理输入输出操作的重要概念，涉及数据的持久化、存储介质和各种应用场景。本电子书主要讲解了IO流的基础知识，包括流的概念、分类、IO流体系，以及InputStream和OutputStream的使用。书...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Rita_zzf

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值