Java基础学习生疏知识点总结（15）——IO字节流

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

文章目录

1、IO概述

1.1 什么是IO？

  • i:input输入
  • o: output 输出

1.2 为什么会有IO？

  • 需要长久保存的数据都是以文件的形式存储的,存储在外边设备当中
  • 内存有限,需要把数据读取到内存才行,需要io交互

1.3 java中如何实现IO功能？

  • 通过流
  • java流模型
    在这里插入图片描述

1.4 流的分类

  • 按照流向分(前提条件,以内存为参照)
    ①输入流 input
    ②输出流output
  • 按照数据类型分类
    ①字节流 : 一连串的01二进制数据 按字节传输 1B=8bit 0000 0000
    ②字符流: 一连串的字符序列,把它当做一种文化符号 , “你” “abc” ,“の”

1.5 抽象基类

  • 字节输出流 OutputStream
  • 字节输入流: InputStream
  • 字符输出流:Writer
  • 字符输入流:Reader
    注意：
    由这4个基类派生出的子类,其子类名都是以父类名作为后缀的
    FileOutputStream 文件字节输出流
    FileInputStream 文件字节输入流

1.6 什么时候该用什么流

  • 不知道用啥的时候就用字节流 字节流是万能的
  • 对于文本文件 我们选择用字符流

2、字节流

2.1 字节输出流

在这里插入图片描述
在这里插入图片描述

2.2 字节输出流具体子类

2.2.1FileOutputStream

在这里插入图片描述
例子：

package com.cskaoyan.bytestream.out;

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

/**
 * @description: 构造方法
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo1 {
    public static void main(String[] args) throws IOException {
        // 方式一
        File file = new File("a.txt");
        FileOutputStream out = new FileOutputStream(file);
        // 方式二
        FileOutputStream fileOutputStream = new FileOutputStream("a.txt");

        FileOutputStream outputStream = new FileOutputStream(new File("a.txt"));
    }
}

在这里插入图片描述
3个write方法：

package com.cskaoyan.bytestream.out;

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

/**
 * @description: write方法
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo2 {
    public static void main(String[] args) throws IOException {
        // 创建文件字节输出流对象
        FileOutputStream out = new FileOutputStream("../day16_io01/a.txt");
        // 第一种write方法 write(int b)
        // writeSingle(out);


        // 第二种write方法 write(byte[] b)
        String s = "abc";
        //writeMuti(out, s);

        // 第三种write方法 write(byte[] b ,int off,int len)
        byte[] bytes = s.getBytes();
        out.write(bytes,0,bytes.length);
        // 写数据
        
        // 关闭资源 close
        out.close();
    }

    private static void writeMuti(FileOutputStream out, String s) throws IOException {
        byte[] bytes = s.getBytes();
        out.write(bytes);
    }

    private static void writeSingle(FileOutputStream out) throws IOException {
        out.write(97);
        out.write(98);
    }
}

在这里插入图片描述

package com.cskaoyan.bytestream.out;

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

/**
 * @description: 文件追加写入
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo3 {
    public static void main(String[] args) throws IOException {
        FileOutputStream outputStream =
                new FileOutputStream("../day16_io01/a.txt",true);
        outputStream.write("def".getBytes());
        outputStream.close();
    }
}

在这里插入图片描述

package com.cskaoyan.bytestream.out;

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

/**
 * @description: 换行
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo4 {
    public static void main(String[] args) throws IOException {
        FileOutputStream outputStream =
                new FileOutputStream("../day16_io01/a.txt",true);
        //outputStream.write("\n".getBytes());
        //outputStream.write(System.lineSeparator().getBytes());
        outputStream.write("\r".getBytes());
        outputStream.write("def".getBytes());
        outputStream.close();    }
}

在这里插入图片描述

package com.cskaoyan.bytestream.out;

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

/**
 * @description: 异常处理方式一
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo5 {
    public static void main(String[] args) {
        FileOutputStream out = null;
        try {

            out = new FileOutputStream("../day16_io01/a.txt");
            out.write(97);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (out != null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

在这里插入图片描述

package com.cskaoyan.bytestream.out;

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

/**
 * @description: 异常处理方式二
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo6 {
    public static void main(String[] args) {
        try(FileOutputStream out = new FileOutputStream("../day16_io01/a.txt")) {
            // 写数据
            out.write("abc".getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

例子：

package com.cskaoyan.bytestream.out;

/**
 * @description: AutoCloseable例子
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo7 {
    public static void main(String[] args) {
        try(A a = new A()) {
            a.test();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class A implements AutoCloseable {

    @Override
    public void close() throws Exception {
        System.out.println("close 方法执行了!!");
    }

    public void test(){
        System.out.println("test 执行了!!");
    }

}

2.2.2 BufferedOutputStream

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.cskaoyan.bytestream.buff;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @description:
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo {
    public static void main(String[] args) throws IOException {
        //FileOutputStream out = new FileOutputStream("a.txt");
        //BufferedOutputStream bo = new BufferedOutputStream(out);
        BufferedOutputStream bufferedOutputStream =
                new BufferedOutputStream(new FileOutputStream(new File("a.txt")));

        bufferedOutputStream.write(97);
        //bufferedOutputStream.flush();
        // 对于包装流 我们只需关闭最外层的流
        // close方法会执行flush方法
        bufferedOutputStream.close();
    }
}

注意：
①close方法会执行flush方法
②对于包装流 我们只需关闭最外层的流

2.2.3 装饰设计模式

不改变原有类的基础上去扩展新的功能
在这里插入图片描述

package com.cskaoyan.bytestream.decorator;

/**
 * @description: 装饰设计模式例子
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo {
    public static void main(String[] args) {
        MilkTea milkTea = new MilkTea();
        milkTea.add();
        System.out.println("-------------");
        DecoratorA decoratorA = new DecoratorA();
        decoratorA.setBeverage(milkTea);
        decoratorA.add();
        System.out.println("---------------");
        DecoratorB decoratorB = new DecoratorB();
        decoratorB.setBeverage(decoratorA);
        decoratorB.add();
        System.out.println("---------------");
        DecoratorC decoratorC = new DecoratorC();
        decoratorC.setBeverage(decoratorB);
        decoratorC.add();
    }
}

/*表示饮料 基类*/
abstract class Beverage {
    // 添加小料
    abstract void add();
}
/*奶茶类*/
class MilkTea extends Beverage {

    @Override
    void add() {
        System.out.println("老板,来杯奶茶,加冰! ");
    }
}
/*装饰器类*/
class Decorator extends Beverage {
    public Beverage beverage;

    public void setBeverage(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    void add() {
        beverage.add();
    }
}
/*加珍珠*/
class DecoratorA extends Decorator {
    @Override
    void add() {
        super.add();
        addZz();
    }

    private void addZz() {
        System.out.println("再加点珍珠!");
    }
}
/*加椰果*/
class DecoratorB extends Decorator {
    @Override
    void add() {
        super.add();
        addYg();
    }

    private void addYg() {
        System.out.println("再加点椰果!");
    }
}

class DecoratorC extends Decorator {
    @Override
    void add() {
        super.add();
        addHd();
    }

    private void addHd() {
        System.out.println("再加点红豆");
    }
}

2.3 字节输入流

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.4 字节输入流具体子类

2.4.1 FileInputStream

在这里插入图片描述
例子：

public class Demo1 {
    public static void main(String[] args) throws IOException {
        // 创建字节输入流对象
        FileInputStream fileInputStream = new FileInputStream(new File("a.txt"));

        FileInputStream fileInputStream1 = new FileInputStream("a.txt");
    }
}

在这里插入图片描述

package com.cskaoyan.bytestream.in;

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

/**
 * @description:
 * @author: songtao@cskaoyan.onaliyun.com
 **/
// workspace
public class Demo2 {
    public static void main(String[] args) throws IOException {
        // 创建字节输入流对象
        FileInputStream in = new FileInputStream("../day16_io01/a.txt");

        // 读取数据
        //readSingle(in);
        //readMuti(in);
        byte[] bytes = new byte[1024];
        int readCount = in.read(bytes, 0, bytes.length);
        System.out.println(new String(bytes,0,readCount));

        // close
        in.close();
    }

    private static void readMuti(FileInputStream in) throws IOException {
        byte[] bytes = new byte[1024];
        int readCount = in.read(bytes);
        // 字节数组转化成字符串
        String s = new String(bytes, 0, readCount);
        System.out.println(s);
    }

    private static void readSingle(FileInputStream in) throws IOException {
        // read() 返回的是读取到的一个字节值
        int readData = in.read();
        System.out.println(((char) readData));

        int readData2 = in.read();
        System.out.println(((char) readData2));

        int readData3 = in.read();
        System.out.println(((char) readData3));

        int readData4 = in.read();
        System.out.println(((char) readData4));

        int readData5 = in.read();
        System.out.println((readData5));
    }
}

在这里插入图片描述

package com.cskaoyan.bytestream.in;

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

/**
 * @description:
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo3 {
    public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("../day16_io01/a.txt");
        byte[] bytes = new byte[4];
        int readCount = in.read(bytes);
        System.out.println(readCount);
        System.out.println(new String(bytes));
        int readCount2 = in.read(bytes);
        System.out.println(readCount2);
        System.out.println(new String(bytes,0,readCount2));

    }
}

循环读

package com.cskaoyan.bytestream.in;

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

/**
 * @description: 循环读
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo4 {
    public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("../day16_io01/a.txt");
        // 第一种方式
        //readWhile(in);
        // 单字节
        //readWhile2(in);

        // 字节数组的方式
        int readCount;
        byte[] bytes = new byte[1024];
        while ((readCount = in.read(bytes)) != -1) {
            System.out.println(new String(bytes,0,readCount));
        }

        // 关闭资源
        in.close();
    }

    private static void readWhile2(FileInputStream in) throws IOException {
        int readData;
        while ((readData=in.read()) != -1) {
            System.out.println(readData);
        }
    }

    private static void readWhile(FileInputStream in) throws IOException {
        while (true) {
            int readData = in.read();
            System.out.println(readData);
            if (readData == -1) {
                break;
            }
        }
    }
}

2.4.2 BufferedInputStream

在这里插入图片描述
在这里插入图片描述

package com.cskaoyan.bytestream.buff;

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

/**
 * @description:
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo2 {
    public static void main(String[] args) throws IOException {
        BufferedInputStream br =
                new BufferedInputStream(new FileInputStream("a.txt"));
        // 读数据
        int readData = br.read();
        System.out.println(((char) readData));
        // close
        br.close();
    }
}

2.5 复制文件练习

在这里插入图片描述

package com.cskaoyan.bytestream.ex;

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

/**
 * @description: 复制文本文件
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo1 {
    public static void main(String[] args) throws IOException {
        // 创建字节输入流对象
        FileInputStream in = new FileInputStream("aa.txt");
        // 创建字节输出流对象
        FileOutputStream out = new FileOutputStream("bb.txt");
        // 边读边写
        // 按照单字节的方式去复制文件 耗时:18ms
        //copy1(in, out);
        // 字节数组的方式
        copy2(in, out);
        // close
        in.close();
        out.close();
    }

    private static void copy2(FileInputStream in, FileOutputStream out) throws IOException {
        int readCount;
        byte[] bytes = new byte[1024];
        long start = System.currentTimeMillis();

        while ((readCount = in.read(bytes)) != -1) {
            out.write(bytes,0,readCount);
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时:" + (end - start) + "ms");
    }

    private static void copy1(FileInputStream in, FileOutputStream out) throws IOException {
        long start = System.currentTimeMillis();
        int readData;
        while ((readData = in.read()) != -1) {
            out.write(readData);
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时:" + (end - start) + "ms");
    }
}

在这里插入图片描述

package com.cskaoyan.bytestream.ex;

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

/**
 * @description: 复制文本文件
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo1 {
    public static void main(String[] args) throws IOException {
        // 创建字节输入流对象
        FileInputStream in = new FileInputStream("D:\\mm.jpg");
        // 创建字节输出流对象
        FileOutputStream out = new FileOutputStream("mm.jpg");
        // 边读边写
        // 按照单字节的方式去复制文件 耗时:110ms
        copy1(in, out);
        // 字节数组的方式 耗时:1ms
        //copy2(in, out);
        // close
        in.close();
        out.close();
    }

    private static void copy2(FileInputStream in, FileOutputStream out) throws IOException {
        int readCount;
        byte[] bytes = new byte[1024];
        long start = System.currentTimeMillis();

        while ((readCount = in.read(bytes)) != -1) {
            out.write(bytes,0,readCount);
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时:" + (end - start) + "ms");
    }

    private static void copy1(FileInputStream in, FileOutputStream out) throws IOException {
        long start = System.currentTimeMillis();
        int readData;
        while ((readData = in.read()) != -1) {
            out.write(readData);
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时:" + (end - start) + "ms");
    }
}

在这里插入图片描述

package com.cskaoyan.bytestream.ex;

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

/**
 * @description: 复制文本文件
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Demo1 {
    public static void main(String[] args) throws IOException {
        // 创建字节输入流对象
        FileInputStream in = new FileInputStream("D:\\aa.mp4");
        // 创建字节输出流对象
        FileOutputStream out = new FileOutputStream("aa.mp4");
        // 边读边写
        // 按照单字节的方式去复制文件 耗时:8758ms
        //copy1(in, out);
        // 字节数组的方式 耗时:19ms
        copy2(in, out);
        // close
        in.close();
        out.close();
    }

    private static void copy2(FileInputStream in, FileOutputStream out) throws IOException {
        int readCount;
        byte[] bytes = new byte[1024];
        long start = System.currentTimeMillis();

        while ((readCount = in.read(bytes)) != -1) {
            out.write(bytes,0,readCount);
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时:" + (end - start) + "ms");
    }

    private static void copy1(FileInputStream in, FileOutputStream out) throws IOException {
        long start = System.currentTimeMillis();
        int readData;
        while ((readData = in.read()) != -1) {
            out.write(readData);
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时:" + (end - start) + "ms");
    }
}

得出结论

字节数组的方式效率更高
愿美梦成真
关注
专栏目录
IO流之字节流知识总结
zangjunlang4288的博客
07-01 119
IO流之字节流知识总结 IO流分为字符流和字节流。 字节流;可以读取任何文件，电脑以字节的方式储存 字符流:用来读取字符。 下面是我总结的思维导图。 相关练习代码 public class Demo { @Test public void fun() th...
java io难_Java 基础（四）| IO 流之使用文件流的正确姿势
weixin_42497839的博客
02-23 190
为跳槽面试做准备，今天开始进入 Java 基础的复习。希望基础不好的同学看完这篇文章，能掌握泛型，而基础好的同学权当复习，希望看完这篇文章能够起一点你的青涩记忆。一、什么是 IO 流？想象一个场景：我们在电脑上编辑文件，可以保存到硬盘上，也可以拷贝到 U 盘中。那这个看似简单的过程，背后其实是数据的传输。数据的传输，也就是数据的流动。既然是流动也就会有方向，有入方向和出方向。举个上传文件的栗子，...
Java基础学习生疏知识点总结（17）——IO字符流和其它流
weixin_43510391的博客
04-20 134
文章目录1、字符流1.1 字符输出流1.1.1 抽象基类Writer1.1.2 具体子类 1、字符流 字符流产生的原因 用字节流读取英文字符与数字 没有问题 能够正常显示 用字节流读取中文字符 可能会有问题 编解码 一个字符在计算机当中是怎样存储的? 基于某个编码表,有与之对应的整数值(编码值)存储在计算机当中的 编码 基于某个编码表,把字符数据转化成编码值的过程(把人看懂的东西转化成计算机看懂的东西) 解码 基于某个编码表,把编码值转化成字符数据的过程(把计算机看懂的东西转
Java基础学习生疏知识点总结（20）——SE模考错题总结
weixin_43510391的博客
04-26 926
3 设 int x = 1 , int y = 2 , int z = 3，则表达式 y＋＝z-- / ++x 的值是 _____。 A. 3 B. 3.5 C. 4 D. 5 8 下列说法中，_____是正确的。 A. 子类拥有的成员数目大于父类拥有的成员数目 B. 父类代表的对象范围比子类广 C. 子类要调用父类的方法，必须使用super关键字 D. 一个Java类可以有多个父类 14 下面代码的运行结果为：（） import java.io.; import java.util.; public
Java基础学习生疏知识点总结（16）——异常处理，文件和日期常用方法
weixin_43510391的博客
04-18 294
文章目录1、异常1.1 异常与错误1.2 Throwable的子类：1.3 Java设计异常体系的原则1.4 JVM异常处理机制1.5 处理异常语法1.6 自定义异常2 File2.1 System.getProperty("user.dir") 这个方法可以用来获取当前IDEA的相对路径2.2 常用API2.2.1分隔符2.2.2 文件创建2.2.3 删除文件2.2.4 文件移动与重命名2.2.5 File的判断功能2.2.6 File的获取功能2.2.7 File的高级获取功能2.2.8 listFil
Java——IO流
天上的光博客
06-01 189
前言：好久之前学的，最近有用到，感觉一些东西比较生疏，就回过头来梳理一下加深印象。 概念 首先我们来讲一些概念性的东西，从整体上感受一下这个流程：IO就是Input和Output。一个是in，一个是out。对应的：一个是进，一个是出。 我总是很喜欢用参照系这个概念，IO的参照系就是我们的应用程序，这里可以理解成我们编写的项目工程。 那么In是什么，In就是向我们的程序中读入，我们叫Read。Out是什么，Out就是我们从程序写出，我们叫Write。 很好理解吧？那么我们就可以想象一下整个数据走过的流程了：从
Java入门到架构师知识点整理，P8的技术大咖是这样通关的
前端工程师年薪30万，就靠这套教程！持续更新最新知识
04-08 1035
一个人最怕的不是路途遥远，而是看不到胜利曙光。我希望下面这篇文章能给你的学习之路带来一丝曙光，大家不妨试着读一下吧，如果有收获给我点个赞哟。 温馨提醒：这篇文章写着写着就一万字了，建议大家关注后再收藏，以防走丢。 这篇文章主要内容包括(干货满满)： 学Java有哪些就业方向？ 数据结构和算法 设计模式 计算机基础 Java 入门 Java 高手进阶 基础框架（SSM） 微服务框架 常用中间件 数据库 分布式架构 必须掌握的工具软件 学习资源网站列表汇总 学习常见问题（FAQ） 买一瓶可乐，泡一杯咖啡
Java基础总结
weixin_41077841的博客
08-25 603
文章目录1.Java 基础1. JDK 和 JRE 有什么区别？2. == 和 equals 的区别是什么？3. 两个对象的 hashCode()相同，则 equals()也一定为 true，对吗？4. final 在 java 中有什么作用？5. java 中的 Math.round(-1.5) 等于多少？6. String 属于基础的数据类型吗？7. java 中操作字符串都有哪些类？它们之间有什么区别？8. String str="i"与 String str=new String("i")一样吗？9
完整的Java从小白到大牛的自学路线
程序员高级码农的博客
03-15 1270
我相信这些读者或多或少都有一些 Java 基础，但由于看不到全貌，学了一段时间很容易迷失。所以我在寻思着能不能写一个学习的地图或者路线，让读者能知道下一步该学什么，自己离大厂的 offer还有多远的距离。一个人最怕的不是路途遥远，而是看不到胜利曙光。这篇文章主要内容包括(干货满满)：学Java有哪些就业方向？数据结构和算法设计模式计算机基础Java 入门Java 高手进阶基础框架（SSM）微服务框架常用中间件数据库分布式架构必须掌握的工具软件学习资源网站列表汇总。
部编版六年级(下)语文期末复习知识点总结.pdf
10-11
部编版六年级（下）语文期末复习知识点总结 本资源摘要信息为六年级（下）语文期末复习知识点总结，涵盖易读错的字、易写错的字、会写词语、多音字、形近字、近义词、反义词、词语搭配、词语归类、句子积累等十个...
Java基础学习生疏知识点总结（9）——多态（下）
weixin_43510391的博客
03-25 201
文章目录1、接口应用常见问题1.1 当父类实现接口，子类继承父类后，是否也要实现接口中的全部方法呢？1.2 接口只能在同一个包里创建吗？可以单独创建一个接口包吗？如果单独创建了接口包，怎么实现跨包的使用呢？1.3 如下图所示：1.4 一个java文件里可以存在几个接口？1.5 接口及其中成员默认修饰符都是什么？通常情况下如何访问？1.6 接口中的默认方法与静态方法看着差不读到，怎么区分呢？ 1、接口应用常见问题 1.1 当父类实现接口，子类继承父类后，是否也要实现接口中的全部方法呢？ 子类是否需要实现接口中
用 Java 的 IO 流进行读写文件操作
BASK2312的博客
11-17 2940
在计算机领域里 IO，有时也写作I/O，是的缩写，也就是输入和输出。这里的输入和输出是指不同系统之间的数据输入和输出，比如读写文件数据，读写网络数据等等。同步阻塞 IO 即 BIO（blocking IO），指的主要是传统的 java.io 包，它基于流模型实现。java.io 包提供了我们最熟知的一些 IO 功能，比如 File 对象提供的文件和目录操作，还有一大块就是通过输入输出流读写文件等。
Java设计模式学习总结（4）——创建型模式之单例模式
科技D人生
06-15 4465
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。注意：1、单例类只能有一个实例；2、单例类必须自己创建自己的唯一实例；3、单例类必须给所有其...
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 94
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 554
Java StreamAPI的使用与常用方法
智能BI平台项目
2302_79400545的博客
09-22 221
BI商业智能：数据可视化、报表可视化系统。
Android系统：系统架构
liufeismart2024的博客
09-23 437
Android的系统结构的设计混合了分层设计和分块设计。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 716
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
电路学习心得：从生疏到精通的探索
总结起来，电路学习不仅是理论知识的积累，更是实践能力的培养。从初学者的角度，理解和应用三要素法是掌握一阶电路分析的关键。在学习过程中，不断反思、练习和回顾，加上老师的悉心指导，将使我们对电路的理解更加...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值