Baozi series -- Java basics Chapter 13_ IO stream

baozi series java basics chapter


Chapter 13 IO flow

image-20201109214309972.png

File The use of the class

File Class

File An object of class , Represents a file or a file directory ( Be commonly called : Folder )

File Class declaration in java.io It's a bag

File Class involves the creation of files or file directories 、 Delete 、 rename 、 Modification time 、 File size, etc , It does not involve writing or reading the contents of the file . If you need to read or write the contents of the file , You have to use IO Flow to complete .

follow-up File The object of the class is often passed as an argument to the constructor of the stream , To indicate read or write to " End ".

File Instantiation

File(String filePath)
File(String parentPath,String childPath)
File(File parentFile,String childPath)

The classification of paths

Relative paths : Compared with a certain path , The path indicated .
Absolute path : The path to the file or file directory that contains the drive letter

explain :
IDEA in :
If you develop and use JUnit Unit test method test in , The relative path is the current Module Next .
If you use main() test , The relative path is the current Project Next .
Eclipse in :
Whether using unit testing methods or using main() test , Relative paths are all current Project Next .

Path separator

windows and DOS System default use “\” To express
// D:\ Chen 2\ Baozixue series \Java01_ Baozi studies Java Basics
UNIX and URL Use “/” To express
// home/cyb

File Common methods of class

File Class

public String getAbsolutePath(): Get absolute path
public String getPath() : Get path
public String getName() : Get the name
public String getParent(): Get the upper file directory path . If there is no , return null
public long length() : Get file length ( namely : Number of bytes ). Cannot get the length of the directory .
public long lastModified() : Get the last modification time , Millisecond value
public String[] list() : Get the name array of all files or file directories in the specified directory
public File[] listFiles() : Get all the files in the specified directory or file directory File Array

File Class renaming function

public boolean renameTo(File dest): Rename the file to the specified file path

File Class

public boolean isDirectory(): Determine whether it is a file directory
public boolean isFile() : Determine if it's a document
public boolean exists() : Judge whether it exists
public boolean canRead() : Judge whether it is readable
public boolean canWrite() : Judge whether it is writable
public boolean isHidden() : Determine whether to hide

File Class creation

public boolean createNewFile() : create a file . If the file exists , Do not create , return false
public boolean mkdir() : Create file directory . If this file directory exists , We won't create . If the upper directory of this file directory does not exist , It doesn't create .
public boolean mkdirs() : Create file directory . If the upper file directory does not exist , Create... Together

matters needing attention : If you create a file or the file directory does not have a drive letter path , that , Default in project Under the path .

File Class delete function

public boolean delete(): Delete files or folders

Delete notes :

Java Delete in does not go to the recycle bin . To delete a file directory , Please note that the file directory cannot contain files or file directories

practice

File dir1 = new File("D:/IOTest/dir1");
if (!dir1.exists()) { // If D:/IOTest/dir1 non-existent , Just create it as a directory
dir1.mkdir();
}
// Create to dir1 Is the parent directory , be known as "dir2" Of File object
File dir2 = new File(dir1, "dir2");
if (!dir2.exists()) { // If it doesn't exist yet , Just create it as a directory
dir2.mkdirs();
}
File dir4 = new File(dir1, "dir3/dir4");
if (!dir4.exists()) {
dir4.mkdirs();
}
// Create to dir2 Is the parent directory , be known as "test.txt" Of File object
File file = new File(dir2, "test.txt");
if (!file.exists()) { // If it doesn't exist yet , Just create it as a file
file.createNewFile();
}
//2. Determine whether there is a suffix named .jpg The file of , If there is , Just output the file name
@Test
public void test1(){
File srcFile = new File("d:\\code");
String[] fileNames = srcFile.list();
for(String fileName : fileNames){
if(fileName.endsWith(".jpg")){
System.out.println(fileName);
}
}
}
public void test2(){
File srcFile = new File("d:\\code");
File[] listFiles = srcFile.listFiles();
for(File file : listFiles){
if(file.getName().endsWith(".jpg")){
System.out.println(file.getAbsolutePath());
}
}
}
//3. Traverse the specified directory all file names , Include files in the subdirectory .
// expand 1: And calculate the space occupied by the specified directory
// expand 2: Delete the specified file directory and all the files under it
public static void printSubFile(File dir) {
// Print sub files of directory
File[] subfiles = dir.listFiles();
for (File f : subfiles) {
if (f.isDirectory()) {// File directory
printSubFile(f);
} else {// file
System.out.println(f.getAbsolutePath());
}
}
}
// List file Subordinate to the directory , If it's subordinate to the directory , Then list the subordinates of your subordinates , By analogy
// It is recommended to use File Class File[] listFiles()
public void listAllSubFiles(File file) {
if (file.isFile()) {
System.out.println(file);
} else {
File[] all = file.listFiles();
// If all[i] It's a document , Print directly
// If all[i] Is a directory , And then get the next level of it
for (File f : all) {
listAllSubFiles(f);// Recursively call : Call yourself recursion
}
}
}
// expand 1: Find the space size of the specified directory
// Find the total size of a directory
public long getDirectorySize(File file) {
// file It's a document , Then go straight back file.length()
// file Is a directory , Add up all the sizes of its next level to get its total size
long size = 0;
if (file.isFile()) {
size += file.length();
} else {
File[] all = file.listFiles();// obtain file Next level
// Add up all[i] Size
for (File f : all) {
size += getDirectorySize(f);// f Size ;
}
}
return size;
}
// expand 2: Delete the specified directory
public void deleteDirectory(File file) {
// If file It's a document , direct delete
// If file Is a directory , Take out the next level first , Then delete yourself
if (file.isDirectory()) {
File[] all = file.listFiles();
// The circular deletion is file Next level
for (File f : all) {// f representative file Every subordinate of
deleteDirectory(f);
}
}
// Delete yourself
file.delete();
}

IO Flow overview

Input input: Read external data ( disk 、 Data from storage devices such as optical disks ) To Program ( Memory ) in .

Output output: Put the program ( Memory ) Data output to disk 、 CD and other storage devices Prepare for .

The dividing line is memory : In memory processing is Input stream 、 Out of memory is the output stream

The most basic flow

( Abstract base class ) Byte stream Character stream
Input stream InputStream Reader
Output stream OutputStream Writer

Classification of flows

  1. Operating data units : Byte stream 、 Character stream
  2. The flow of data : Input stream 、 Output stream
  3. The role of flow : Node flow 、 Processing flow

Flow architecture

image-20201109195941284.png

explain : The red box corresponds to IO Streaming 4 Abstract base classes .

The flow in the blue box needs our attention .

  • The basic four abstract base classes
  • Four of the documents
  • Four buffers
  • Two streams of transformation
    • BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
    • BufferedWriter bw = new BufferedWriter(new OutStreamWriter(System.out));

Several stream structures are highlighted

image-20201109200858754.png

Input 、 The standardization process of output

Input process

① establish File Class object , Indicates the source of the data read .( This file must exist )
② Create the corresponding input stream , take File Class as parameters , In the constructor of the incoming stream
③ The specific reading process :
Create the corresponding byte[] or char[].
④ Close stream resource
explain : The exception in the program needs to use try-catch-finally Handle .

InputStream & Reader

InputStream and Reader Is the base class for all input streams
InputStream
int read()
int read(byte[] b)
int read(byte[] b, int off, int len)
Reader
int read()
int read(char [] c)
int read(char [] c, int off, int len)
// Files opened in the program IO Resources do not belong to resources in memory , The garbage collection mechanism can't recover the money
Source , So you should explicitly close the file IO resources
// FileInputStream Get input bytes from a file in the file system .FileInputStream
Used to read raw byte streams such as non text data . To read a character stream , Need to use FileReader

image-20201109201451284.png

image-20201109201517676.png

Output process

① establish File Class object , Indicate the location of the written data .( Don't ask this file to exist )
② Create the corresponding output stream , take File Class as parameters , In the constructor of the incoming stream
③ The specific writing process :
write(char[]/byte[] buffer,0,len)
④ Close stream resource

explain : The exception in the program needs to use try-catch-finally Handle .

OutputStream & Writer

void write(int b/int c);
void write(byte[] b/char[] cbuf);
void write(byte[] b/char[] buff, int off, int len);
void flush();
void close(); You need to refresh , Close the stream again
// Because character streams operate directly on characters , therefore Writer You can replace character arrays with strings ,
That is to String Object as parameter
void write(String str);
void write(String str, int off, int len);
// FileOutputStream Get the output bytes from a file in the file system .FileOutputStream
Used to write raw byte streams such as non text data . To write a character stream , Need to use FileWriter

image-20201109201722500.png

Node flow ( Stream or file )

FileReader Use

1. Create a stream object , Load an existing file into the stream .
FileReader fr = new FileReader(new File(“Test.txt”));
2. Create an array of temporary data storage .
char[] ch = new char[1024];
3. Call the read method of the stream object to read the data in the stream into the array .
fr.read(ch);
4. close resource .
fr.close();
@Test
public void testFileReader1() {
FileReader fr = null;
try {
//1.File Class instantiation
File file = new File("hello.txt");
//2.FileReader Instantiation of a stream
fr = new FileReader(file);
//3. Read in operation
//read(char[] cbuf): Return every read in cbuf The number of characters in the array . If the end of the file is reached , return -1
char[] cbuf = new char[5];
int len;
while((len = fr.read(cbuf)) != -1){
// Mode one :
// The wrong way to write
// for(int i = 0;i < cbuf.length;i++){
// System.out.print(cbuf[i]);
// }
// Correct writing
// for(int i = 0;i < len;i++){
// System.out.print(cbuf[i]);
// }
// Mode two :
// The wrong way to write , It's the wrong way to write it
// String str = new String(cbuf);
// System.out.print(str);
// Correct writing
String str = new String(cbuf,0,len);
System.out.print(str);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fr != null){
//4. Closure of resources
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

explain :

  1. read() The understanding of the : Returns a character read in . If the end of the file is reached , return -1
  2. Exception handling : In order to ensure that the stream resource can be closed . Need to use try-catch-finally Handle
  3. The file read in must exist , Otherwise it will be reported FileNotFoundException

FileWriter Use

1. Create a flow object , Create data storage files
FileWriter fw = new FileWriter(new File(“Test.txt”));
2. Call the write method of the stream object , Write data to the stream
fw.write(“atguigu-songhongkang”);
3. Close stream resource , And empty the data in the stream to the file .
fw.close();
@Test
public void testFileWriter() {
FileWriter fw = null;
try {
//1. Provide File Class object , Indicate the document written to
File file = new File("hello1.txt");
//2. Provide FileWriter The object of , For writing data
fw = new FileWriter(file,false);
//3. Written operations
fw.write("I have a dream!\n");
fw.write("you need to have a dream!");
} catch (IOException e) {
e.printStackTrace();
} finally {
//4. The closure of streaming resources
if(fw != null){
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

explain :

  1. Output operation , Corresponding File Can not exist . No exception will be reported
  2. File If the file in the corresponding hard disk does not exist , In the process of output , This file will be created automatically .
  3. File If the file in the corresponding hard disk exists :
    1. If the constructor used by the stream is :FileWriter(file,false) / FileWriter(file): An overlay of the original file
    2. If the constructor used by the stream is :FileWriter(file,true): The original file will not be overwritten , It's an addition to the original document

Copy of text files

@Test
public void testFileReaderFileWriter() {
FileReader fr = null; // Using a character stream
FileWriter fw = null;
try {
//1. establish File Class object , Indicate the documents read in and written out
File srcFile = new File("hello.txt");
File destFile = new File("hello2.txt");
// Can't use character stream to process byte data such as pictures
// File srcFile = new File(" Love and friendship .jpg");
// File destFile = new File(" Love and friendship 1.jpg");
//2. Create objects for input and output streams
fr = new FileReader(srcFile);
fw = new FileWriter(destFile);
//3. Data reading and writing operations
char[] cbuf = new char[5];
int len;// Record every time you read in cbuf The number of characters in the array
while((len = fr.read(cbuf)) != -1){
// Every time you write len Characters
fw.write(cbuf,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4. Close stream resource
// Mode one :
// try {
// if(fw != null)
// fw.close();
// } catch (IOException e) {
// e.printStackTrace();
// }finally{
// try {
// if(fr != null)
// fr.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
// Mode two :
try {
if(fw != null)
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(fr != null)
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

FileInputStream / FileOutputStream Use

For text files (.txt,.java,.c,.cpp), Using character stream processing

For non text files (.jpg,.mp3,.mp4,.avi,.doc,.ppt,...), Using byte stream processing

// Picture reproduction
@Test
public void testFileInputOutputStream() {
FileInputStream fis = null; // Byte stream
FileOutputStream fos = null;
try {
//1. Making documents
File srcFile = new File(" Love and friendship .jpg");
File destFile = new File(" Love and friendship 2.jpg");
//2. Flow making
fis = new FileInputStream(srcFile);
fos = new FileOutputStream(destFile);
//3. The process of copying
byte[] buffer = new byte[5];
int len;
while((len = fis.read(buffer)) != -1){
fos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fos != null){
//4. Closed flow
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

The relative path is IDEA and Eclipse The difference used in ?

IDEA:

  1. If you use the unit testing method , The relative path is based on the current Module Of .
  2. If you use main() test , The relative path is based on the current Project Of .

Eclipse:

  1. Unit testing method or main(), Relative paths are based on the current situation Project Of .

Buffer flow

The class involved in the buffer flow

  • BufferedInputStream
  • BufferedOutputStream
  • BufferedReader
  • BufferedWriter

The buffer stream needs to be “ Socket joint ” On the corresponding node stream , The buffer stream can be divided into :

effect

effect : Provide stream reading 、 The speed of writing
The reason to improve the speed of reading and writing : Internally, a buffer is provided . By default 8kb

image-20201109205146948.png

Use BufferedInputStream and BufferedOutputStream: Processing non text files

// How to copy files
public void copyFileWithBuffered(String srcPath,String destPath){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//1. Making documents
File srcFile = new File(srcPath);
File destFile = new File(destPath);
//2. Flow making
//2.1 Making node flow
FileInputStream fis = new FileInputStream((srcFile));
FileOutputStream fos = new FileOutputStream(destFile);
//2.2 Create a buffer stream
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
//3. The details of copying : Read 、 write in
byte[] buffer = new byte[1024];
int len;
while((len = bis.read(buffer)) != -1){
bos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4. Resources to shut down
// requirement : Turn off the outer stream first , Then close the inner stream
if(bos != null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bis != null){
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// explain : While closing the outer laminar flow , The inner layer flow will be automatically closed . About the closure of the inner laminar flow , We can omit .
// fos.close();
// fis.close();
}
}

Use BufferedReader and BufferedWriter: Processing text files

@Test
public void testBufferedReaderBufferedWriter(){
BufferedReader br = null;
BufferedWriter bw = null;
try {
// Create files and corresponding streams
br = new BufferedReader(new FileReader(new File("dbcp.txt")));
bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));
// Read and write operations
// Mode one : Use char[] Array
// char[] cbuf = new char[1024];
// int len;
// while((len = br.read(cbuf)) != -1){
// bw.write(cbuf,0,len);
// // bw.flush();
// }
// Mode two : Use String
String data;
while((data = br.readLine()) != null){
// Method 1 :
// bw.write(data + "\n");//data Line breaks are not included in
// Method 2 :
bw.write(data);//data Line breaks are not included in
bw.newLine();// Provide line feed operations
}
} catch (IOException e) {
e.printStackTrace();
} finally {
// close resource
if(bw != null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(br != null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

Converted flow

The class involved in the conversion flow : Belongs to the character stream

InputStreamReader: Will a byte The input stream of is converted to character The input stream of

decode : byte 、 Byte array ---> A character array 、 character string

OutputStreamWriter: Will a character The output stream of the byte The output stream of

code : A character array 、 character string ---> byte 、 Byte array

To put it bluntly . Look at the picture below , Is to use character streams to process byte streams

Provides conversion between byte stream and character stream

image-20201109210448374.png

Typical implementation

@Test
public void test1() throws IOException {
FileInputStream fis = new FileInputStream("dbcp.txt");
// InputStreamReader isr = new InputStreamReader(fis);// Use the default character set of the system
// Parameters 2 Indicates the character set , Which character set to use , Depends on the file dbcp.txt The character set used when saving
InputStreamReader isr = new InputStreamReader(fis,"UTF-8");// Use the default character set of the system
char[] cbuf = new char[20];
int len;
while((len = isr.read(cbuf)) != -1){
String str = new String(cbuf,0,len);
System.out.print(str);
}
isr.close();
}
@Test
public void test2() throws Exception {
//1. Making documents 、 Flow making
File file1 = new File("dbcp.txt");
File file2 = new File("dbcp_gbk.txt");
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
InputStreamReader isr = new InputStreamReader(fis,"utf-8");
OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
//2. Reading and writing process
char[] cbuf = new char[20];
int len;
while((len = isr.read(cbuf)) != -1){
osw.write(cbuf,0,len);
}
//3. close resource
isr.close();
osw.close();
}

// The way the document is encoded ( such as :GBK), Determines the character set to use when parsing ( It can only be GBK).

Common coding table

ASCII: American standard information interchange code .
Use a byte of 7 Bits can represent .
ISO8859-1: Latin code table . European Code watch
Use a byte of 8 Who said .
GB2312: Chinese code table of China . Up to two bytes encode all characters
GBK: China's Chinese coding table upgrade , It integrates more Chinese characters and symbols . Up to two byte encoding
Unicode: International Standard Code , It integrates all the characters currently used by humans . Assign a unique character code to each character . All the text is represented in two bytes .
UTF-8: Variable length encoding , You can use 1-4 Bytes to represent a character .

The use of other streams

Standard input and output streams

System.in: Standard input stream , Input from the keyboard by default
System.out: Standard output stream , Output from the console by default

Modify the default input and output behavior

System Class setIn(InputStream is) / setOut(PrintStream ps) Method to specify the input and output streams .

Print stream

PrintStream and PrintWriter

Provides a series of overloaded print() and println() Method , Output for multiple data types

System.out The return is PrintStream Example

Data flow

DataInputStream and DataOutputStream

effect

A variable or string used to read or write basic data types

Example

  1. Put the string in memory 、 The variables of the basic data type are written out to the file .

    @Test
    public void test3() throws IOException {
    //1.
    DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
    //2.
    dos.writeUTF(" Liu Jianchen ");
    dos.flush();// Refresh operation , Write data in memory to a file
    dos.writeInt(23);
    dos.flush();
    dos.writeBoolean(true);
    dos.flush();
    //3.
    dos.close();
    }
    
  2. Read the basic data type variables and strings stored in the file into memory , Save in variable .

    @Test
    public void test4() throws IOException {
    //1.
    DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
    //2.
    String name = dis.readUTF();
    int age = dis.readInt();
    boolean isMale = dis.readBoolean();
    System.out.println("name = " + name);
    System.out.println("age = " + age);
    System.out.println("isMale = " + isMale);
    //3.
    dis.close();
    }
    

The use of object streams

Object flow

ObjectInputStream and ObjectOutputStream

effect

ObjectOutputStream: Objects in memory ---> Files in storage 、 It's transmitted over the Internet : Serialization process
ObjectInputStream: Files in storage 、 Received over the Internet ---> Objects in memory : Deserialization process

The object serialization mechanism allows the Java Object to platform independent binary stream , This allows the binary stream to be persistent on disk , Or transfer this binary stream over the network to another network node .// When other programs get this binary stream , It can be restored to the original Java object

Serialization and deserialization

serialize

@Test
public void testObjectOutputStream(){
ObjectOutputStream oos = null;
try {
//1.
oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
//2.
oos.writeObject(new String(" I love tian 'anmen square in Beijing "));
oos.flush();// Refresh operation
oos.writeObject(new Person(" Wang Ming ",23));
oos.flush();
oos.writeObject(new Person(" Zhang xueliang ",23,1001,new Account(5000)));
oos.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(oos != null){
//3.
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

Deserialization

@Test
public void testObjectInputStream(){
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream("object.dat"));
Object obj = ois.readObject();
String str = (String) obj;
Person p = (Person) ois.readObject();
Person p1 = (Person) ois.readObject();
System.out.println(str);
System.out.println(p);
System.out.println(p1);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if(ois != null){
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(“data.txt"));
Person p = new Person(" Han Meimei ", 18, " Zhonghua Street ", new Pet());
oos.writeObject(p);
oos.flush();
oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(“data.txt"));
Person p1 = (Person)ois.readObject();
System.out.println(p1.toString());
ois.close();

The class of the object that implements serialization needs to satisfy

  1. Need to implement interface :Serializable
  2. The current class provides a global constant :serialVersionUID
  3. Except for the present Person Class needs to be implemented Serializable Beyond the interface , It is also necessary to ensure that its internal properties are serializable .( By default , Basic data types are serializable )

Add :ObjectOutputStream and ObjectInputStream Cannot serialize static and transient Modified member variables

Path、 Paths、Files The use of the class

NIO Instructions for use

  • Java NIO (New IO,Non-Blocking IO) It's from Java 1.4 A new set of IO API, Can replace the standard Java
    IO AP.
  • NIO Original IO The same function and purpose , But in a totally different way ,NIO Support for buffer oriented (IO It's stream oriented )、 Channel based IO operation .
  • NIO It will read and write files in a more efficient way .
  • With JDK 7 Release ,Java Yes NIO It's a huge expansion , Enhanced support for file processing and file system features , So we call them NIO.2.

Path Use ---jdk7 Provide

import java.io.File;
File file = new File("index.html");
import java.nio.file.Path;
import java.nio.file.Paths;
Path path = Paths.get("index.html");

Path It can be seen as File Upgrade version of class , Actually quoted information The source may not exist

版权声明
本文为[Want to exchange steamed stuffed bun for thesis]所创,转载请带上原文链接,感谢

  1. 【计算机网络 12(1),尚学堂马士兵Java视频教程
  2. 【程序猿历程,史上最全的Java面试题集锦在这里
  3. 【程序猿历程(1),Javaweb视频教程百度云
  4. Notes on MySQL 45 lectures (1-7)
  5. [computer network 12 (1), Shang Xuetang Ma soldier java video tutorial
  6. The most complete collection of Java interview questions in history is here
  7. [process of program ape (1), JavaWeb video tutorial, baidu cloud
  8. Notes on MySQL 45 lectures (1-7)
  9. 精进 Spring Boot 03:Spring Boot 的配置文件和配置管理,以及用三种方式读取配置文件
  10. Refined spring boot 03: spring boot configuration files and configuration management, and reading configuration files in three ways
  11. 精进 Spring Boot 03:Spring Boot 的配置文件和配置管理,以及用三种方式读取配置文件
  12. Refined spring boot 03: spring boot configuration files and configuration management, and reading configuration files in three ways
  13. 【递归,Java传智播客笔记
  14. [recursion, Java intelligence podcast notes
  15. [adhere to painting for 386 days] the beginning of spring of 24 solar terms
  16. K8S系列第八篇(Service、EndPoints以及高可用kubeadm部署)
  17. K8s Series Part 8 (service, endpoints and high availability kubeadm deployment)
  18. 【重识 HTML (3),350道Java面试真题分享
  19. 【重识 HTML (2),Java并发编程必会的多线程你竟然还不会
  20. 【重识 HTML (1),二本Java小菜鸟4面字节跳动被秒成渣渣
  21. [re recognize HTML (3) and share 350 real Java interview questions
  22. [re recognize HTML (2). Multithreading is a must for Java Concurrent Programming. How dare you not
  23. [re recognize HTML (1), two Java rookies' 4-sided bytes beat and become slag in seconds
  24. 造轮子系列之RPC 1:如何从零开始开发RPC框架
  25. RPC 1: how to develop RPC framework from scratch
  26. 造轮子系列之RPC 1:如何从零开始开发RPC框架
  27. RPC 1: how to develop RPC framework from scratch
  28. 一次性捋清楚吧,对乱糟糟的,Spring事务扩展机制
  29. 一文彻底弄懂如何选择抽象类还是接口,连续四年百度Java岗必问面试题
  30. Redis常用命令
  31. 一双拖鞋引发的血案,狂神说Java系列笔记
  32. 一、mysql基础安装
  33. 一位程序员的独白:尽管我一生坎坷,Java框架面试基础
  34. Clear it all at once. For the messy, spring transaction extension mechanism
  35. A thorough understanding of how to choose abstract classes or interfaces, baidu Java post must ask interview questions for four consecutive years
  36. Redis common commands
  37. A pair of slippers triggered the murder, crazy God said java series notes
  38. 1、 MySQL basic installation
  39. Monologue of a programmer: despite my ups and downs in my life, Java framework is the foundation of interview
  40. 【大厂面试】三面三问Spring循环依赖,请一定要把这篇看完(建议收藏)
  41. 一线互联网企业中,springboot入门项目
  42. 一篇文带你入门SSM框架Spring开发,帮你快速拿Offer
  43. 【面试资料】Java全集、微服务、大数据、数据结构与算法、机器学习知识最全总结,283页pdf
  44. 【leetcode刷题】24.数组中重复的数字——Java版
  45. 【leetcode刷题】23.对称二叉树——Java版
  46. 【leetcode刷题】22.二叉树的中序遍历——Java版
  47. 【leetcode刷题】21.三数之和——Java版
  48. 【leetcode刷题】20.最长回文子串——Java版
  49. 【leetcode刷题】19.回文链表——Java版
  50. 【leetcode刷题】18.反转链表——Java版
  51. 【leetcode刷题】17.相交链表——Java&python版
  52. 【leetcode刷题】16.环形链表——Java版
  53. 【leetcode刷题】15.汉明距离——Java版
  54. 【leetcode刷题】14.找到所有数组中消失的数字——Java版
  55. 【leetcode刷题】13.比特位计数——Java版
  56. oracle控制用户权限命令
  57. 三年Java开发,继阿里,鲁班二期Java架构师
  58. Oracle必须要启动的服务
  59. 万字长文!深入剖析HashMap,Java基础笔试题大全带答案
  60. 一问Kafka就心慌?我却凭着这份,图灵学院vip课程百度云