当前位置： 首页 > java >正文

Java零基础快速入门

java 2025/7/18 7:39:48

这篇文章只限于想快速了解Java的小伙伴，当然也适合学过一段时间的复盘，做的不好还请你们多多担待，希望在以后的日子里可以跟你们一起进步。

目录

一、准备工具

2. 基础语法

3. 数据类型与变量

Scanner

基本数据类型

出基本类型外还有引用数据类型，如数组，对象，集合等

 5、break和continue

6、选择结构语句

7、循环结构语句

8、面向对象三大特性

九、异常

一、什么是异常？

二、异常分类（常见异常类型）

十、引用数据类型 

一、数组(Array)

数组特点：

二、字符串（String）

字符串特点：

三、集合

集合框架的核心接口

 十一、IO流(Input/Output Streams)

十二、线程 

 十三、网络编程

一、准备工具

1.安装JDK

从Oracle官方安装需要的版本，推荐JDK8或者11,安装步骤默认就行，安装的路径可以根据自己选择

2.配置环境变量->为了通过修改PATH变量，允许用户从命令行直接运行Java相关工具，如java, javac等，而不需要指定完整的路径。

步骤：右击此电脑->属性->高级系统设置->环境变量->系统变量做修改

增加JAVA_HOME指定bin目录，双击Path变量，增加%JAVA_HOME\bin%

2.在dos命令终端(win+R输入cmd回车)中输入java -version和javac -version来检查Java和Javac的版本信息

3.安装一款开发工具

这里建议新手小白刚开始学习Java时安装一些偏文本编辑器的，如Sublime Text、Notepad++等

因为偏重量级的开发工具比较智能有代码提示功能，这是不利于打基础的。

2. 基础语法

Hello World: 最简单的Java程序,也是所有程序员入门的第一个程序。

public class HelloWorld {public static void main(String[] args) {System.out.println("Hello, world!");}
}

 这里大家只需要知道类的定义格式为 public class 类名

main()方法是程序的主入口就行，Java代码都是在这里面执行的

System.out.println()；Java的在控制端打印内容的语句

注释：单行注释  // 注释内容         多行注释 /* 注释内容*/

标识符命名规则：

以英文字母大小写，数字0-9，_和$组合

不能以数字开头

不能是关键字

不能存在空格

大驼峰命名：每个单词首字母大写，适用于类名起名

小驼峰命名：第一个单词全部小写，第二个单词起每个单词首字母大写，如变量，常量，方法名等

3. 数据类型与变量

变量遵循标识符命名规则

变量只在作用域内有用

这个类我是后面才想起来的，回来补一下，因为经常用到

Scanner

Scanner 类是 Java 提供的一个用于获取用户输入的便捷工具,需要导包，

在头部写import java.util.Scanner

import java.util.Scanner; // 导入Scanner类public class ScannerExample {public static void main(String[] args) {// 创建一个Scanner对象，关联到标准输入(System.in)Scanner scanner = new Scanner(System.in);System.out.println("请输入您的姓名：");String name = scanner.nextLine(); // 读取一行字符串输入System.out.println("请输入您的年龄：");int age = scanner.nextInt(); // 读取一个整数输入System.out.println("请输入您的身高（米）：");double height = scanner.nextDouble(); // 读取一个浮点数输入// 输出用户输入的信息System.out.println("您好, " + name + "。您今年" + age + "岁，身高为" + height + "米。");}
}

基本数据类型

整型

byte a = 1;      // 1字节，8位有符号整数（-128~127）
short b = 2;     // 2字节，16位有符号整数（-32768~32767）
int c = 3;       // 4字节，32位有符号整数（-2^31~2^31-1）
long d = 4L;     // 8字节，64位有符号整数（-2^63~2^63-1）

浮点型

float e = 5.0f;  // 4字节，32位单精度浮点数（IEEE 754标准）
double f = 6.0;  // 8字节，64位双精度浮点数（IEEE 754标准）

字符型

char g = 'A';    // 2字节，16位Unicode字符（\u0000~\uffff）

 布尔型

boolean h = true; // 官方未明确字节数，JVM通常用1字节或4字节存储

注意：

  1. 布尔类型在不同JVM实现中占用空间可能不同
  2. 长整型（long）和浮点型（float）需分别用L和f后缀显式声明

出基本类型外还有引用数据类型，如数组，对象，集合等

类型转换示例：

double d = 3.14;
int i = (int)d;  // 显式强制转换，结果为3

类型大的向小的转换需要进行强制类型转换

小的转大的有自动转换功能

这里所说的容量大小不是指占用字节大小，而是指表示数据范围的大小，如long可以转换为float

特别的：byte和short以及char的运算结果都为int，不能用他们本身来接收

精度损失1：

dpuble d1=12.3;double d2=12.9int n1=(int)d1;//12int n2=(int)d2;//12

不存在四舍五入，而是直接截断

精度损失2：

int n=128byte b=(byte)n;//-128

截取高位二进制，剩下最后一位作为高位的表示符号位

进制

二进制：以0b开头

八进制：以0开头

十六进制：以0X开头

//二进制
int x=0b110;
//八进制
int y=072;
//十六进制
int z=0X123;

四、基本运算符

运算符类型示例说明
算术运算符+, -, *, /, %数学计算
赋值运算符=, +=, -=给变量赋值
关系运算符>, <, ==, !=判断两个值之间的关系
逻辑运算符&&, `
自增/自减运算符++, --变量自增或自减
位移运算符<<,>>,>>>二进制运算

public class Main {public static void main(String[] args) {// ================== 算术运算符 ==================int a = 10, b = 3;System.out.println("算术运算符：");System.out.println("a + b = " + (a + b)); // 加法System.out.println("a - b = " + (a - b)); // 减法System.out.println("a * b = " + (a * b)); // 乘法System.out.println("a / b = " + (a / b)); // 除法（取商）System.out.println("a % b = " + (a % b)); // 取余数// ================== 赋值运算符 ==================System.out.println("\n赋值运算符：");int c = 5;          // 基本赋值c += 2;             // 等价于 c = c + 2System.out.println("c += 2 后的值：" + c);c -= 1;             // 等价于 c = c - 1System.out.println("c -= 1 后的值：" + c);c *= 3;             // 等价于 c = c * 3System.out.println("c *= 3 后的值：" + c);// ================== 关系/比较运算符 ==================System.out.println("\n关系/比较运算符（返回 boolean 值）：");System.out.println("a > b ? " + (a > b));   // 大于System.out.println("a < b ? " + (a < b));   // 小于System.out.println("a == b ? " + (a == b)); // 等于System.out.println("a != b ? " + (a != b)); // 不等于System.out.println("a >= b ? " + (a >= b)); // 大于等于System.out.println("a <= b ? " + (a <= b)); // 小于等于// ================== 逻辑运算符 ==================System.out.println("\n逻辑运算符（操作 boolean 类型）：");boolean x = true, y = false;System.out.println("x && y = " + (x && y)); // 与（AND）System.out.println("x || y = " + (x || y)); // 或（OR）System.out.println("!x = " + (!x));         // 非（NOT）// ================== 自增/自减运算符 ==================System.out.println("\n自增/自减运算符：");int d = 5;System.out.println("d++ = " + (d++)); // 后自增：先使用再加1 → 输出 5System.out.println("现在 d = " + d);  // 此时 d 已变成 6System.out.println("++d = " + (++d)); // 前自增：先加1再使用 → 输出 7int e = 10;System.out.println("e-- = " + (e--)); // 后自减：先使用再减1 → 输出 10System.out.println("现在 e = " + e);  // 此时 e = 9System.out.println("--e = " + (--e)); // 前自减：先减1再使用 → 输出 8// ================== 位移运算符 ==================int num1 = 5; // 二进制：0000 0101int result1 = num1 << 2; // 左移2位 => 0001 0100System.out.println("左移结果：" + result1); // 输出：20int num2 = -8; // 二进制表示（32位系统）：11111111 11111111 11111111 11111000int result2 = num2 >> 2; // 右移2位System.out.println("右移结果：" + result2); // 输出：-2int num3 = -1; // 二进制全是1：11111111 11111111 11111111 11111111int result3 = num3 >>> 1; // 无符号右移1位，最高位补0，正负数都是如此System.out.println("无符号右移结果：" + result3); // 输出：2147483647}
}

 5、break和continue

关键字功能描述
break终止最近的封闭循环或switch语句
continue跳过当前循环体的剩余部分，立即开始下一次循环
  // ================== Break 和 Continue 示例 ==================System.out.println("\nBreak 和 Continue 示例:");for (int m = 0; m < 10; m++) {if (m == 3) {continue; // 跳过本次循环剩余部分，直接进入下一次循环}if (m == 7) {break; // 终止循环}System.out.println("当前的m值是: " + m);}

6、选择结构语句

语句类型简洁描述
If根据条件执行代码块。
If-Else条件为真时执行一段代码，为假时执行另一段代码。
If-Else If-Else多条件分支，依次判断直至满足某一条件或执行默认代码。
Switch根据变量值匹配case执行相应代码块，支持默认处理（default）。

public class Mainde {public static void main(String[] args) {// 示例变量int number = 15;String dayOfWeek = "Wednesday";// ================== if-else 选择语句 ==================System.out.println("=== If-Else 选择语句 ===");if (number > 10) {System.out.println("Number is greater than 10.");} else if (number < 10) {System.out.println("Number is less than 10.");} else {System.out.println("Number is equal to 10.");}// ================== switch 选择语句 ==================System.out.println("\n=== Switch 选择语句 ===");switch (dayOfWeek) {case "Monday":System.out.println("Today is Monday.");break;case "Tuesday":System.out.println("Today is Tuesday.");break;case "Wednesday":System.out.println("Today is Wednesday.");break;default:System.out.println("Looking forward to the weekend.");}// 另一个 switch 示例，演示使用整数System.out.println("\n=== Switch with Integer ===");int month = 8;switch (month) {case 1: case 2: case 3:System.out.println("第一季度");break;case 4: case 5: case 6:System.out.println("第二季度");break;case 7: case 8: case 9:System.out.println("第三季度");break;case 10: case 11: case 12:System.out.println("第四季度");break;default:System.out.println("无效的月份");}// ================== 演示 case 穿透（fall-through）==================System.out.println("\n=== 演示 case 穿透（fall-through）===");int grade = 85;switch (grade / 10) {case 10:case 9:System.out.println("优秀");// 没有 break，会穿透到下一个 casecase 8:System.out.println("良好");// 没有 break，继续穿透case 7:System.out.println("中等");break;case 6:System.out.println("及格");break;default:System.out.println("不及格");}/** 上面的例子中：* grade = 85 → grade / 10 = 8* 所以进入 case 8:* 但由于没有 break，会继续执行 case 7: 的内容。* 输出结果为：* 良好* 中等*/}
}

switch语句中的穿透就不做详细介绍了，代码上有

7、循环结构语句

语句类型描述特点
For执行已知次数的循环初始化、条件判断、更新表达式
While当条件为真时执行循环先判断后执行
Do-While至少执行一次循环，直到条件为假先执行后判断
增强型 For遍历数组或集合简化遍历操作

public class Maindemo2 {public static void main(String[] args) {// ================== For 循环 ==================System.out.println("For 循环示例:");for (int i = 0; i < 5; i++) { // 初始化; 条件判断; 更新表达式System.out.println("当前的i值是: " + i);}// ================== While 循环 ==================System.out.println("\nWhile 循环示例:");int j = 0;while (j < 3) { // 当条件为true时执行循环体System.out.println("当前的j值是: " + j);j++; // 必须更新循环变量，否则会导致无限循环}// ================== Do-While 循环 ==================System.out.println("\nDo-While 循环示例:");int k = 0;do {System.out.println("当前的k值是: " + k);k++;} while (k < 2); // 先执行一次循环体，然后检查条件// ================== 增强型 For 循环（适用于数组和集合） ==================System.out.println("\n增强型 For 循环示例:");int[] numbers = {1, 2, 3, 4, 5};for (int num : numbers) { // 遍历数组中的每个元素System.out.println("数组中的元素: " + num);}}
}

8、面向对象三大特性

这个部分很重要，建议有时间的小伙伴好好学这部分 

简单说一下类和对象：

类就是一个类型，抽象的类型，比如人类、动物、学生、老师，把具有相同特性的事物称为一个类

对象就是具有属性和行为的，它是实体的，什么意思？就是学生类中某一名学生，老师类中某一名老师就分别属于他们对应类的一个对象也叫实例。我习惯叫对象，相信大家也是，方便理解。

特性描述关键点
封装将数据和方法绑定在一起，并隐藏内部实现细节。访问控制（如：private, public, protected），类的概念
继承允许一个类继承另一个类的属性和方法，促进代码复用。extends关键字，父类与子类关系
多态同一接口可以有多种形式，通过方法重载或覆盖实现不同行为。方法重写（@Override），动态绑定，接口或抽象类的实现

简单来说：

封装->就是创建一个具有相同共性的类

继承->就是儿子跟爸爸的关系，他们有很多类似的地方可以封装成另一个类，只支持单继承

多态-> 类的多种形态，比如狗类和猫类它们都是动物类，子类引用指向父类对象

这里会涉及到一些构造函数，方法重载，重写和接口，抽象类，因为是快速入门我就不写这方面的大家有时间自己去了解一下，因为我觉得速成的话，这些够用了

// 封装演示：定义一个类，使用private修饰成员变量，并提供公共方法来访问这些变量
class Animal {// 使用 private 修饰符进行封装，外部不能直接访问private String name;private int age;// 构造函数public Animal(String name, int age) {this.name = name;this.age = age;}// 提供getter和setter方法，以安全的方式访问私有成员变量public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {if (age > 0) { // 简单的数据验证this.age = age;}}// 定义一个普通方法public void makeSound() {System.out.println("Some generic animal sound");}
}// 继承演示：定义一个子类继承自Animal类
class Dog extends Animal {// 子类构造器需要调用父类构造器public Dog(String name, int age) {super(name, age); // 调用父类的构造函数}// 方法重写（覆盖），展示多态性@Overridepublic void makeSound() {System.out.println(getName() + " barks");}
}// 另一个子类
class Cat extends Animal {public Cat(String name, int age) {super(name, age);}@Overridepublic void makeSound() {System.out.println(getName() + " meows");}
}public class Main {public static void main(String[] args) {// 封装演示：通过getter和setter方法访问和修改私有成员变量Animal myAnimal = new Animal("Generic Animal", 5);System.out.println("Animal's name: " + myAnimal.getName());myAnimal.setAge(6);System.out.println("Animal's age: " + myAnimal.getAge());// 继承演示：创建Dog和Cat对象Dog myDog = new Dog("Buddy", 4);Cat myCat = new Cat("Whiskers", 3);// 多态演示：使用父类类型的引用来引用子类对象Animal dogAsAnimal = myDog;Animal catAsAnimal = myCat;// 调用各自的方法，实际调用的是子类中重写的方法dogAsAnimal.makeSound(); // 输出 Buddy barkscatAsAnimal.makeSound(); // 输出 Whiskers meows// 直接调用子类对象的方法也是可以的myDog.makeSound(); // 输出 Buddy barksmyCat.makeSound(); // 输出 Whiskers meows}
}

九、异常

一、什么是异常？

在程序运行过程中发生的错误或意外情况称为“异常”（Exception）。我们需要进行相应处理，避免程序崩溃。

二、异常分类（常见异常类型）

异常类型说明示例
Error系统级错误，通常不处理OutOfMemoryError, StackOverflowError
Exception可检查异常（编译时异常）IOException, SQLException
RuntimeException运行时异常（非检查异常）NullPointerException, ArrayIndexOutOfBoundsException

 第二个和第三个是需要掌握的，也是后续很常见的

给大家演示一下：

public class ExceptionDemo {public static void main(String[] args) {try {// 尝试执行可能会出错的代码int result = divide(10, 0); // 分母为0，会抛出 ArithmeticExceptionSystem.out.println("结果是：" + result);} catch (ArithmeticException e) {// 捕获特定异常System.out.println("发生算术异常: " + e.getMessage());} catch (Exception e) {// 捕获其他通用异常System.out.println("发生了异常: " + e.getMessage());} finally {// 不管有没有异常都会执行System.out.println("finally块始终执行");}try {// 主动抛出异常validateAge(-5);} catch (IllegalArgumentException e) {System.out.println("非法年龄异常: " + e.getMessage());}}// 方法中使用 throws 声明可能抛出的异常public static int divide(int a, int b) throws ArithmeticException {return a / b;}// 验证年龄是否合法public static void validateAge(int age) {if (age < 0) {// 抛出自定义异常信息throw new IllegalArgumentException("年龄不能为负数");}}
}

总结： 

关键字作用
try包含可能会发生异常的代码块
catch捕获并处理异常
finally不管是否发生异常都执行（如关闭资源）
throw手动抛出一个异常对象
throws声明方法可能抛出的异常类型

十、引用数据类型 

一、数组(Array)

数组是一种数据结构，用于存储固定大小的同类型元素集合。

数组特点：

固定大小：一旦创建后，数组的大小不可改变。

索引访问：通过索引访问数组元素，索引从0开始。

public class ArrayExample {public static void main(String[] args) {// 创建一个整型数组int[] numbers = new int[5]; // 定义了一个可以存储5个整数的数组// 初始化数组元素for (int i = 0; i < numbers.length; i++) { // length属性获取数组长度numbers[i] = i * 10; // 给每个元素赋值}// 遍历并打印数组元素System.out.println("数组元素为：");for (int num : numbers) { // 增强for循环遍历数组System.out.print(num + " ");}}
}

二、字符串（String）

在Java中，String是一个类，表示文本数据.

字符串特点：

不可变性：每次对字符串进行操作都会生成一个新的字符串对象。

丰富的API支持：提供了大量的方法来操作字符串，如查找、替换、分割等。

public class StringExample {public static void main(String[] args) {// 创建字符串String greeting = "Hello, World!";// 获取字符串长度System.out.println("字符串长度: " + greeting.length());// 查找子串的位置System.out.println("子串World的位置: " + greeting.indexOf("World"));// 拼接字符串String result = greeting.concat(" Welcome to Java!");System.out.println("拼接后的字符串: " + result);// 替换字符串中的字符String replacedResult = result.replace("!", ".");System.out.println("替换后的字符串: " + replacedResult);// 转换为大写System.out.println("转换为大写的字符串: " + greeting.toUpperCase());}
}

三、集合

集合框架的核心接口

List：有序集合，允许重复元素。

Set：不包含重复元素的集合。

Queue：通常用于实现队列数据结构，支持先进先出(FIFO)的操作。这个不用勉强，后面数据结构会讲

Map：存储键值对的集合，不允许有重复的键。

速成阶段大家只需要掌握List

import java.util.*;public class CollectionExample {public static void main(String[] args) {// ================== List 示例 ==================System.out.println("List 示例:");List<String> list = new ArrayList<>();list.add("Apple"); // 添加元素到列表末尾list.add("Banana");list.add("Apple"); // List允许重复元素System.out.println("原始列表: " + list);System.out.println("索引1处的元素: " + list.get(1)); // 通过索引访问元素}
}

原始列表: [Apple, Banana, Apple]
索引1处的元素: Banana

 十一、IO流(Input/Output Streams)

那什么是流，就想象成水管子就行，我就是这么抽象，然后数据就相当于水。IO就是取和存，

这里有人不理解，I不是相当于Input往里的存吗，其实这里的IO是相对外部资源的，外部资源要展示在程序中就要通过输入即Input，而程序要对外部资源进行数据传输就要输出出去即Output。

这些外部资源可以是文件、网络连接等

package com.whm.io;
import java.io.*;public class Test {public static void main(String[] args) {//字符流//输入输出流创建和读取文件File f = new File("D://whm.txt");//文件路径FileWriter fw = null;try {fw = new FileWriter(f);fw.write("你好，你成功读出");//向文件写入东西} catch (IOException e) {//这个异常前面跟大家说过，应该还记得吧！！！e.getStackTrace();} finally {try {fw.close();//关闭流，水管嘛，不管浪费资源} catch (IOException e) {throw new RuntimeException(e);}}//读出文件内容try {FileReader fr = new FileReader("D://whm.txt");char []arr=new char[220];int length;while ((length = fr.read(arr)) != -1) {System.out.println(new String(arr, 0, length));}}catch (IOException e){e.getStackTrace();}}
}

大家可以看到如果文件不存在，我的D盘根据路径自动创建的文件： 

十二、线程 

这里了解一下线程是什么，怎么创建，怎么运行就行

至于同步、锁、线程池这些速成之后再去了解，因为速成是为了建立一个大概的脉络

概念说明
Thread 类Java中表示线程的基本类
start() 方法启动一个新线程，JVM会调用该线程的 run() 方法
run() 方法线程要执行的任务逻辑，通常通过重写或使用 Lambda 表达式定义
sleep() 方法让当前线程暂停一段时间（单位为毫秒），用于模拟耗时任务
线程名可以通过构造器设置线程名称，便于调试和日志输出

 线程是程序执行流的最小单元。多线程允许同时执行多个任务，从而提高程序的响应速度和效率。

线程状态：包括新建、就绪、运行、阻塞、等待、超时等待和终止等状态。

class MyThread extends Thread {@Overridepublic void run() {for (int i = 1; i <= 3; i++) {System.out.println(Thread.currentThread().getName() + ": " + i);}}
}public class Main {public static void main(String[] args) {MyThread t1 = new MyThread();MyThread t2 = new MyThread();t1.start(); // 启动线程1t2.start(); // 启动线程2}
}
输出结果：
Thread-0: 1
Thread-1: 1
Thread-0: 2
Thread-1: 2
Thread-0: 3
Thread-1: 3

 十三、网络编程

这里了解一下Socket套接字就可以，然后就可以从头细学了，因为后面的JavaWeb中也会用到Socket，所有大家从头下学到这的时候要认真学这部分基础

Socket编程是网络通信的基础，它允许不同计算机之间通过网络进行数据交换->也就是类似微信聊天

掌握两个核心:

  1. ServerSocket：监听来自客户端的连接请求。嗯每个服务器至少有一个对象（实例）
  2. Socket：客户端或服务器端的通信端点。客户端使用Socket连接到服务器，服务器则接受来自客户端的Socket连接。

前面学习的IO流在这就体现出来了，可以通过IO流进行相互传输数据

运行的时候一定要先运行服务器端监听端口，再运行客户端进行连接

服务器端：

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;public class Socketdemo {public static void main(String[] args) throws IOException {int port = 12345; // 服务器监听的端口号ServerSocket serverSocket = new ServerSocket(port);System.out.println("服务器启动，等待连接...");try (Socket clientSocket = serverSocket.accept()) { // 等待客户端连接System.out.println("客户端已连接: " + clientSocket.getInetAddress());// 获取输入流读取客户端发送的消息BufferedReader in = new BufferedReader(new         InputStreamReader(clientSocket.getInputStream()));String inputLine;while ((inputLine = in.readLine()) != null && !inputLine.equals("bye")) {System.out.println("收到客户端消息: " + inputLine);}// 获取输出流向客户端发送消息PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);out.println("Goodbye, thanks for connecting.");} catch (IOException e) {e.printStackTrace();}}
}

客户端：

import java.io.*;
import java.net.Socket;public class SimpleClient {public static void main(String[] args) throws IOException {String hostname = "localhost"; // 服务器地址int port = 12345; // 连接的端口号try (Socket socket = new Socket(hostname, port)) {// 发送消息给服务器PrintWriter out = new PrintWriter(socket.getOutputStream(), true);out.println("Hello from client!");// 接收服务器响应BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));String response;while ((response = in.readLine()) != null) {System.out.println("收到服务器响应: " + response);break; // 假设只接收一条消息后退出}// 发送结束信号out.println("bye");} catch (IOException e) {e.printStackTrace();}}
}

如果做的不好有改进的地方，希望大家给点建议，谢谢支持！！！ 

速成阶段的路线基本就是基础语法->面向对象->集合框架->IO->多线程->网络编程

中间还有很多内容等着小伙伴们学，这个只时候大家大概了解JavaSE。熟话说要学习一个知识点得先大概了解它的整体框架，然后再慢慢的深入，祝每一位小伙伴都可以把Java学的很好，也多指点指点我，谢谢你们！

http://www.xdnf.cn/news/15565.html

相关文章：

  • Vue3入门-组件及组件化
  • Kafka——无消息丢失配置怎么实现？
  • SpringMVC核心注解：@RequestMapping详解
  • java-字符串
  • modelscope ProxyError: HTTPSConnectionPool(host=‘www.modelscope.cn‘, port=443)
  • JxBrowser 7.43.5 版本发布啦！
  • HTML 常用语义标签与常见搭配详解
  • 图片画廊浏览（侧重 CSS 网格布局和模态框交互）
  • 代码随想录算法训练营第二十二天
  • 项目学习笔记 display从none切换成block
  • 基于SD-WAN的智慧高速解决方案：高效、低成本的智能交通实践
  • 数据结构 双向链表(2)--双向链表的实现
  • Kotlin集合聚合
  • ABP VNext + EF Core 二级缓存：提升查询性能
  • FAISS深度学习指南：构建高效向量检索系统的完整方法论
  • Dify工作流节点-Agent
  • 二分查找算法(一）
  • 玩转Docker | 使用Docker部署vnStat网络流量监控服务
  • Python编程基础（六）| 用户输入和while循环
  • 算法精讲--正则表达式（二）：分组、引用与高级匹配技术
  • GENERALIST REWARD MODELS: FOUND INSIDE LARGELANGUAGE MODELS
  • 7.17 滑动窗口 |assign |memo |pii bfs
  • 【Linux】如何使用nano创建并编辑一个文件
  • 使用token调用Spring OAuth2 Resource Server接口错误 insufficient_scope
  • Redis1：高并发与微服务中的键值存储利器
  • 第四章 OB SQL调优
  • OJ题目里面的复杂图形的输出类型的汇总展示（巧妙地利用对称性offset偏移量）
  • 轻松将文件从 iPhone 传输到 Mac
  • 牛客：HJ26 字符串排序[华为机考][map]
  • 暑期算法训练.2