1. 全栈程序员必看首页

新手小白学JAVA IO流 File 字节流 字符流

全栈程序员-用户IM • • 未分类

新手小白学JAVA IO流 File 字节流 字符流IO简介1流Stream在学习IO流之前,我们首先需要学习的概念就是Stream流为了方便理解,我们可以把数据的读写操作抽象成数据在”管道”中流动,但需注意:1.流只能单方向流动2.输入流用来读取→in3.输出流用来写出→out4.数据只能从头到尾顺序的读写一次所以以程序的角度来思考,In/out相对于程序而言的输入(读取)/输出(写出)的过程.2IO流的继承结构在java中,根据处理的数据单位不同,可以把流分为字节流和字符流字节流:针对二进制文件字符流:针对

大家好，又见面了，我是你们的朋友全栈君。

IO简介

1 流Stream

在学习IO流之前,我们首先需要学习的概念就是Stream流
为了方便理解,我们可以把数据的读写操作抽象成数据在”管道”中流动,但需注意:
1.流只能单方向流动
2.输入流用来读取 → in
3.输出流用来写出 → out
4.数据只能从头到尾顺序的读写一次
所以以程序的角度来思考,In/out 相对于程序而言的输入(读取)/输出(写出)的过程.
在这里插入图片描述

2 IO流的继承结构

在java中,根据处理的数据单位不同,可以把流分为字节流和字符流
字节流 : 针对二进制文件
字符流 : 针对文本文件
再结合对应类型的输入和输出方向,常用的流有:

File

字节流:针对二进制文件

InputStream

FileInputStream
BufferedInputStream
ObjectInputStream

OutputStream

FileOutputStream
BufferedOutputStream
ObjectOutputStream

字符流:针对文本文件

Reader

FileReader
BufferedReader
InputStreamReader

Writer

FileWriter
BufferedWriter
OutputStreamWriter
PrintWriter一行行写出

3 File文件类

3.1概述

封装一个磁盘路径字符串,对这个路径可以执行一次操作
可以封装文件路径、文件夹路径、不存在的路径

3.2创建对象

File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新的File实例
new File(“d:/abc/a.txt”);
new File(“d:/abc”,”a.txt”);

3.3常用方法

在这里插入图片描述

3.4 练习：测试常用方法

创建包: cn.tedu.file
创建类: TestFile.java

package cn.tedu.file;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
/*本类用于测试文件类File*/
public class TestFile { 

public static void main(String[] args) throws IOException { 

//1.创建File类对象
/*1.ready目录与1.txt需要自己手动创建 * 2.File需要导包：import java.io.File; * 3.路径是String类型，必须写正确，不然找不到文件 * 4.完整的文件名包含两部分：文件名+后缀名*/
File file = new File("E:\\ready\\1.txt");
//2.1测试File中的常用方法
System.out.println(file.length());//3，获取文件的字节量
System.out.println(file.exists());//true,判断文件是否存在
System.out.println(file.isFile());//true,判断是否为文件
System.out.println(file.isDirectory());//false，判断是否为文件夹
System.out.println(file.getName());//1.txt获取文件名
System.out.println(file.getParent());//E:\ready 获取父级路径
System.out.println(file.getAbsolutePath());//E:\ready\1.txt 获取带盘符的完整路径：绝对路径
//2.2 测试创建与删除
/*new 只会帮你在内存中创建一个File类型的对象 * 并不会帮你在磁盘中创建一个真实存在的2.txt文件*/
file = new File("E:\\ready\\2.txt");
//创建一个之前不存在的文件2.txt,如果创建成功，会返回true
/*如果指定创建文件的路径不对，会抛出异常：java.io.Exception * 所以需要提前处理这个问题，我们暂时选择在main()上抛出 * 这个IO异常是目前我们遇到的强制要求必须预先处理的异常 * 如果不处理，方法的调用会报错，通不过编译*/
System.out.println(file.createNewFile());//创建之前不存在的文件
file = new File("E:\\ready\\m");
System.out.println(file.mkdir());//创建之前不存在的单层文件夹
file = new File("E:\\ready\\a\\b\\c");
System.out.println(file.mkdirs());//创建之前不存在的多层文件夹
System.out.println(file.delete());//c被删除，删除空文件夹或者文件
file = new File("E:\\ready\\a");
System.out.println(file.delete());//false,a文件夹不是空的，里面有内容
file = new File("E:\\ready\\2.txt");
System.out.println(file.delete());//2.txt被删除，可以删除文件
//2.3测试展示文件列表
file = new File("E:\\ready");
String[] list = file.list();/*不常用*/
System.out.println(Arrays.toString(list));
//这句话会报错，因为这是一个String[],所以数组中每个元素都是String类型的
//那么只能用String类中的方法，而isDirectory()是File类中的方法
//System.out.println(list[0].isDirectory());
File[] fs = file.listFiles();/*常用*/
System.out.println(Arrays.toString(fs));
System.out.println(fs[0].isDirectory());
}
}

4 字节流读取

字节流是由字节组成的,字符流是由字符组成的.
Java里字符由两个字节组成.字节流是基本流，主要用在处理二进制数据。
所以字节流是比较常用的，可以可以处理多种不同种类的文件，比如文本文档/音频/视频等等

4.1 InputStream抽象类

此抽象类是表示字节输入流的所有类的超类/抽象类,不可创建对象哦

常用方法：
abstract int read() 从输入流中读取数据的下一个字节
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
int read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组,off表示存时的偏移量
void close() 关闭此输入流并释放与该流关联的所有系统资源

4.2 FileInputStream子类

直接插在文件上，直接读取文件数据

创建对象
FileInputStream(File file)—直接传文件对象
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定FileInputStream(String pathname)—传路径
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定

4.3 BufferedInputStream子类

BufferedInputStream 为另一个输入流添加一些功能，在创建BufferedInputStream 时，会创建一个内部缓冲区数组(默认8k大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。

创建对象
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

4.4 练习：字节流读取案例

创建包: cn.tedu.file
创建类: TestIn.java

package cn.tedu.file;
import java.io.*;
/*本类用于练习字节输入流*/
public class TestIn { 

public static void main(String[] args) { 

//method();//字节流的读取
method2();//高效字节流的读取
}
//本方法用于测试高效字节流的读取
private static void method2() { 

//定义一个在本方法中都生效的局部变量in,注意手动初始化，值为null
InputStream in = null;
try { 

//1.创建高效字节输入流对象
// InputStream in = new BufferedInputStream(
// new FileInputStream(new File("E:\\ready\\1.txt")));
in = new BufferedInputStream
(new FileInputStream("E:\\ready\\1.txt"));
//2.使用流进行读取
int b;
while ((b= in.read())!= -1){ 

System.out.println(b);
}
} catch (Exception e) { 

e.printStackTrace();
}finally { 
//关流操作写在finally{}中
//3.流用完以后一定要关闭！！！
try { 

in.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
}
//本方法用于测试字节流的读取
private static void method() { 

//创建一个在本方法都生效的局部变量注意手动初始化
InputStream in = null;
try { 

//1.创建字节输入流对象用于读取
//InputStream in = new InputStream();//报错原因：抽象类不可实例化
//InputStream in = new FileInputStream(new File("E:\\ready\\1.txt"));
in = new FileInputStream("E:\\ready\\1.txt");
//2.开始读取
/*read()每次调用都会读取一个字节，如果读到了数据的末尾，返回-1*/
// System.out.println(in.read());
// System.out.println(in.read());
// System.out.println(in.read());
// System.out.println(in.read());
//需求：需要循环读取文件中的所有内容，直至读完
//定义变量，记录读到的数据
int b;
while((b=in.read())!= -1){ 

System.out.println(b);
}
} catch (Exception e) { 

e.printStackTrace();//打印错误信息
/*try-catch结构中的第三个部分：finally{} * 这部分不论是否捕获到异常，是一定会被执行到的代码，常用于关流*/
}finally { 

try { 

//3.释放资源，流资源用完必须释放！！！
in.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
}
}

5 字符流读取

常用于处理纯文本数据,读写容易出现乱码的现象,在读写时,最好指定编码集为UTF-8

5.1 Reader抽象类

用于读取字符流的抽象类。

常用方法：
int read() 读取单个字符
int read(char[] cbuf) 将字符读入数组
abstract int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分
int read(CharBuffer target) 试图将字符读入指定的字符缓冲区
abstract void close() 关闭该流并释放与之关联的所有资源

5.2 FileReader子类

用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

创建对象
FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader
FileReader(File file) 在给定从中读取数据的 File 的情况下创建一个新 FileReader

5.3 BufferedReader子类

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

创建对象
BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流

5.4 练习：字符流读取案例

创建包: cn.tedu.file
创建类: TestIn2.java

package cn.tedu.file;
import java.io.*;
/*本类用于测试字符流的读取*/
public class TestIn2 { 

public static void main(String[] args) { 

//method();//测试普通字符输入流
method2();//测试高效字符输入流
}
//创建一个用于测试高效字符输入流的方法
private static void method2() { 

//1.定义一个在本方法都生效的局部变量，手动初始化值null
Reader in=null;
try{ 

//1.创建高效字符读取流对象
//in = new BufferedReader(new FileReader(new File("E:\\ready\\1.txt")));
in = new BufferedReader(new FileReader("E:\\ready\\1.txt"));
//2.使用流对象
int b;
while((b=in.read())!=-1){ 

System.out.println(b);
}
}catch (Exception e){ 

e.printStackTrace();
}finally { 

//3.关闭流对象
try { 

in.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
}
//创建一个用于测试普通字符输入流的方法
private static void method() { 

//1.1创建一个在本方法中都生效的局部变量，注意初始化值null
Reader in = null;
try { 

//1.2创建字符输入流对象，注意需要捕获异常
//Reader in = new Reader();//报错原因：抽象父级不可实例化
//in = new FileReader(new File("E:\\ready\\1.txt"));
in = new FileReader("E:\\ready\\1.txt");
//2.使用流对象
//System.out.println(in.read());
//需求：循环读取文件中的所有内容，只要不是-1，就说明还有数据，继续读取
//3.1定义变量，记录读取到的数据
int b;
while((b = in.read())!= -1){ 

System.out.println(b);
}
} catch (Exception e) { 

e.printStackTrace();
} finally { 
//3.关流
try { 

in.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
}
}

6 字节流写出

6.1 OutputStream抽象类

此抽象类是表示输出字节流的所有类的超类.输出流接受输出字节并将这些字节发送到某个接收器.

常用方法:
Void close() 关闭此输出流并释放与此流相关的所有系统资源
Void flush() 刷新此输出流并强制写出所有缓冲的输出字节
Void write(byte[ ] b) 将b.length个字节从指定的byte数组写入此输出流
Void write(byte[ ] b,int off ,int len) 将指定byte数组中从偏移量off开始的len个字节写入输出流
Abstract void write(int b) 将指定的字节写入此输出流

6.2 FileOutputStream 子类

直接插在文件上,直接写出文件数据

构造方法(创建对象):
FileOutputStream(String name)
创建一个向具有指定名称的文件中写入数据的文件输出流
FileOutStream(File file)
创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutStream(File file,boolean append)—如果第二个参数为true,表示追加,不覆盖
创建一个向指定File对象表示的文件中写入数据的文件输出流,后面的参数是指是否覆盖原文件内容

6.3 BufferedOutputstream 子类

该类实现缓冲的输出流,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必每次针对字节写出调用底层系统

构造方法(创建对象):
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流,用以将数据写入指定的底层输出流

6.4 练习: 字节输出流测试:

创建包: cn.tedu.file
创建类: TestOut.java

package cn.tedu.file;
import java.io.*;
/*本类用于测试字节输出流*/
public class TestOut { 

public static void main(String[] args) { 

method();//用于测试普通字节输出流
//method2();//用于测试高效字节输出流
}
//创建一个用于测试高效字节输出流的方法
private static void method2() { 

//1.创建一个在本方法都生效的局部变量，注意手动初始化
OutputStream out = null;
try{ 

//2.创建高效字节输出流对象
// out = new BufferedOutputStream(new FileOutputStream(new File("E:\\ready\\2.txt")));
out = new BufferedOutputStream(new FileOutputStream("E:\\ready\\2.txt"));
//3.使用流对象--进行写出操作
out.write(97);
out.write(97);
out.write(97);
}catch (Exception e){ 

e.printStackTrace();
}finally { 
//关流操作要放在finally{}中
try { 

//4.关流
out.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
}
//创建一个用于测试普通字节输出流的方法
private static void method() { 

//1.创建一个在本方法中都生效的局部变量，注意手动初始化null
OutputStream out = null;
//2.创建try-catch-finally结构，因为IO操作可能会产生异常
try{ 

//3.创建普通字节输出流对象
//out = new FileOutputStream(new File("E:\\ready\\2.txt"));
//out = new FileOutputStream("E:\\ready\\2.txt");
out = new FileOutputStream("E:\\ready\\2.txt",true);
//4.使用流对象--进行写出操作
out.write(99);//对应ASCII码表中的a
out.write(99);//对应ASCII码表中的b
out.write(99);//对应ASCII码表中的c
}catch (Exception e){ 

e.printStackTrace();
}finally { 
//如果想要代码一定会执行，需要写在finally中
try { 

//5.关流操作
out.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
}
}

7 字符流写出

7.1 Writer 抽象类

写入字符流的抽象类

常用方法:
Abstract void close() 关闭此流,但要先刷新它
Void write(char[ ] cbuf) 写入字符数组
Void write(int c) 写入单个字符
Void write(String str) 写入字符串
Void write(String str,int off,int len) 写入字符串的某一部分
Abstract void write(char[] cbuf,int off,int len)写入字符数组的某一部分

7.2 FileWriter 子类

用来写入字符文件的便捷类,此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的.如果需要自己自定义这些值,可以先在FileOutputStream上构造一个OutputStreamWriter.

构造方法(创建对象):
FileWriter(String filename)
根据给定的文件名构造一个FileWriter对象
FileWriter(String filename,boolean append)
根据给定的文件名以及指示是否附加写入数据的boolean值来构造FileWriter

7.3 BufferedWriter子类

将文本写入字符输出流,缓冲各个字符,从而提供单个字符,数组和字符串的高效写入.可以指定缓冲区的大小,或者接受默认的大小,在大多数情况下,默认值就足够大了

构造方法(创建对象):
BufferedWriter(Writer out)
创建一个使用默认大小输出缓冲区的缓冲字符输出流

7.4 练习: 字符输出流测试:

创建包: cn.tedu.file
创建类: TestOut2.java

package cn.tedu.file;
import java.io.*;
/*本类用于测试字符输出流*/
public class TestOut2 { 

public static void main(String[] args) { 

//method();//用于测试普通字符输出流
method2();//用于测试高效字符输出流
}
//创建一个用于测试高效字符输出流的方法
private static void method2() { 

//1.创建一个在本方法都生效的局部变量，值为null,注意手动初始化！！！
Writer out = null;
//2.由于程序可能会抛出异常，所以需要写一个try-catch-finally结构
try{ 
//存放可能会抛出异常的代码
//3.创建普通字符输出流对象
//out = new BufferedWriter(new FileWriter(new File("E:\\ready\\2.txt")));
//out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt"));
out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt",true));
//4.使用流对象
out.write(100);
out.write(100);
out.write(100);
out.write(100);
out.write(100);
}catch (Exception e){ 
//匹配并捕获异常
e.printStackTrace();//如果捕获到异常就打印错误信息
}finally { 
//一定会被执行到的代码块，常用于关流
try { 

out.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
}
//创建一个用于测试普通字符输出流的方法
private static void method() { 

//1.创建一个在本方法都生效的局部变量，值为null,注意手动初始化！！！
Writer out = null;
//2.由于程序可能会抛出异常，所以需要写一个try-catch-finally结构
try{ 
//存放可能会抛出异常的代码
//3.创建普通字符输出流对象
//out = new FileWriter(new File("E:\\ready\\2.txt"));
//out = new FileWriter("E:\\ready\\2.txt");
out = new FileWriter("E:\\ready\\2.txt",true);
//4.使用流对象
out.write(98);
out.write(98);
out.write(98);
out.write(98);
}catch (Exception e){ 
//匹配并捕获异常
e.printStackTrace();//如果捕获到异常就打印错误信息
}finally { 
//一定会被执行到的代码块，常用于关流
try { 

out.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
}
}

8 拓展

通过学习以上的几种流,我们也可以拓展尝试做下文件的复制:
创建包: cn.tedu.file
创建类: TestCopyFile.java

package cn.tedu.file;
import java.io.*;
import java.util.Scanner;
/*本类用于练习文件复制综合案例*/
public class TestCopyFile { 

public static void main(String[] args) { 

//1.提示并接收用户输入的两个路径
System.out.println("请输入源文件路径");//--被复制的那个文件
String f = new Scanner(System.in).nextLine();
System.out.println("请输入新文件路径：");//--复制好的新文件
String t = new Scanner(System.in).nextLine();
//2.调用创建好的自定义方法完成文件复制
//ZFCopy(f,t);//用字符流完成文件的复制案例
ZJCopy(f,t);//用字节流完成文件的复制案例
}
//利用字节流完成文件复制案例
private static void ZJCopy(String f, String t) { 

//1.定义在整个方法都生效的局部变量，注意手动初始化，引用类型默认值为null
InputStream in = null;
OutputStream out = null;
//2.由于代码可能会发生异常，所以需要编写try-catch-finally结构
try{ 

//3.1创建高效字节输入流对象--FIS的参数是用户传入的源文件路径f
in = new BufferedInputStream(new FileInputStream(f));
//3.2创建高效字节输出流对象--FOS的参数是用户传入的新文件路径t
out = new BufferedOutputStream(new FileOutputStream(t));
//4.利用创建好的流对象完成业务
//4.1定义变量用来保存读到的数据
int b;
//4.2循环读取源文件中的数据，只要不是-1，说明还有数据循环继续
while((b = in.read()) != -1){ 

//4.3将读到的数据写入到新文件中
out.write(b);
}
System.out.println("恭喜您！文件复制成功！");
}catch (Exception e){ 

System.out.println("很抱歉！文件复制失败！");
e.printStackTrace();
}finally { 

try { 

out.close();
} catch (IOException e) { 

e.printStackTrace();
}
try { 

in.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
}
//利用字符流完成文件复制案例
private static void ZFCopy(String f, String t) { 

//1.定义在整个方法中都生效的局部变量，注意手动初始化，默认值为null
Reader in = null;
Writer out = null;
//2.由于代码可能会发生异常，所以需要编写try-catch-finally结构
try{ 

//3.1创建高效字符输入流对象
in = new BufferedReader(new FileReader(f));
//3.2创建高效字符输出流对象
out = new BufferedWriter(new FileWriter(t));
//4.拿到流对象以后，就可以使用流对象来完成业务了
//4.1定义变量用来保存读到的数据
int b;
//4.2循环读取源文件，直到返回值为-1，说明没有数据了，再结束循环
while ((b=in.read())!=-1) { 

//4.3将本轮循环中读到的数据写入到新文件中
out.write(b);
}
System.out.println("恭喜您！文件复制成功！");
}catch (Exception e){ 

System.out.println("很抱歉！文件复制失败！");
e.printStackTrace();
}finally { 

/*关流是有顺序的：如果有多个流，最后创建的流最先关闭 * 多条关流语句需要各自try-catch*/
try { 

out.close();
} catch (IOException e) { 

e.printStackTrace();
}
try { 

in.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
}
}

9 总结:IO的继承结构

1.主流分类

  1. 按照方向进行分类:输入流 输出流(相对于程序而言,从程序写数据到文件中是输出)
  2. 按照传输类型进行分类:字节流 字符流
  3. 组合: 字节输入流 字节输出流 字符输入流 字符输出流

2.学习方法:在抽象父类中学习通用的方法,在子类中学习如何创建对象
3.字节输入流:

InputStream 抽象类,不能new,可以作为超类,学习其所提供的共性方法
--FileInputStream 子类,操作文件的字节输入流,普通类
--BufferedInputStream 子类,缓冲字节输入流,普通类

4.字符输入流

Reader 抽象类,不能new,可以作为超类,学习其所提供的共性方法
--FileReader,子类,操作文件的字符输入流,普通类
--BufferedReader,子类,缓冲字符输入流,普通类

5.字节输出流:

OutputStream 抽象类,不能new,可以作为超类,学习其所提供的共性方法
--FileOutputStream 子类,操作文件的字节输出流,普通类
--BufferedOutputStream 子类,缓冲字节输出流,普通类

6.字符输出流

Writer 抽象类,不能new,可以作为超类,学习其所提供的共性方法
--FileWriter,子类,操作文件的字符输出流,普通类
--BufferedWriter,子类,缓冲字符输出流,普通类
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/130876.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0
blank

相关推荐

  • DDoS攻击工具HOIC分析

    DDoS攻击工具HOIC分析

    DDoS攻击工具HOIC分析本文是绿盟科技安全+技术刊物中的文章，文章对拒绝服务攻击工具—”HighOrbitIonCannon”的技术性分析。HOIC是一款用RealBasic开发可移植的多平台拒绝服务攻击工具，该工具虽然对使用者的水平…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年7月11日
  • 跳频介绍_跳频功能

    跳频介绍_跳频功能

    跳频介绍_跳频功能跳频是最常用的扩频方式之一，其工作原理是指收发双方传输信号的载波频率按照预定规律进行离散变化的通信方式，也就是说，通信中使用的载波频率受伪随机变化码的控制而随机跳变。从通信技术的实现方式来说，“跳频”是一种用码序列进行多频频移键控的通信方式，也是一种码控载频跳变的通信系统。从时域上来看，跳频信号是一个多频率的频移键控信号；从频域上来看，跳频信号的频谱是一个在很宽频带上以不等间隔随机跳变的。其中：跳

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月23日
  • 万字文肝Python基础知识

    万字文肝Python基础知识

    万字文肝Python基础知识Python基础知识，进阶操作

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年6月24日
  • swagger @ApiModel @ApiModelProperty注解属性说明「建议收藏」

    swagger @ApiModel @ApiModelProperty注解属性说明「建议收藏」

    @ApiModel使用场景：在实体类上边使用，标记类时swagger的解析类。概述：提供有关swagger模型的其它信息，类将在操作中用作类型时自动内省。用法：@ApiModel(value=“ShopVo”,description=“商铺信息”)@ApiModelProperty使用场景：使用在被@ApiModel注解的模型类的属性上。表示对model属性的说明或者数据操作更改。概述：添加和操作模型属性的数据。用法：@ApiModelProperty(value=“

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年4月14日
  • PLSQL 使用教程

    PLSQL 使用教程

    PLSQL 使用教程1打开表打开PLSQL点击Objects在下拉列表中选中Myobjects找到Table下级目录中都是数据库的表2查看表的数据选中表,右击点击-查看数据/querydata弹出sql窗口,可以查看数据3查看表结构选中表,右击点击-查看/View…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年5月2日
  • 基于VUE选择上传图片并在页面显示（图片可删除）

    基于VUE选择上传图片并在页面显示（图片可删除）

    基于VUE选择上传图片并在页面显示（图片可删除）

    全栈程序员-用户IM 全栈程序员-用户IM
    2021年10月11日

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号