使用Java操作文件与文件IO流（字节流，缓冲字节流，字符流，缓冲字符流）

news2025/1/29 14:01:20

文章目录

  • 1. 认识文件
  • 2. 文件的类型
  • 3. 操作文件
    • 3.1 属性
    • 3.2 构造方法
    • 3.3 常用方法
  • 4. IO流
    • 4.1 字节流
      • 4.1.1 InputStream
      • 4.1.2 OutputStream
      • 4.1.3 flush刷新
      • 4.1.4 关闭文件close
      • 4.1.5 字节缓冲流
    • 4.2 字符流
      • 4.2.1 Reader
      • 4.2.2 Writer
      • 4.2.3 Scanner
      • 4.2.4 字符缓冲流
  • 5. 复制文件
    • 5.1 字节流复制图片
    • 5.2 缓冲字节流复制图片
    • 5.3 字符流复制Java文件
    • 5.4 缓冲字符流复制Java文件
    • 5.5 耗时对比

1. 认识文件

  • 侠义上的文件：硬盘上的文件和目录（文件夹）
  • 广义上的文件：泛指计算机中很多的软硬件资源，操作系统中，把很多的硬件设备和软件资源抽象成文件，按照文件的方式统一管理

此处只讨论侠义上的文件，也就是硬盘上的文件

每个文件在硬盘上都有一个具体的路径，表示一个文件的具体位置路径，就可以使用/（斜杠）或\（反斜杠）来分割不同的目录级别
在这里插入图片描述

路径有两种表示风格：

  1. 绝对路径：以盘符c:，d:这样开头的
  2. 相对路径：以当前所在的目录（工作目录）为基准，./或../开头，./有时候可以省略

说明： 每个程序运行的时候都有一个工作目录，./为当前目录，../为上级目录，打开idea，下面的路径就是idea的工作目录，我们在程序中要是写相对目录的话，就是以该路径为基准的

在这里插入图片描述

2. 文件的类型

我们一般将文件分为两种类型，文本文件与二进制文件

文本文件存的是文本也就是字符串，字符串是由字符构成的，每个字符是由一个整数数字表示的
二进制文件存储的是二进制数据

小技巧：如何区分文本文件与二进制文件？

使用记事本打开文件，看的懂就是文本文件，看不懂（乱码）的就是二进制文件

3. 操作文件

Java标准库提供了File这个类

3.1 属性

separator是File类里的一个静态变量，表示的是系统里的路径分割符

        System.out.println(File.separator);

在这里插入图片描述

\反斜杠是windows系统中路径的分割符

3.2 构造方法

构造方法说明
File(String pathName)根据文件路径创建一个File实例，路径可以为绝对或者相对路径
File(File parent, String child)根据父目录与孩子文件创建一个File实例，父目录用File表示
File(String parent, String child)根据父目录与孩子路径创建一个File实例，父目录用String表示

注意： 使用路径创建File实例的时候，不要求文件真实存在

        File file1 = new File("D:/photo/1.jpg"); //最常用
        File file2 = new File("D:/photo/","2.jpg");
        File file3 = new File(new File("D:/photo/"),"3.jpg");

3.3 常用方法

返回值方法说明
booleanexists()目录或文件是否存在
StringgetName()返回目录或文件的名称
StringgetPath()返回文件路径（使用啥路径创建FIle，返回啥路径）
StringgetAbsolutePath()返回绝对路径
booleanisDirectory()是否是目录
booleanisFile()是否是文件
File[]listFiles()返回目录下一级的子文件夹或子文件
booleanmkdir()创建目录
booleanmkdirs()创建多级目录
booleancreateNewFile()创建文件
booleandelete()删除文件

示例1：

        File file = new File("./dir/test.txt"); //此路径不要求真实存在
        System.out.println(file.getName()); //获取目录或文件名称
        System.out.println(file.getPath()); //获取文件路径（用啥路径创建File，返回啥路径）
        System.out.println(file.getAbsoluteFile()); //获取文件绝对路径
        System.out.println(file.getCanonicalPath()); //获取使用File修饰过的绝对路径
        System.out.println(file.exists()); //判断目录或文件是否存在
        System.out.println(file.isFile()); //判断是否是文件
        System.out.println(file.isDirectory()); //判断是否是目录

在这里插入图片描述

示例2：

        File file = new File("./a/b/c");
        file.mkdirs(); //创建多级目录
        File file1 = new File("./a/b/c/d.txt");
        file1.createNewFile(); //创建文件

在这里插入图片描述

示例3：

        File file1 = new File("./a/b/c/d.txt");
        file1.delete(); //删除文件

在这里插入图片描述

4. IO流

针对文件内容的读写，使用流对象来操作

流对象从类型上分为两个大类别：

  1. 字节流：操作二进制数据
    InputStream（字节输入流）
    OutputStream（字节输出流）
  2. 字符流：操作文本数据
    Reader（字符输入流）
    Writer（字符输出流）

这些类的使用方式比较固定：

  1. 打开文件
  2. 读文件
  3. 写文件
  4. 关闭文件

输入输出的方向：

  • 数据从硬盘到内存称为读（input）
  • 数据从内存到硬盘称为写（output）

使用推荐：

  • 对于文本文件，推荐使用字符流进行读写，使用二进制读写也行，只是推荐使用字符流
  • 对于二进制文件（图片，视频等），使用字节流进行读写

字节数组可以和字符串相互转换

字节数组转字符串：

byte[] bytes = new byte[1024];
String str = new String(bytes);

还可以指定字节数组的范围

int len = 10;
String str = new String(bytes,0,len);

字符串转字节数组：

String str = "hello";
byte[] bytes = str.getBytes();

字符转字节是编码，字节转字符是解码，解码编码如果不一致会发生乱码，所以在字符串与字节数组进行转换的时候可以指定编码集：

byte[] bytes = str.getBytes("utf-8");
String s = new String(bytes,"utf-8");

不同编码类型说明：

  • GBK：英文占1个字节，中文占2个字节
  • UTF-8：英文占1个字节，中文占3个字节
  • Unicode：英文占2个字节，中文占2个字节
  • Ascll：单字节编码，无中文

4.1 字节流

4.1.1 InputStream

InputStream是一个抽象类不能创建实例，要创建实例得使用它的子类，我们使用FileInputStream创建字节输入流对象

InputStream的方法：

方法说明
int read()一次读一个字节，返回读到的内容，返回-1代表读完
int read(byte[] b)一次读一个字节数组，返回实际读到的长度，返回-1代表读完
int read(byte[] b, int off, int len)往字节数组b从off开始，读取len个长度，返回读到的长度，返回-1代表读完
void close()关闭字节输入流

FileInputStream的构造方法：

构造方法说明
FileInputStream(String fileName)使用文件路径构建输入流对象（可以是绝对路径或相对路径）
FileInputStream(File file)使用File对象构建输入流对象

注意： 创建输入流的时候必须要保证文件存在，否则会抛出异常，因为是在读文件

一个字节一个字节的读：

public class Demo2 {
    public static void main(String[] args) throws IOException {
        //该文件路径必须存在，因为是读文件
        InputStream is = new FileInputStream("./dir/test.txt");
        int n;
        while((n = is.read()) != -1){
            System.out.println(n);
        }
        is.close();
    }
}

在这里插入图片描述
上述代码是一次读一个字节，导致读的次数多，而单次IO操作是要访问硬盘设备的，单词操作是比较耗时的，如果频繁进行这样的IO操作，效率肯定低

一次读一个字节数组：

public class Demo3 {
    public static void main(String[] args) throws IOException {
        InputStream is = new FileInputStream("./dir/test.txt");
        byte[] bytes = new byte[1024];
        int len;
        while((len = is.read(bytes)) != -1){
            for(int i = 0;i < len;i++){
                System.out.println(bytes[i]);
            }
        }
        is.close();
    }
}

在这里插入图片描述

这种操作一次最多可读1024个字节，大大减少了IO操作的次数，也就是减少了访问硬盘设备的次数，所以效率大大提高了

将读到的字节数组转换为字符串输出:

public class Demo3 {
    public static void main(String[] args) throws IOException {
        InputStream is = new FileInputStream("./dir/test.txt");
        byte[] bytes = new byte[1024];
        int len;
        while((len = is.read(bytes)) != -1){
            String s = new String(bytes,0,len);
            System.out.println(s);
        }
    }
}

在这里插入图片描述

4.1.2 OutputStream

OutputStream也是一个抽象类，不可以创建实例，我们使用它的子类FileOutputStream创建字节输出流对象

注意： 使用FileOutputStream创建对象时，文件不要求真实存在，如果文件不存在，则会创建文件

在这里插入图片描述

运行程序后，发现文件被创建

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

方法说明
void write(int b)一次写一个字节
void write(byte[] b)一次写一个字节数组
int write(byte[] b, int off, int len)从字节数组off位置开始写，一次写len长度
void close()关闭字节输出流

写文件之前，文件中存在内容hello

在这里插入图片描述

public class Demo5 {
    public static void main(String[] args) throws IOException {
        OutputStream os = new FileOutputStream("./dir/test.txt");
        os.write(97);
        os.write(98);
        os.write(99);
        os.write(100);
        os.close();
    }
}

写文件后，文件内容被更新为abcd

在这里插入图片描述

说明： 使用OutputStream打开文件，默认会清空文件原有的内容，如果想在原文件的基础上追加写，则在创建输出流对象时添加一个参数true，true代表不清空文件原有内容追加写

public class Demo5 {
    public static void main(String[] args) throws IOException {
        OutputStream os = new FileOutputStream("./dir/test.txt",true);
        os.write(97);
        os.write(98);
        os.write(99);
        os.write(100);
        os.close();
    }
}

发现在abcd的基础上又多了abcd

在这里插入图片描述

一次写一个字节数组：

public class Demo6 {
    public static void main(String[] args) {
        try(OutputStream os = new FileOutputStream("./dir/test.txt")){
            byte[] bytes = {96,97,98,99,100};
            os.write(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4.1.3 flush刷新

IO操作是很慢的，所以OutputStream为了减少IO次数，写数据的时候会先将数据写到内存的一个指定区域里，该区域称为缓冲区，直到该区域满了或者满足其他指定条件时，才会把数据真正的写入到硬盘中，所以我们写文件的时候，很可能数据还存在缓冲区中，我们常常在合适的位置调用flush()，将数据刷新到硬盘中

public class Demo6 {
    public static void main(String[] args) {
        try(OutputStream os = new FileOutputStream("./dir/test.txt")){
            byte[] bytes = {96,97,98,99,100};
            os.write(bytes);
            os.flush(); //刷新操作
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4.1.4 关闭文件close

在写或者读完文件，都要调用close来关闭文件，那调用close到底关闭的是什么？

在内核里，使用PCB这样的数据结构来表示进程，一个进程可以用一个或者多个PCB来表示，而一个线程对应一个PCB，PCB中有一个属性，文件描述符表（类似与数组）记录了该进程打开了哪些文件
一个进程里有多个线程，有多个PCB，这些PCB公用一个文件描述符表

在这里插入图片描述

  • 每次打开文件，就会在文件描述符表中申请一个空间，然后把该文件的信息放进去
  • 每次关闭文件（close），就会把这个文件描述符表对应的表项释放掉

如果文件没关闭，也就是没有调用close会怎样呢？

如果没有调用close，那文件描述符中对应的表项就不会及时的被释放掉，虽然Java中有GC操作，但是这个GC不一定及时，也就是不手动调用close释放，会导致文件描述符表很快被占满了（文件描述符表的容量大小一定，不能自动扩容）如果被占满了，后续在打开文件向文件描述符表申请空间的时候就会失败，所以文件就打不开了

一般来说close要被手动执行的，但是如果该文件始终伴随着程序，那么不关闭问题也不大，因为随着程序的运行结束，进程的销毁，PCB也就跟着销毁了，文件描述符表也就销毁了，对应的资源，操作系统就自动回收了

一般写代码都是要手动调用close的，那么如果保证close一定被执行到呢？

使用try-finally：

public class Demo5 {
    public static void main(String[] args) throws IOException {
        OutputStream os = null;
        try{
            os = new FileOutputStream("./dir/test.txt",true);
            os.write(97);
            os.write(98);
            os.write(99);
            os.write(100);
        }finally{
            os.close();
        }
    }
}

这种方式代码写着不优雅，有一种更推荐的写法：

public class Demo5 {
    public static void main(String[] args) throws IOException {
        try(OutputStream os = new FileOutputStream("./dir/test.txt",true)){
            os.write(97);
            os.write(98);
            os.write(99);
            os.write(100);
        }
    }
}

这样写对然没有显式调用close，但是在try语句块执行完，会自动调用close，try()中满足自动释放的有一定要求的，类必须实现Closeable接口，才可以自动调用close释放资源

在这里插入图片描述

4.1.5 字节缓冲流

一个字节一个字节的读会频繁进行IO操作，也就是频繁发生系统内核调用，这个操作是很耗时的，使用字节缓冲流，类似“池子”快速读写，减少系统内核调用频率

  • 字节缓冲输入流：BufferedInputStream(InputStream is)
  • 字节缓冲输出流：BufferedOutputStream(OutputStream os)

注意： 字节缓冲流构造函数的参数是字节流对象不是文件路径

缓冲流在内存提供一个区域为缓冲区，做了封装以块形式读写数据，但是读写数据还是依赖字节流对象，缓冲区的大小默认是8k（8192字节）

缓冲流和字节流之间的关系图：
在这里插入图片描述
缓冲字节输入流读数据：

public class Demo10 {
    public static void main(String[] args) throws IOException {
        try(BufferedInputStream bis = new BufferedInputStream(new FileInputStream("./dir/test.txt"))){
            int n;
            byte[] bytes = new byte[1024];
            while((n = bis.read(bytes)) != -1){
                String str = new String(bytes,0,n);
                System.out.print(str);
            }
        }
    }
}

在这里插入图片描述

缓冲字节输出流写数据：

public class Demo11 {
    public static void main(String[] args) throws IOException {
        try(BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("./dir/test.txt"))){
            String str = "世界，你好";
            byte[] bytes = str.getBytes();
            bos.write(bytes);
            bos.flush();
        }
    }
}

在这里插入图片描述

4.2 字符流

字符流其实就是带编码的字节流，对于文本类型的文件，优先使用字符流，字符流的使用和字节流差不多

4.2.1 Reader

Reader是一个抽象类，必须new其子类FileReader

方法说明
int read()一次读一个字符，返回读的内容，返回-1代表读完
int read(char[] c)一次读一个字符数组，返回读的长度，返回-1待变读完
int read(char[] c, int off, int len)一次读一个字符数组的范围

一次读一个字符：

public class Demo8 {
    public static void main(String[] args) throws IOException {
        try(Reader r = new FileReader("./dir/test.txt")){
            int n;
            while((n = r.read()) != -1){
                System.out.println(n);
            }
        }
    }
}

往字符数组中读：

public class Demo8 {
    public static void main(String[] args) throws IOException {
        try(Reader r = new FileReader("./dir/test.txt")){
            char[] c = new char[100];
            int n;
            while((n = r.read(c)) != -1){
                String s = new String(c,0,n);
                System.out.print(s);
            }
        }
    }
}

在这里插入图片描述

4.2.2 Writer

Writer是一个抽象类，new的时候必须new其子类FileWriter

方法说明
void write(int c)一次写一个字符
void write(String str)一次写一个字符串
void write(char[] c)一次写一个字符数组
void write(String str, int off, int len)一次写字符串的部分数据
void write(char[] c, int off, int len)一次写字符数组的部分数据
public class Demo9 {
    public static void main(String[] args) throws IOException {
        try(Writer w = new FileWriter("./dir/test.txt")){
            w.write(98);
            w.write('\n');
            w.write("hello");
            w.write('\n');
            char[] c = {'w','o','r','l','d'};
            w.write(c);
            w.write('\n');
            w.write("好好学习",0,2);
            w.write('\n');
            w.write(c,0,2);
            w.flush();
        }
    }
}

在这里插入图片描述

4.2.3 Scanner

Scanner是搭配流对象使用的

构造方法说明
Scanner(InputStream is, String charset)使用charset字符集对is的扫描进行读取

我们常常写的这句代码：System.in就是一个输入流对象

Scanner sc = new Scanner(System.in);

也可以使用我们存在的文件构建流对象传入：

public class Demo7 {
    public static void main(String[] args) {
        try(Scanner sc = new Scanner(new FileInputStream("./dir/test.txt"))){
            while(sc.hasNext()){
                System.out.println(sc.nextLine());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

4.2.4 字符缓冲流

字符缓冲流的用法和字节缓冲流一样，是对字符流进行了封装，缓冲区的大小默认也是8k

  • 字符缓冲输入流：BufferedReader(FileReader fr)
  • 字符串冲输出流：BufferedWriter(FileWriter fw)

字符缓冲流读数据：

public class Demo12 {
    public static void main(String[] args) throws IOException {
        try(BufferedReader br = new BufferedReader(new FileReader("./dir/test.txt"))){
            int len;
            char[] c = new char[10];
            while((len = br.read(c)) != -1){
                String str = new String(c,0,len);
                System.out.print(str);
            }
        }
    }
}

在这里插入图片描述

字符缓冲流写数据：

public class Demo12 {
    public static void main(String[] args) throws IOException {
        try(BufferedWriter bw = new BufferedWriter(new FileWriter("./dir/test.txt"))){
            String str = "好好学习 找好工作";
            bw.write(str);
            bw.flush();
        }
    }
}

在这里插入图片描述

5. 复制文件

复制文件前提说明：

  • 用字节流复制图片文件（.jpg）
  • 用字符流复制普通的xml文件（.xml）

5.1 字节流复制图片

    public static void method1() throws IOException {
        InputStream is = new FileInputStream("./dir/图片.jpg");
        OutputStream os = new FileOutputStream("./dir/图片复制.jpg");
        int len;
        byte[] bytes = new byte[1024];
        while((len = is.read(bytes)) != -1){
            os.write(bytes,0,len);
        }
        os.flush();
        os.close();
        is.close();
    }

在这里插入图片描述

5.2 缓冲字节流复制图片

    public static void method2() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("./dir/图片.jpg"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("./dir/图片复制1.jpg"));
        int len;
        byte[] bytes = new byte[1024];
        while((len = bis.read(bytes)) != -1){
            bos.write(bytes);
        }
        bos.flush();
        bos.close();
        bis.close();
    }

在这里插入图片描述

5.3 字符流复制Java文件

    public static void method3() throws IOException {
        FileReader fr = new FileReader("./dir/server.xml");
        FileWriter fw = new FileWriter("./dir/server1.xml");
        int len;
        char[] c = new char[255];
        while((len = fr.read(c)) != -1){
            fw.write(c,0,len);
        }
        fw.flush();
        fw.close();
        fr.close();
    }

在这里插入图片描述

5.4 缓冲字符流复制Java文件

    public static void method4() throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("./dir/server.xml"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("./dir/server2.xml"));
        int len;
        char[] c = new char[255];
        while((len = br.read(c)) != -1){
            bw.write(c,0,len);
        }
        bw.flush();
        bw.close();
        br.close();
    }

在这里插入图片描述

5.5 耗时对比

我们对上述的四个操作的耗时进行分组对比

  1. 字节流与缓冲字节流对比
  2. 字符流与缓冲字符流对比

看看哪个效率更高？

    public static void main(String[] args) throws IOException {
        long start1 = System.currentTimeMillis();
        method1();
        long end1 = System.currentTimeMillis();
        System.out.println("字节流耗时："+(end1-start1));
        long start2 = System.currentTimeMillis();
        method2();
        long end2 = System.currentTimeMillis();
        System.out.println("缓冲字节流耗时："+(end2-start2));
        long start3 = System.currentTimeMillis();
        method3();
        long end3 = System.currentTimeMillis();
        System.out.println("字符流耗时："+(end3-start3));
        long start4 = System.currentTimeMillis();
        method4();
        long end4 = System.currentTimeMillis();
        System.out.println("缓冲字符流耗时："+(end4-start4));
    }

在这里插入图片描述

从中发现，带缓冲的流比不带缓冲的流效率高，但是这里好像差别不大，那是因为这里举例的文件本身不大，大家可以换成稍微大的文件，效果更明显

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/433592.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

深度学习优化方法

深度学习优化方法

如有错误&#xff0c;感谢不吝赐教、交流 文章目录 一、梯度下降如何选择学习率不能太小不能太大 二、小批量随机梯度下降如何选择批量大小不能太小不能太大 总结 三、常用优化方法SGDAdagradAdam实现大佬经验 一、梯度下降 如何选择学习率 不能太小 以缓慢的速度接近最优值&…
阅读更多...
sqoop的介绍与安装

sqoop的介绍与安装

简介 Sqoop 是一款开源的工具&#xff0c;主要用于在 Hadoop(Hive) 与传统的数据库 (mysql 、 postgresql...) 间进行数据的传递&#xff0c;可以将一个关系型数据库&#xff08;例如 &#xff1a; MySQL ,Oracle ,Postgres 等&#xff09;中的 数据导进到 Hadoop 的 …
阅读更多...
从单兵作战到生态共创，纵目科技打响智驾2.0新战役

从单兵作战到生态共创，纵目科技打响智驾2.0新战役

4月18日&#xff0c;第十二届上海国际汽车工业展览会&#xff08;简称&#xff1a;2023上海车展&#xff09;在上海国家会展中心盛大启幕。纵目科技携最新自动驾驶解决方案——Amphiman 3000、8000行泊一体解决方案、Trinity 3000、8000舱行泊一体解决方案以及众多摄像头产品强…
阅读更多...
15-721 Chapter8 数据分布model分析

15-721 Chapter8 数据分布model分析

Data Organization 有两个data pool&#xff0c;一个是不可变长的block&#xff0c;一个是可变长的block,然后要定位的话&#xff0c;我们只要知道是哪个block&#xff0c;和他的offset,我们就可以定位 下面是数据类型&#xff0c;单个类型太大的话&#xff0c;我们要来个溢出…
阅读更多...
真的很迷茫！

真的很迷茫！

作者&#xff1a;阿秀 校招八股文学习网站&#xff1a;https://interviewguide.cn 这是阿秀的第「258」篇原创 小伙伴们大家好&#xff0c;我是阿秀。 欢迎今年参加秋招的小伙伴加入阿秀的学习圈&#xff0c;目前已经超过 2300 小伙伴加入&#xff01;去年认真准备和走下来的基…
阅读更多...
vue 中quill-editor富文本图片和视频上传功能

vue 中quill-editor富文本图片和视频上传功能

quill-editor富文本对于新手来说是个很友好的富文本编辑器。但是里面的图片上传和视频上传功能在实际的工作中不能满足要求。 1.原生的图片上传会转换成bas64格式， 2.视频上传只是个输入框，要有视频链接了才能添加视频；而且视频标签是iframe标签，并不是video标签。 现在…
阅读更多...
大数据分析案例-基于XGBoost算法构造房屋租赁价格评估模型

大数据分析案例-基于XGBoost算法构造房屋租赁价格评估模型

&#x1f935;‍♂️ 个人主页&#xff1a;艾派森的个人主页 ✍&#x1f3fb;作者简介&#xff1a;Python学习者 &#x1f40b; 希望大家多多支持&#xff0c;我们一起进步&#xff01;&#x1f604; 如果文章对你有帮助的话&#xff0c; 欢迎评论 &#x1f4ac;点赞&#x1f4…
阅读更多...
asp.net+sqlserver基于web的在校大学生贷款管理系统

asp.net+sqlserver基于web的在校大学生贷款管理系统

采用的技术&#xff1a; 1.ASP.NET框架&#xff1b; 2. SQL Server 数据库&#xff1b; 3.AJAX技术&#xff1a;它不是一种新的编程语言&#xff0c;而是一种用于创建更好更快以及交互性更强的 Web 应用程序的技术&#xff1b; 4.HTML,CSSDIV,代码实现静态页面&#xff1b; 开…
阅读更多...
HTML5 ＜output＞ 标签、HTML5 ＜optgroup＞ 标签

HTML5 ＜output＞ 标签、HTML5 ＜optgroup＞ 标签

HTML5 <output> 标签 实例 HTML5 <output>标签用来定义不同类型的输出。请参考下述示例&#xff1a; 将计算结果显示在 <output> 元素中&#xff1a; <form oninput"x.valueparseInt(a.value)parseInt(b.value)">0<input type"ran…
阅读更多...
达索系统基于系统工程的AUTOSAR设计端到端解决方案 | 达索系统百世慧®

达索系统基于系统工程的AUTOSAR设计端到端解决方案 | 达索系统百世慧®

目录 达索系统基于系统工程的AUTOSAR设计端到端解决方案 达索系统&#xff1a;陪伴AUTOSAR一起成长 达索系统的解决方案&#xff1a;MBSE和AUTOSAR结合 软件设计端到端的追溯能力 系统架构设计中的“条理分明” 全贯通的一站式平台 科技是第一生产力&#xff0c;达索系统…
阅读更多...
项目设计：迷宫游戏设计day2

项目设计：迷宫游戏设计day2

今天主要把搜出最短路径想出来了&#xff0c;但还是没有优化&#xff0c;其思想就是&#xff0c;再搜的时候&#xff0c;记录它的前驱结点&#xff0c;这样就能在最后的时候就可以把它的最短路径以反序遍历的方式&#xff0c;将他输出出来 明天再优化优化
阅读更多...
JVM系统优化实践（17）：线上GC案例（二）

JVM系统优化实践（17）：线上GC案例（二）

您好&#xff0c;我是湘王&#xff0c;这是我的CSDN博客&#xff0c;欢迎您来&#xff0c;欢迎您再来&#xff5e; GC的概念并不难明白&#xff0c;而且它的原理也不复杂&#xff0c;但是很难用好。为什么&#xff1f;因为每个平台、架构、指标、运行环境都不一样&#xff0c;甚…
阅读更多...
设计模式-行为型模式之中介者模式

设计模式-行为型模式之中介者模式

2. 中介者模式 2.1. 模式动机 在用户与用户直接聊天的设计方案中&#xff0c;用户对象之间存在很强的 关联性&#xff0c;将导致系统出现如下问题&#xff1a; 系统结构复杂 对象之间存在大量的相互关联和调用&#xff0c;若有一个对象发生变化&#xff0c;则需要跟踪和该对象关…
阅读更多...
初识 MongoDB

初识 MongoDB

文章目录 一、简介二、体系结构三、数据类型四、特点五、应用场景 提示&#xff1a;以下是本篇文章正文内容&#xff0c;MongoDB 系列学习将会持续更新 一、简介 MongoDB 是一个文档数据库&#xff0c;是由字段和值对&#xff08;field:value&#xff09;组成的数据结构&…
阅读更多...
煤矿电子封条视频监控系统 yolov7

煤矿电子封条视频监控系统 yolov7

煤矿电子封条视频监控系统基于yolov7python网络模型视频AI智能分析技术&#xff0c;煤矿电子封条视频监控算法模型对现场皮带撕裂、跑偏、皮带异物、堆煤等设备异常状态实时监控分析自动识别预警。YOLOv7 的发展方向与当前主流的实时目标检测器不同&#xff0c;研究团队希望它能…
阅读更多...
（原创）Flutter基础入门：装饰器Decoration

（原创）Flutter基础入门：装饰器Decoration

前言 作为一个Android开发&#xff0c;最近打算把自己学的Flutter相关知识做个积累&#xff0c;所以这会是一个系列的博客。里面讲的都会是一些Flutter相关的知识&#xff0c;有基础的&#xff0c;也有比较深入的&#xff0c;由浅入深嘛。 那么今天作为开篇&#xff0c;就先讲…
阅读更多...
经典回顾丨同为科技（TOWE）在2008年奥运场馆防雷建设中都做了什么？

经典回顾丨同为科技（TOWE）在2008年奥运场馆防雷建设中都做了什么？

针对大型体育赛事场馆防雷建设工作非常重要&#xff0c;这是因为大型体育赛事通常吸引了大量的观众和运动员聚集&#xff0c;一旦场馆遭受雷击&#xff0c;可能会造成严重的伤亡和财产损失。如今&#xff0c;大型体育赛事的场馆都会配备防雷设施&#xff0c;如建筑物避雷针、接…
阅读更多...
代理设计模式解读

代理设计模式解读

目录 代理模式的基本介绍 静态代理 静态代码模式的基本介绍 应用实例 思路分析图解(类图) 代码实战 静态代理优缺点 动态代理 动态代理模式的基本介绍 JDK 中生成代理对象的 API 代码实战 Cglib 代理 Cglib 代理模式的基本介绍 Cglib 代理模式实现步骤 Cglib 代理模…
阅读更多...
同为科技（TOWE）机柜PDU电源插头类型详解

同为科技（TOWE）机柜PDU电源插头类型详解

机柜PDU电源插座作为机房服务器众多设备运行的“最后一米”也是最为密切的电源配件&#xff0c;专用于精细保护单相交流供电的敏感设备&#xff0c;其品质好坏直接影响到各个设备的正常运行。机柜PDU电源管理器是由插头、线缆、主体三个部分组成&#xff0c;其中电源插头可以分…
阅读更多...
leetcode24. 两两交换链表中的节点

leetcode24. 两两交换链表中的节点

给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4] 输出&#xff1a;[2,1…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023