文件操作和IO详解

news2025/7/10 9:33:43

v2-5119579f3b3a75da8d540ed2cebaa8f7_bfly0213

文件操作 和 IO

文件,File 这个概念,在计算机里,也是“一词多用”.

文件的狭义和广义

狭义的文件: 指的是硬盘上的文件和目录(文件夹)
广义的文件: 泛指计算机中很多的软硬件资源.操作系统中,把很多的硬件设备和软件设备都抽象成了文件.按照文件的方式来统一管理.例如网卡,操作系统就是把网卡当成了一个文件.
注: 平时谈到的“文件”,指的都是狭义的文件,也就是硬盘上的文件.

硬盘(外存)和内存相比

速度: 内存比硬盘快很多.
空间: 内存空间比硬盘小.
成本: 内存比硬盘快.
持久化: 内存掉电后数据丢失,外存掉电后数据还在.

文件路径

每个文件,在硬盘上都有一个具体的“路径”.

\ => 反斜杠 (使用 \ ,写代码的时候很不方便)
/ => 斜杠 (建议大家优先使用)

表示一个文件的具体位置路径是,就可以使用 / 来分割不同的目录级别.

image-20231014202007224

image-20231014203341037

在路径这里,有两种表示路径的风格.

  1. 绝对路径.以c: d:盘符开头的路径.

  2. 相对路径.以当前所在的目录为基准,以 . 或者 … 开头(. 有时候可以省略),找到指定的路径.

    当前所在的目录称为工作目录.每个程序运行的时候,都有一个工作目录(在控制台里通过命令操作的时候,是特别明显的,后来进化到图形化界面了,工作目录就不那么直观了).

image-20231014205208414

工作目录不同,定位到同一个文件,相对路径写法是不同的.

同样是定位到 java_code 这里
如果工作目录是 d:/ ,相对路径写作 ./code/java_code
如果工作目录是 d:/code ,相对路径写作 ./java_code
如果工作目录是 d:/code/python_code ,相对路径写作 …/java_code (… 表示当前目录的上级目录)
如果工作目录是 d:/code/python_code/2023 ,相对路径写作 …/…/java_code
注: 我们日常写java代码一般都会使用IDEA,当我们打开IDEA之后,IDEA的默认工作路径就是你的当前项目的所在目录. 如果代码中写了一些相对路径的代码,工作路径就是以上述路径为基准的!!!

在 Windows 电脑,命令行下,直接输入某个程序的名字,本质上是操作系统去PATH环境变量里查找的. calc (Windows自带的计算器) 本身就在 PATH 下,所以可以直接运行.自己装的程序,比如 qq 之类的,默认不行.但是如果把 qq.exe 的路径也加入到 PATH 就可以了.
注: Linux没有盘符的概念,统一是使用 cd 切换. Windows 有盘符,先定位盘符,再 cd 在当前盘符下切换.

文件的类型

文件分类: 文本 vs 二进制
word,exe,图片,视频,音频,源代码,动态库……这些不同的文件,整体可以归纳到两类中,文本文件和二进制文件.

文本文件

文本文件: 存的是文本,字符串.
字符串,是由字符构成的,每个字符,都是通过一个数字来表示的.
这个文本文件里存的数据,—定是合法的字符,都是在你指定字符编码的码表之内的数据.

二进制文件

二进制文件: 存的是二进制数据,不一定是字符串了,没有任何限制,可以存储任何你想要你想要的数据.

随便给你个文件,如何区分文本还是二进制?
直接使用记事本打开.如果乱码了,说明就是二进制.如果没乱说明就是文本.

Java 对于文件的操作

  1. 针对文件系统操作(创建文件,删除文件,重命)
  2. 针对文件内容操作(文件的读和写)

File 类

Java 标准库,提供了一个 File 这个类(java.io.File), 这个 FIle 类,封装了文件系统操作.
注: 有 File 对象，并不代表真实存在该文件.

属性

修饰符及类型属性说明
static StringpathSeparator依赖于系统的路径分隔符，String 类型的表示
static charpathSeparator依赖于系统的路径分隔符，char 类型的表示

注: pathSeparator => File 里的一个静态变量, 它是 / 还是 \ , 取决于操作系统.

构造方法

签名说明
File(File parent, String child)根据父目录 + 孩子文件路径，创建一个新的 File 实例
File(String pathname)根据文件路径创建一个新的 File 实例，路径可以是绝对路径或者 相对路径
File(String parent, String child)根据父目录 + 孩子文件路径，创建一个新的 File 实例，父目录用 路径表示

在 new File 对象的时候,构造方法参数中,可以指定一个路径,此时 File 对象就代表这个路径对应的文件了(指定一个路径 => 这里绝对路径和相对路径都行).
parent 表示当前文件所在的目录, child 自身的文件名.例如: d:/fly.jpg => parent d:/ , child fly.jpg

方法

**方法 **~~ 不需要死记,了解有印象即可

修饰符及返回值类型方法签名说明
StringgetParent()返回 File 对象的父目录文件路径
StringgetName()返回 File 对象的纯文件名称
StringgetPath()返回 File 对象的文件路径
StringgetAbsolutePath()返回 File 对象的绝对路径
StringgetCanonicalPath()返回 File 对象的修饰过的绝对路径
booleanexists()判断 File 对象描述的文件是否真实存在
booleanisDirectory()判断 File 对象代表的文件是否是一个目录
booleanisFile()判断 File 对象代表的文件是否是一个普通文件
booleancreateNewFile()根据 File 对象，自动创建一个空文件, 成功创建后返 回 true
booleandelete()根据 File 对象，删除该文件, 成功删除后返回 true
voiddeleteOnExit()根据 File 对象，标注文件将被删除，删除动作会到 JVM 运行结束时才会进行
String[]list()返回 File 对象代表的目录下的所有文件名
File[]listFiles()返回 File 对象代表的目录下的所有文件，以 File 对象 表示
booleanmkdir()创建 File 对象代表的目录
booleanmkdirs()创建 File 对象代表的目录，如果必要，会创建中间目录
booleanrenameTo(File dest)进行文件改名，也可以视为我们平时的剪切、粘贴操 作
booleancanRead()判断用户是否对文件有可读权限
booleancanWrite()判断用户是否对文件有可写权限

代码示例1 ~~ 文件路径

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: fly(逐梦者)
 * Date: 2023-10-13
 * Time: 20:21
 */
public class IODemo1 {
    public static void main(String[] args) throws IOException {
        File file = new File("d:/test.txt");// 不要求在 d:/ 这里真的有个 test.txt
        /*
        * 注: 这个 test.txt文件不存在的话,是不会自动在 D盘下创建一个 test.txt
        * 不过可以使用 createNewFile 手动创建.
        * */
//      File file=new File("./test.txt"); 第二类写法,使用相对路径,当前目录是项目所在路径
        System.out.println(file.getName());// 获取到文件名
        System.out.println(file.getParent());// 获取父级路径
        System.out.println(file.getPath());// 获取到完整路径
        System.out.println(file.getAbsolutePath());// 获取绝对路径
        System.out.println(file.getCanonicalFile());// 获取绝对路径的简化路径
    }
}

运行结果
第一类写法的运行结果
image-20231014232552018

第二类写法的运行结果
image-20231014233309663

代码示例2 ~~ 文件创建

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: fly(逐梦者)
 * Date: 2023-10-13
 * Time: 21:19
 */
public class IODemo2 {
    public static void main(String[] args) throws IOException {
//      File file = new File("d:/test.txt");
        File file = new File("./test.txt");
        file.createNewFile();// 创建文件
        System.out.println(file.exists());// 判断是否存在
        System.out.println(file.isFile());// 判断是否是文件
        System.out.println(file.isDirectory());// 判断是否是目录
    }
}

运行结果

image-20231015130010041

代码示例3 ~~ 文件删除

import java.io.File;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: fly(逐梦者)
 * Date: 2023-10-13
 * Time: 21:28
 */
public class IODemo3 {
    public static void main(String[] args) {
        File file = new File("./test.txt");
        file.delete();// 文件删除
    }
}

deleteOnExit 程序退出的时候,自动删除.程序中需要使用到一些"临时文件”的时候,需要用到.

image-20231015140013643

代码示例4 ~~ 创建目录

import java.io.File;

/**
 * Created with IntelliJ IDEA.
 * Description: 目录创建
 * User: fly(逐梦者)
 * Date: 2023-10-13
 * Time: 21:56
 */
public class IODemo4 {
    public static void main(String[] args) {
        File dir=new File("./test");
//      File dir=new File("./test/aaa/bbb");
        // mkdir 只能创建一直目录
        // mkdirs 才能创建多级目录
        // mk => make (制造,创建), dir => directory (目录)
        dir.mkdirs();
    }
}

运行结果

image-20231015144515405

代码示例5 ~~ 文件重命名

import java.io.File;

/**
 * Created with IntelliJ IDEA.
 * Description: 重命名
 * User: fly(逐梦者)
 * Date: 2023-10-13
 * Time: 22:36
 */
public class IODemo5 {
    public static void main(String[] args) {
        File file = new File("./test.txt");
        File dest = new File("./testAAA");
        file.renameTo(dest);
        file.delete();
    }
}

运行结果

image-20231015150424798

文件内容的操作

针对文件内容,使用**“流对象”**进行操作.

流对象 => 形象的比喻
计算机里的很多概念,都使用了一定的修辞手法.比喻是一种常见的方式.
使用一个链表头结点/二叉树根节点,表示整个链表/二叉树,这也是一个修辞手法借代也是一种常见的方式,用局部表示整体.
比如白居易的<<长恨歌>>:“六军不发无奈何,宛转蛾眉马前死.”
峨眉,古代女子纹的眉毛,用眉毛代替杨贵妃.

image-20231015162224067

Java标准库的流对象.从类型上,分成两个大类:

  1. 字节流: 以字节为单位,读写数据(操作二进制数据)
    InputStream => FileInputStream
    OutputStream => FileOutputStream

  2. 字符流: 以字符为单位,读写数据(操作文本数据)
    Reader => FileReader
    Writer => FileWriter

注: 这里虽然涉及的类很多,但是规律性很强.
InputStream,OutputStream,Reader,Writer 都是抽象类,不能直接实例化.

抽象类和接口,有什么区别

抽象类和接口的区别 ~~ [经典面试题]

(1)接口比抽象类更抽象,但是抽象类的功能是比接口更多的.
(2)抽象类和普通的类,差别就不大.只不过抽象类不能new实例,带有抽象方法.抽象类,可以有普通方法,也可以有普通的属性.
(3)接口里面都是抽象方法&不能有普通的成员.

注: 抽象类,大部分的东西都是确定.有几个属性,有几个方法,大部分都是明确的,只要一小部分是抽象方法
接口,大部分都是不确定.有什么属性,也不知道,方法也都是抽象方法(不考虑default的情况)
因此接口提供的信息量更少,视为接口比抽象类更抽象.

这些类的使用方式是非常固定的 ~~ 核心操作(四个)
(1)打开文件(构造对象)
(2)关闭文件(close)
(3)读文件(read) => 针对 InputSream/Reader
(4)写文件(write) => 针对``OutputStream/Writer`

字节流

InputStream 概述

方法

修饰符及返回值类型方法签名说明
intread()读取一个字节的数据，返回 -1 代表已经完全读完了
intread(byte[] b)最多读取 b.length 字节的数据到 b 中，返回实际读到的数 量；-1 代表以及读完了
intread(byte[] b, int off, int len)最多读取 len - off 字节的数据到 b 中，放在从 off 开始，返 回实际读到的数量；-1 代表以及读完了
voidclose()关闭字节流

read无参数版本: 一次读一个字节.
read一个参数版本: 把读到的内容填充到参数的这个字节数组中.(此处的参数是个“输出型参数")―返回值是实际读取的字节数.
read三个参数版本: 和2类似,只不过是往数组的一部分区间里尽可能填充.

read()返回值为什么是int?
read读取的是一个字节,按理说,返回一个byte就行了,但是实际上返回是int.
除了要表示 byte 里的0 ->255 (-128->127)这样的情况之外,还需要表示一个特殊情况,-1这个情况表示读取文件结束了(读到文件末尾了)

代码示例 ~~ 读取文件

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: fly(逐梦者)
 * Date: 2023-10-12
 * Time: 22:52
 */
public class IODemo6 {
    // 使用字节流来读取文件
    public static void main(String[] args) throws IOException {
        // 创建 InputStream 对象的时候,使用绝对路径或者相对路径,都是可以的,也可以使用 File 对象
        InputStream inputStream = new FileInputStream("d:/cat.jpg");

/*        // 进行读操作
        一次读取一个字节
        while (true){
           int b= inputStream.read();
            if (b==-1){
                // 读取完毕
                break;
            }
//          System.out.println(""+(byte)b);
            System.out.printf("%x\n",(byte)b);
        }*/

        // 一次读取若干个字节
        while (true) {
            byte[] buffer = new byte[1024];// read的第二个版本,需要调用者提前准备好一个数组.
            int len = inputStream.read(buffer);
            System.out.println("len: "+len);
            if (len == -1) {
                break;
            }
            // 此时读取的结果就被放到 byte 数组中.
/*            for (int i = 0; i < len; i++) {
                System.out.printf("%x\n",buffer[i]);
            }*/
        }
        inputStream.close();// 关闭文件
    }
}

image-20231015190816429

buffer(缓存区)

buffer存在的意义,就是为了提高IО操作的效率.
单次IO操作,是要访问硬盘/IO设备,单次操作是比较消耗时间的,如果频繁进行这样的IO操作,耗时肯定就更多了.
单次IO时间是一定的,如果能缩短IO的次数,此时就可以提高程序整体的效率了.
第一个版本的代码,是一次读一个字节.循环次数就比较高. read次数也很高.
第二个版本的代码,是一次读1024个字节,循环次数就降低了很多.read次数变少了.
缓冲区,“缓和了一下冲突”,减少冲击的次数.

FileInputStream 概述

构造方法

签名说明
FileInputStream(File file)利用 File 构造文件输入流
FileInputStream(String name)利用文件路径构造文件输入流

OutputStream 概述

方法

修饰符及返回值类型方法签名说明
voidwrite(int b)写入要给字节的数据
voidwrite(byte[] b)将 b 这个字符数组中的数据全部写入 os 中
intwrite(byte[] b, int off, int len)将 b 这个字符数组中从 off 开始的数据写入 os 中，一共写 len 个
voidclose()关闭字节流
voidflush()调用 flush（刷新）操作，将数据刷到设备中

注: OutputStream 同样只是一个抽象类，要使用还需要具体的实现类。我们现在还是只关心写入文件中，所以使用 FileOutputStream

代码示例 ~~ 写文件

使用了InputStream来读文件.还可以使用OutputStream来写文件.

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: fly(逐梦者)
 * Date: 2023-10-14
 * Time: 15:28
 */
public class IODemo7 {
    // 进行写文件
    public static void main(String[] args) throws IOException {

        OutputStream outputStream = new FileOutputStream("d:/test.txt");
        outputStream.write(97);
        outputStream.write(98);
        outputStream.write(99);
        outputStream.write(100);
        outputStream.close();
        
        /*  第二种写法
        try (OutputStream outputStream = new FileOutputStream("d:/test.txt")){
            outputStream.write(97);
            outputStream.write(98);
            outputStream.write(99);
            outputStream.write(100);
        }
        // 这个写法虽然没有显示的写close,实际上是会执行的.只要 try 语句块执行完毕,就可以执行到 close
        // 这个语法, 在 Java中被称为 try with resources
        // 注: 只有实现了 Closeable 接口的类才可以放到 try的() 中被自动关闭
        */
    }
}

image-20231015200758515

outputStream.close;=> 这里的close操作,含义是,关闭文件.

进程 -> 在内核里,使用PCB这样的数据结构来表示进程.
一个线程对应一个PCB
一个进程可以对应一个PCB也可以对应多个…
PCB中有一个重要的属性，文件描述符表.(相当于一个数组)记录了该进程打开了哪些文件
(即使一个进程里有多个线程多个PCB,也没关系,这些PCB共用同一个文件描述符表

image-20231015211107980

字符流

字符流用法和字节流基本差不多

示例代码 ~~ 字符读操作

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: fly(逐梦者)
 * Date: 2023-10-14
 * Time: 19:32
 */
public class IODemo8 {
    // 字符流的操作
    public static void main(String[] args) {
        try (Reader reader = new FileReader("d:/test.txt")) {
            while (true) {
                int ch = reader.read();
                if (ch == -1) {
                    break;
                }
                System.out.print("" + (char) ch);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

运行结果
image-20231016005143994

示例代码 ~~ 字符写操作

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: fly(逐梦者)
 * Date: 2023-10-14
 * Time: 19:40
 */
public class IODemo9 {
    public static void main(String[] args) {
        try (Writer writer= new FileWriter("d:/test.txt")){
            writer.write("fly in the sky! -- from: 0213");
            // 手动刷新缓冲区
            writer.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

运行结果

image-20231016010337612

writer.write("fly in the sky! -- from: 0213");
像这样的写操作,其实是先写到缓冲区里(缓冲区存在很多种形态.咱们自己的代码里可以有缓冲区;标准库里也可以有缓冲区∵操作系统内核里也可以有缓冲区…).
写操作执行完了,内容可能在缓冲区里,还没有真的进入硬盘.
close操作,就会触发缓冲区的刷新(刷新操作,就是把缓冲区里的内容写到硬盘里)
除了close之外,还可以通过 flush(推荐) 方法,也能起到刷新缓冲区的效果.

Scanner

Scanner 是搭配流对象进行使用的.

利用 Scanner 进行字符读取

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

Scanner scanner = new Scanner(System.in); => System.in 其实就是一个输入流对象

示例代码

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: fly(逐梦者)
 * Date: 2023-10-14
 * Time: 19:50
 */
public class IODemo10 {
    public static void main(String[] args) {
        //Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream=new FileInputStream("d:/test.txt")){
            Scanner scanner = new Scanner(inputStream);
            // 此时读取的内容就是从 文件 进行读取了.
            scanner.next();
        }catch (IOException e){
            e.printStackTrace();
        }
        // 此时,内部的 inputStream 对象已经被 try() 关闭了.里面的这个 Scanner 不关闭,也没事
    }
}

image-20231016015842345

小工具程序练习

练习一

扫描指定目录,并找到名称中包含指定字符的所有普通文件(不包含目录),并且后续询问用户是否要删除该文件.

练习一题目

给定一个目录,目录里会包含很多的文件和子目录…
用户输入一个要查询的词,看看当前目录下(以及子目录里)是否有匹配的结果.如果有匹配结果,就进行删除.

代码实现

import java.io.File;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * // 给定一个目录,目录里会包含很多的文件和子目录
 * // 用户输入一个要查询的词,看看当前目录下(以及子目录里)是否有匹配的结果
 * // 如果有匹配结果,就进行删除.
 * User: fly(逐梦者)
 * Date: 2023-10-14
 * Time: 20:34
 */
public class IODemo11 {

    private static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        // 让用户输入一个指定搜索
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要搜索的路径: ");
        String basePath = scanner.next();

        // 针对用户输入进行简单判定
        File root = new File(basePath);
        if (!root.isDirectory()) {
            // 路径不存在,或者只是一个普通文件,此时无法进行搜索
            System.out.println("输入的目录有误!");
            return;
        }
        // 再让用户输入一个要删除的文件名
        System.out.println("请输入要删除的文件名:");
        // 此处要使用 next, 而不是使用 nextLine!!!
        String nameToDelete = scanner.next();
        // 针对指定的路径进行扫描 => 递归操作
        // 先从根目录出发.(root)
        // 先判定一下,当前这个目录里,看看是否包含我们要删除的文件.如果是,就删除;否则,就调过下一个.
        // 如果当前这里包含了一些目录,再针对子目录进行递归.

        scanDir(root, nameToDelete);
    }

    private static void scanDir(File root, String nameToDelete) {
        System.out.println("[scanDir]"+root.getAbsolutePath());
        // 1.先列出当前路径下包含的内容
        File[] files = root.listFiles();
        if (files == null) {
            // 当前 root 目录下没东西,是一个空目录
            // 结束继续递归
            return;
        }
        // 2.遍历当前的列出结果
        for (File f : files) {
            if (f.isDirectory()) {
                // 如果是目录,就进一步递归
                scanDir(f, nameToDelete);

            } else {
                // 如果是普通文件,则判定是否要删除
                if (f.getName().contains(nameToDelete)) {
                    System.out.println("确认是否要删除 " + f.getAbsolutePath() + " 嘛?");
                    String choice = scanner.next();
                    if (choice.equals("y")||choice.equals("Y")){
                        f.delete();
                        System.out.println("删除成功!");
                    }else {
                        System.out.println("删除成功!");
                    }
                }
            }
        }
    }
}

image-20231016022446638

image-20231016022904719

运行结果

image-20231016144211844

练习二

进行普通文件的复制

练习二题目

把一个文件拷贝成另一个文件,就是把第一个文件按照字节依次读取,把结果写入到另一个文件中.

代码实现

import java.io.*;
import java.util.Date;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * 把一个文件拷贝成另一个文件
 * 就是把第一个文件按照字节依次读取,把结果写入到另一个文件中
 * User: fly(逐梦者)
 * Date: 2023-10-14
 * Time: 22:16
 */
public class IODemo12 {
    public static void main(String[] args) {
        // 输入两个路径
        // 源 和 目标 (从哪里,拷贝到哪里)
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入要拷贝那个文件: ");
        String srcPath =scanner.next();
        System.out.println("请输入要拷贝到那个地方: ");
        String destPath = scanner.next();
        File srcFile = new File(srcPath);
        if (!srcFile.isFile()){
            // 如果源不是一个文件(是个目录或者不存在)
            System.out.println("您当前输入的源路径有误!");
            return;
        }
        File destFile = new File(destPath);
        if (destFile.isFile()){
            // 如果已经存在,认为也不能拷贝
            System.out.println("您当前输入的目标路径有误!");
            return;
        }

        // 进行拷贝操作
        try (InputStream inputStream= new FileInputStream(srcFile);
             OutputStream outputStream=new FileOutputStream(destFile)){
            // try()语法,支持包含多个流对象,多个流对象之间使用 ; 分割开就行了

            // 进行读文件操作
            while (true){
                int b = inputStream.read();
                if (b==-1){
                    break;
                }
                outputStream.write(b);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

image-20231016150901611

注: (1)由于这里的文件都是一个一个字节来进行读取的,所以无论哪种类型的文件都可以拷贝的.
(2)这里的代码只能进行文件的拷贝,如果需要拷贝目录的话,就需要按照上一个例子一样,递归的拷贝.

运行结果

image-20231016150815969

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

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

相关文章

薪资27k，从华为外包测试“跳”入字节，说说我转行做测试的这5年.....

薪资27k，从华为外包测试“跳”入字节，说说我转行做测试的这5年.....

转行测试5年了 当时因为家里催促就业&#xff0c;在其中一个室友的内推下进入了一家英语教培机构&#xff0c;前期上班和工资都还算满意&#xff0c;甚至觉得自己找到了一份很稳定的工作了&#xff0c;可是好景不长&#xff0c;“双减政策”的到来&#xff0c;让公司的经济遭受…
阅读更多...
LeetCode1389——按既定顺序创建目标数组

LeetCode1389——按既定顺序创建目标数组

LeetCode1389 思路&#xff1a;先将元素存放在集合中&#xff0c;集合中的add&#xff08;index&#xff0c;value&#xff09;方法可以在指定的位置插入元素。 再创建新的数组&#xff0c;将集合中的元素存入数组&#xff0c;直接用数组的话元素移动不好操作。 public class D…
阅读更多...
嵌入式学习笔记（58）程序运行为什么需要内存？

嵌入式学习笔记（58）程序运行为什么需要内存？

1.1.1.计算机程序运行的目的 程序 代码 数据 代码就是函数&#xff0c;表示加工数据的动作。 数据包括全局变量和局部变量&#xff0c;表示被加工的东西。 程序运行的目的要么重在数据结果&#xff08;有返回值&#xff09;&#xff0c;要么重在过程&#xff08;无返回值…
阅读更多...
Java和前端都不好找工作，计算机毕业可以干嘛？

Java和前端都不好找工作，计算机毕业可以干嘛？

37了&#xff0c;11年多的Java经验&#xff0c;其他什么mysql&#xff0c;linux&#xff0c;Vue等等都会&#xff0c;现在失业在家已经1年多&#xff0c;不指望入职摸鱼了&#xff0c;寻思着转行中。祝你好运 这是某问答社区&#xff0c;有个大四学生提问&#xff0c;好迷茫啊马…
阅读更多...
华为云云耀云服务器L实例评测｜部署war格式的web项目

华为云云耀云服务器L实例评测｜部署war格式的web项目

目录 准备服务器安装java安装tomcat配置tomcat部署Web Adaptor总结 对于很多刚开始接触编程的朋友&#xff0c;通常都期待自己能部署一个网站&#xff0c;并可以在公网上访问。这就需要一台云服务器。最近发现华为云 推出了 云耀云服务器L实例&#xff0c;使用后&#xff0c;体…
阅读更多...
R语言进度条：txtProgressBar功能使用方法

R语言进度条：txtProgressBar功能使用方法

R语言进度条使用攻略 在数据处理、建模或其他计算密集型任务中&#xff0c;我们常常会执行一些可能需要很长时间的操作。 在这些情况下&#xff0c;展示一个进度条可以帮助我们了解当前任务的进度&#xff0c;以及大约还需要多长时间来完成&#xff0c;R语言提供了几种简单且灵…
阅读更多...
多模态论文串讲

多模态论文串讲

多模态论文串讲 近几年&#xff0c;尤其是 CLIP 出现以来&#xff0c;多模态学习的发展异常火爆。除了传统的VQA、图文检索、图像描述等&#xff0c;还有受启发于 CLIP 的新任务 Language Guided Detection/Segmentation、文本图像生成、文本视频生成等。本次串讲主要还是围绕…
阅读更多...
MATLAB——概率神经网络分类问题程序

MATLAB——概率神经网络分类问题程序

欢迎关注“电击小子程高兴的MATLAB小屋” %% 概率神经网络 %% 解决分类问题 clear all; close all; P[1:8]; Tc[2 3 1 2 3 2 1 1]; Tind2vec(Tc) %数据类型的转换 netnewpnn(P,T); Ysim(net,P); Ycvec2ind(Y) %转换回来
阅读更多...
机器人力控制构架

机器人力控制构架

在交互过程中&#xff0c;环境会对末端执行器可以遵循的几何路径设置约束。这种情况通常被称为约束运动。在这种情况下&#xff0c;使用纯运动控制策略来控制交互是失败的&#xff01;&#xff01; 只有任务准确规划&#xff0c;使用运动控制才能成功执行与环境的交互任务。但…
阅读更多...
10.17数电第二次实验

10.17数电第二次实验

就是数码管有4个&#xff0c;前两个来表示分钟&#xff0c;后两个表示秒钟 然后下面十六个led灯来记录时间&#xff0c;小时以十六进制&#xff0c;就是说4个二进制&#xff0c;4个灯为一组&#xff0c;一共可以显示四位小时 首先是要接收信号&#xff0c;应该是要无信号&…
阅读更多...
任务调度器

任务调度器

题目链接 任务调度器 题目描述 注意点 tasks[i] 是大写英文字母任务可以以任意顺序执行两个 相同种类 的任务之间必须有长度为整数 n 的冷却时间 解答思路 利用桶思想&#xff0c;将不同的字母放进同一个桶中&#xff0c;桶的数量为tasks中字母出现频率最高的次数&#xf…
阅读更多...
保序回归与金融时序数据

保序回归与金融时序数据

保序回归在回归问题中的作用是通过拟合一个单调递增或递减的函数&#xff0c;来保持数据点的相对顺序特性。 一、保序回归的作用 主要用于以下情况&#xff1a; 1. 有序数据&#xff1a;当输入数据具有特定的顺序关系时&#xff0c;保序回归可以帮助保持这种顺序关系。例如&…
阅读更多...
ai配音怎么弄？推荐一款免费好用的ai配音软件

ai配音怎么弄？推荐一款免费好用的ai配音软件

你们做短视频卡在了哪&#xff1f;剪辑&#xff1f;文案&#xff1f;还是配音&#xff1f;我身边很多朋友都卡在了配音&#xff0c;因为他们都觉得自己的声音不好听&#xff0c;普通话不标准&#xff0c;不够自信&#xff0c;那我们到底该如何解决短视频配音难题呢&#xff1f;…
阅读更多...
动态规划：11分割等和子集

动态规划：11分割等和子集

动态规划&#xff1a;11分割等和子集 416. 分割等和子集 这道题目初步看&#xff0c;和如下两题几乎是一样的&#xff0c;大家可以用回溯法&#xff0c;解决如下两题 698.划分为k个相等的子集473.火柴拼正方形 这道题目是要找是否可以将这个数组分割成两个子集&#xff0c;使…
阅读更多...
C++：继承的概念和用法

C++：继承的概念和用法

文章目录 继承的定义基类和派生类的对象赋值转换继承中的作用域派生类的默认成员函数几个继承小点继承理论的演示 菱形继承和菱形虚拟继承虚拟继承 本篇主要总结的内容有 什么是继承继承的一些概念菱形继承和虚拟继承继承的优缺点对比 继承的定义 继承是代码复用的一种重要手…
阅读更多...
Redis 主从复制，哨兵，集群——（1）主从复制篇

Redis 主从复制，哨兵，集群——（1）主从复制篇

目录 1. Redis 主从复制是什么&#xff1f; 2. Redis 主动复制能干嘛&#xff1f; 2.1 读写分离 2.2 容灾恢复 2.3 数据备份 2.4 水平扩展支撑高并发 3. Redis 主从复制配置项 3.1 配从库不配主库 3.2 权限密码配置 3.3 基本操作命令 4. 案例演示 4.1 案例说明 4.…
阅读更多...
leetCode 647.回文子串 动态规划 + 优化空间 / 中心扩展法 + 双指针

leetCode 647.回文子串 动态规划 + 优化空间 / 中心扩展法 + 双指针

647. 回文子串 - 力扣&#xff08;LeetCode&#xff09; 给你一个字符串 s &#xff0c;请你统计并返回这个字符串中 回文子串 的数目。回文字符串 是正着读和倒过来读一样的字符串。子字符串 是字符串中的由连续字符组成的一个序列。具有不同开始位置或结束位置的子串&#x…
阅读更多...
Springboot-MyBatisPlus-01

Springboot-MyBatisPlus-01

一 创建项目&#xff0c;选择spring boot 初始化&#xff0c;配置相关信息 第五步创建实体类 二 快速开发实体类的jar包--lombok <dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.12<…
阅读更多...
Pycharm中终端不显示虚拟环境名解决方法

Pycharm中终端不显示虚拟环境名解决方法

文章目录 一、问题说明&#xff1a;二、解决方法&#xff1a;三、重启Pycharm 一、问题说明&#xff1a; Pycharm中打开项目配置完需要的虚拟环境后&#xff0c;在Terminal&#xff08;终端&#xff09;中无法切换及显示当前需要运行代码的虚拟环境。 比如以下一种情况&#…
阅读更多...
TOUGH2软件教程、CO2地质封存

TOUGH2软件教程、CO2地质封存

TOUGH系列软件是由美国劳伦斯伯克利实验室开发的&#xff0c;旨在解决非饱和带中地下水、热运移的通用模拟软件。和传统地下水模拟软件Feflow和Modflow不同&#xff0c;TOUGH系列软件采用模块化设计和有限积分差网格剖分方法&#xff0c;通过配合不同状态方程&#xff08;EOS模…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023