JAVA 语言基础

AHXGD
468 阅读15分钟

java 基础语法

说明：

  • 类：所有代码都写在类中，类名要与文件名一致，区分大小写。
  • main 方法：程序从 main 方法开始执行。
  • System.out.println：输出一行内容并换行。
public class Main { // 类名与文件名一致，区分大小写
    public static void main(String[] args) { // 主方法，程序入口
        System.out.println("Hello, World!"); // 输出语句
    }
}


public class Main { // 定义一个名为 Main 的类
    public static void main(String[] args) { // 主方法，程序从这里开始执行
        int result = add(5, 3); // 调用 add 方法
        System.out.println("The result is: " + result); // 输出结果
    }

    public static int add(int a, int b) { // 定义一个加法方法
        return a + b; // 返回两个参数的和
    }
}

1. 标识符和关键字

  • 标识符：变量名、类名、方法名等，必须以字母、$ 或 _ 开头，不能使用数字开头。
  • 关键字：Java 的保留字，不能用作标识符，如 public, static, class 等。

2. 数据类型

Java 是强类型语言，变量必须先声明类型

  • 基本数据类型：

    类型大小示例值
    byte1字节-128 到 127
    short2字节-32,768 到 32,767
    int4字节-2³¹ 到 2³¹-1
    long8字节-2⁶³ 到 2⁶³-1
    float4字节3.14f
    double8字节3.14159
    char2字节'A'，'中'
    boolean1位true 或 false

  • 引用数据类型：对象、数组、字符串等。

3. 变量声明和初始化

int number = 10; // 声明一个整型变量并赋值
double pi = 3.14; // 声明一个浮点型变量
char letter = 'A'; // 声明一个字符变量
boolean isJavaFun = true; // 声明一个布尔型变量

4. 运算符

  • 算术运算符：+ - * / %
  • 比较运算符：== != > < >= <=
  • 逻辑运算符：&& || !
  • 赋值运算符：= += -= *= /=
// 算数
int a = 10, b = 3;
System.out.println(a + b); // 13
System.out.println(a / b); // 3 (整数除法)
System.out.println(a % b); // 1 (取余)

// 比较
System.out.println(a > b); // true

// 逻辑
boolean result = (a > b) && (b > 0); // true

// 赋值
a += 5; // 等价于 a = a + 5

5. 条件控制语句

  • if-else 语句 
    if (a > b) {
    System.out.println("a is greater");
} else {
    System.out.println("b is greater");
}
  • switch 语句 
    switch (a) {
    case 1:
        System.out.println("One");
        break;
    case 2:
        System.out.println("Two");
        break;
    default:
        System.out.println("Other");
}

6. 循环语句

  • for 循环 
    for (int i = 0; i < 5; i++) {
    System.out.println(i);
}
  • while 循环 
    int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}
  • do-while 循环 
    int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 5);

7. 数组

数组是存储多个同类型数据的容器

int[] numbers = {1, 2, 3, 4, 5};
System.out.println(numbers[0]); // 输出 1
numbers[2] = 10; // 修改数组元素

// 多维数组
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6}
};
System.out.println(matrix[1][2]); // 输出 6

变量和数据类型

1.变量

  • 什么是变量？
    • 变量是程序中用于存储数据的命名空间。它是一个内存位置的引用，用来保存特定类型的数据。
  • 变量的定义和使用
    • 声明变量：指定变量的名称和数据类型。
    • 赋值：给变量存储具体的值。
    • 使用：通过变量名访问存储的值。
  • 语法
    • 数据类型 变量名 = 初始值;
  • 示例 
    int age = 25; // 声明一个整型变量并赋值
double salary = 3000.50; // 声明一个浮点型变量
char grade = 'A'; // 声明一个字符变量
boolean isJavaFun = true; // 声明一个布尔变量
  • 变量的类型
    • 局部变量
      • 声明在方法或代码块内部。
      • 只能在声明的范围内使用。
      • 必须初始化后才能使用。
      public class Main {
    public static void main(String[] args) {
        int number = 10; // 局部变量
        System.out.println(number);
    }
}
    • 实例变量
      • 声明在类中，但在方法外。
      • 属于对象，每个对象有独立的实例变量。
      public class Person {
    String name; // 实例变量
    int age;

    public void display() {
        System.out.println(name + " is " + age + " years old.");
    }
}
    • 静态变量（类变量）
      • 使用 static 关键字修饰，属于类。
      • 所有对象共享同一个静态变量。
      public class Counter {
    static int count = 0; // 静态变量
}

2. 数据类型

数据类型描述默认值大小示例
byte8 位整数01 字节-128 到 127
short16 位整数02 字节-32,768 到 32,767
int32 位整数（常用）04 字节-2³¹ 到 2³¹-1
long64 位整数0L8 字节-2⁶³ 到 2⁶³-1
float单精度浮点数0.0f4 字节3.4E-38 到 3.4E+38
double双精度浮点数（常用）0.0d8 字节1.7E-308 到 1.7E+308
char单个字符（Unicode）'\u0000'2 字节'A', '中'
boolean布尔值false1 位true 或 false
  • Java 是一种强类型语言，变量必须有类型。Java 的数据类型分为两大类：

    • 基本数据类型

      byte b = 10;
short s = 300;
int i = 1000;
long l = 123456789L;
float f = 3.14f;
double d = 3.14159265359;
char c = 'A';
boolean flag = true;

    • 引用数据类型

      • 引用数据类型包括类、接口、数组和字符串。它们存储的是对象的内存地址
        • 类：例如 String、Scanner 等。
        • 数组：存储多个同类型的数据。
        • 接口：用来定义行为
      String name = "Java";
int[] numbers = {1, 2, 3};

3. 变量的作用域和生命周期

  1. 局部变量：
    • 作用域：方法或代码块内部。
    • 生命周期：方法执行时创建，执行结束后销毁。
  2. 实例变量：
    • 作用域：整个类内，但方法外。
    • 生命周期：对象创建时初始化，销毁时结束。
  3. 静态变量：
    • 作用域：整个类。
    • 生命周期：类加载时初始化，程序结束时销毁。

4. 类型转换

  1. 自动类型转换（隐式转换）
    • 低级类型可以自动转换为高级类型。
    • 转换顺序：byte → short → int → long → float → double
    int a = 10;
double b = a; // 自动转换
  2. 强制类型转换（显式转换）
    • 高级类型需要强制转换为低级类型。
    • 可能会造成数据丢失。
    double a = 10.5;
int b = (int) a; // 强制转换
  3. 类型转换示例 
    int i = 10;
float f = i; // 自动转换
double d = 3.14;
int j = (int) d; // 强制转换

4. 综合示例

public class Main {
    public static void main(String[] args) {
        // 基本数据类型
        int age = 25;
        double height = 5.9;
        char initial = 'J';
        boolean isStudent = true;

        // 引用数据类型
        String name = "John";
        int[] scores = {85, 90, 95};

        // 输出变量
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Height: " + height);
        System.out.println("Initial: " + initial);
        System.out.println("Is student: " + isStudent);
        System.out.println("First score: " + scores[0]);
    }
}

// 运行结果
Name: John
Age: 25
Height: 5.9
Initial: J
Is student: true
First score: 85

运算符

1. 算数运算符

运算符描述示例结果
+加法5 + 38
-减法5 - 32
*乘法5 * 315
/除法5 / 22（整数除法）
%取余5 % 21
public class Main {
    public static void main(String[] args) {
        int a = 10, b = 3;
        System.out.println("加法: " + (a + b)); // 13
        System.out.println("减法: " + (a - b)); // 7
        System.out.println("乘法: " + (a * b)); // 30
        System.out.println("除法: " + (a / b)); // 3
        System.out.println("取余: " + (a % b)); // 1
    }
}

2. 赋值运算符

运算符描述示例结果
=赋值a = 5a 的值是 5
+=加法赋值a += 3等价于 a = a + 3
-=减法赋值a -= 2等价于 a = a - 2
*=乘法赋值a *= 2等价于 a = a * 2
/=除法赋值a /= 2等价于 a = a / 2
%=取余赋值a %= 3等价于 a = a % 3
public class Main {
    public static void main(String[] args) {
        int a = 5, b = 3;
        System.out.println("是否相等: " + (a == b)); // false
        System.out.println("是否不相等: " + (a != b)); // true
        System.out.println("是否大于: " + (a > b)); // true
    }
}

3. 关系/比较运算符

运算符描述示例结果
==是否相等5 == 3false
!=是否不相等5 != 3true
是否大于5 > 3true
<是否小于5 < 3false
>=是否大于等于5 >= 5true
<=是否小于等于3 <= 5true
public class Main {
    public static void main(String[] args) {
        int a = 5, b = 3;
        System.out.println("是否相等: " + (a == b)); // false
        System.out.println("是否不相等: " + (a != b)); // true
        System.out.println("是否大于: " + (a > b)); // true
    }
}

4. 逻辑运算符

运算符描述示例结果
&&逻辑与（AND）true && falsefalse
||逻辑或（OR）true || falsetrue
!逻辑非（NOT）!truefalse
// 示例1
public class Main {
    public static void main(String[] args) {
        boolean a = true, b = false;
        System.out.println("逻辑与: " + (a && b)); // false
        System.out.println("逻辑或: " + (a || b)); // true
        System.out.println("逻辑非: " + (!a)); // false
    }
}

// 示例2
public class Main {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        // 逻辑与
        System.out.println("a && b: " + (a && b)); // false

        // 逻辑或
        System.out.println("a || b: " + (a || b)); // true

        // 逻辑非
        System.out.println("!a: " + (!a)); // false

        // 短路与
        int x = 10;
        System.out.println("短路与: " + (false && (++x > 10))); // false，x 不增加
        System.out.println("x 的值: " + x); // 10

        // 短路或
        int y = 10;
        System.out.println("短路或: " + (true || (++y > 10))); // true，y 不增加
        System.out.println("y 的值: " + y); // 10
    }
}

5. 位运算符

运算符描述示例结果
&按位与5 & 31
|按位或5|37
按位异或5 ^ 36
~按位取反~5-6
<<左移5 << 220
>>右移5 >> 21
  • 常见用途
    • 权限管理：使用按位与、或来设置和检测权限。
    • 性能优化：位移运算比乘法或除法更快。
    • 加密解密：位运算常用于 XOR 加密。
    • 硬件操作：与底层二进制数据直接交互。
public class Main {
    public static void main(String[] args) {
        int a = 5;
        int b = 3;

        // 按位与
        System.out.println("5 & 3 = " + (a & b)); // 1

        // 按位或
        System.out.println("5 | 3 = " + (a | b)); // 7

        // 按位异或
        System.out.println("5 ^ 3 = " + (a ^ b)); // 6

        // 按位取反
        System.out.println("~5 = " + (~a)); // -6

        // 左移
        System.out.println("5 << 2 = " + (a << 2)); // 20

        // 右移
        System.out.println("5 >> 1 = " + (a >> 1)); // 2

        // 无符号右移
        System.out.println("-5 >>> 1 = " + (-5 >>> 1)); // 2147483645
    }
}

6. 三元运算符

是一种简洁的条件判断方式

// 变量 = (条件) ? 表达式1 : 表达式2;

public class Main {
    public static void main(String[] args) {
        int a = 10, b = 20;
        int max = (a > b) ? a : b;
        System.out.println("最大值: " + max); // 20
    }
}

7. 自增自减运算符

运算符描述示例结果
++自增a++ 或 ++aa 加 1
--自减a-- 或 --aa 减 1
  • 前缀和后缀区别：
    • 前缀（++a/--a）：先运算再使用。
    • 后缀（a++/a--）：先使用再运算。
public class Main {
    public static void main(String[] args) {
        int a = 5;
        System.out.println(a++); // 输出 5，a 变为 6
        System.out.println(++a); // 输出 7
    }
}

8. 运算符优先级

从高到低的优先级：

()：括号
++/--：自增自减
* / %
+ -
<< >>
< <= > >=
== !=
&&
||
= += -=

流程控制语句

1. 顺序结构

顺序结构是程序最基本的执行方式，代码从上到下依次执行，按照编写的顺序逐条执行。

public class Main {
    public static void main(String[] args) {
        System.out.println("第一步");
        System.out.println("第二步");
        System.out.println("第三步");
    }
}

// 运行结果
第一步
第二步
第三步

2. 分支结构

  1. if 语句 
    // 语法
if (条件表达式) {
    // 条件为 true 时执行
}

// 示例
public class Main {
    public static void main(String[] args) {
        int num = 10;
        if (num > 5) {
            System.out.println("num 大于 5");
        }
    }
}

// 结果：num 大于 5
  2. if-else 语句 
    // 语法
if (条件表达式) {
    // 条件为 true 时执行
} else {
    // 条件为 false 时执行
}

// 示例
public class Main {
    public static void main(String[] args) {
        int num = 3;
        if (num > 5) {
            System.out.println("num 大于 5");
        } else {
            System.out.println("num 小于或等于 5");
        }
    }
}

// 结果：num 小于或等于 5
  3. if-else if-else 语句 
    // 语法
if (条件1) {
    // 条件1为 true 时执行
} else if (条件2) {
    // 条件2为 true 时执行
} else {
    // 以上条件都不满足时执行
}

// 示例
public class Main {
    public static void main(String[] args) {
        int score = 85;
        if (score >= 90) {
            System.out.println("优秀");
        } else if (score >= 75) {
            System.out.println("良好");
        } else {
            System.out.println("及格");
        }
    }
}

// 结果：良好
  4. switch 语句 
    // 语法
switch (变量) {
    case 值1:
        // 当变量等于值1时执行
        break;
    case 值2:
        // 当变量等于值2时执行
        break;
    default:
        // 当变量不匹配任何 case 时执行
}

// 示例
public class Main {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            default:
                System.out.println("未知的日期");
        }
    }
}

// 结果：星期三

3. 循环结构

  1. while 循环 
    while (条件表达式) {
    // 循环体
}

// 示例
public class Main {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 5) {
            System.out.println("i = " + i);
            i++;
        }
    }
}

// 结果：
i = 1
i = 2
i = 3
i = 4
i = 5
  2. do-while 循环 
    do {
    // 循环体
} while (条件表达式);

// 示例
public class Main {
    public static void main(String[] args) {
        int i = 1;
        do {
            System.out.println("i = " + i);
            i++;
        } while (i <= 5);
    }
}

// 结果：
i = 1
i = 2
i = 3
i = 4
i = 5
  3. for 循环 
    for (初始化; 条件; 更新操作) {
    // 循环体
}

// 示例
public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("i = " + i);
        }
    }
}

// 结果：
i = 1
i = 2
i = 3
i = 4
i = 5
  4. for 循环 遍历数组或集合 
    for (数据类型 变量名 : 数组或集合) {
    // 循环体
}

// 示例
public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        for (int num : numbers) {
            System.out.println("num = " + num);
        }
    }
}

// 结果：
num = 1
num = 2
num = 3
num = 4
num = 5

4. 控制循环的关键字

  • break：立即退出当前循环。 
    public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                continue; // 跳过 i=3
            }
            System.out.println("i = " + i);
        }
    }
}

i = 1
i = 2
i = 4
i = 5
  • continue：跳过当前循环剩余部分，进入下一次循环。 
    public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                break; // 当 i 等于 3 时退出循环
            }
            System.out.println("i = " + i);
        }
        System.out.println("循环结束");
    }
}

i = 1
i = 2
循环结束
  • return：直接退出方法。 
    public class Main {
    public static void main(String[] args) {
        printNumbers();
        System.out.println("主方法继续执行");
    }

    public static void printNumbers() {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                return; // 结束当前方法
            }
            System.out.println("i = " + i);
        }
        System.out.println("方法执行完成"); // 不会执行到这里
    }
}

i = 1
i = 2
主方法继续执行

数组以及应用

1. 数组的基础概念

  1. 数组定义
    • 数组是一组相同类型数据的集合。
    • 数组的长度是固定的，一旦声明，大小不可更改。
    • 数组可以存储任意数据类型的元素，如 int、double、String 等。
    • 数组的索引从 0 开始，到 长度-1 结束。
  2. 数组的特点
    • 通过索引访问数组中的元素。
    • 元素在内存中是连续存储的。

2. 数组的声明和初始化

  1. 声明数组
// 语法
数据类型[] 数组名; // 推荐写法
数据类型 数组名[]; // 可用，但不推荐

// 示例
int[] numbers;  // 声明一个整型数组
String[] names; // 声明一个字符串数组
  1. 初始化数组
    • 静态初始化 
      // 语法
数据类型[] 数组名 = {值1, 值2, 值3, ...};

// 示例
int[] numbers = {1, 2, 3, 4, 5};
String[] names = {"Alice", "Bob", "Charlie"};
    • 动态初始化 
      // 语法
数据类型[] 数组名 = new 数据类型[长度];

// 示例
int[] numbers = new int[5]; // 创建一个长度为5的整型数组
numbers[0] = 10;           // 逐个赋值
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;

3. 访问数组中的元素

  • 通过 数组名[索引] 访问数组中的元素
  • 注意：
    • 如果访问超出索引范围的元素，如 numbers[5]（索引超出范围），会抛出 ArrayIndexOutOfBoundsException
public class Main {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        System.out.println("第一个元素：" + numbers[0]); // 访问第一个元素
        System.out.println("第三个元素：" + numbers[2]); // 访问第三个元素
    }
}

第一个元素：10
第三个元素：30

4. 数组的遍历

  1. 使用 for 循环 
    public class Main {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("索引 " + i + " 的值是：" + numbers[i]);
        }
    }
}

索引 0 的值是：10
索引 1 的值是：20
索引 2 的值是：30
索引 3 的值是：40
索引 4 的值是：50
  2. 使用增强 for 循环 
    public class Main {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        for (int num : numbers) {
            System.out.println("值是：" + num);
        }
    }
}

值是：10
值是：20
值是：30
值是：40
值是：50

5. 多维数组

  1. 声明和初始化 
    // 语法
数据类型[][] 数组名 = new 数据类型[行数][列数];

// 示例
// 初始化方式1
int[][] matrix = new int[2][3]; // 创建2行3列的二维数组
matrix[0][0] = 1;              // 第一行第一列赋值
matrix[0][1] = 2;
matrix[1][2] = 3;              // 第二行第三列赋值

// 初始化方式2
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6}
};
  2. 访问和遍历二维数组 
    public class Main {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6}
        };

        // 遍历二维数组
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.println("matrix[" + i + "][" + j + "] = " + matrix[i][j]);
            }
        }
    }
}

matrix[0][0] = 1
matrix[0][1] = 2
matrix[0][2] = 3
matrix[1][0] = 4
matrix[1][1] = 5
matrix[1][2] = 6

6. 数组的常见应用

  1. 查找最大值或最小值 
    public class Main {
    public static void main(String[] args) {
        int[] arr = {3, 1, 4, 1, 5, 9};
        int max = arr[0];
        int min = arr[0];

        for (int num : arr) {
            if (num > max) {
                max = num;
            }
            if (num < min) {
                min = num;
            }
        }

        System.out.println("最大值：" + max);
        System.out.println("最小值：" + min);
    }
}

最大值：9
最小值：1
  2. 数组求和 
    public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        System.out.println("数组的和是：" + sum);
    }
}

数组的和是：15
  3. 数组元素反转 
    public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        for (int i = 0, j = numbers.length - 1; i < j; i++, j--) {
            int temp = numbers[i];
            numbers[i] = numbers[j];
            numbers[j] = temp;
        }
        for (int num : numbers) {
            System.out.print(num + " ");
        }
    }
}

5 4 3 2 1

7. 数组的常见面试题

  1. 是否包含重复元素 
    import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 3};
        boolean hasDuplicate = false;

        HashSet<Integer> set = new HashSet<>();
        for (int num : arr) {
            if (!set.add(num)) { // 如果元素已存在，add() 返回 false
                hasDuplicate = true;
                break;
            }
        }

        System.out.println("是否包含重复元素：" + hasDuplicate);
    }
}

是否包含重复元素：true
  2. 数组元素顺序反转 
    public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int n = arr.length;

        for (int i = 0; i < n / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[n - 1 - i];
            arr[n - 1 - i] = temp;
        }

        System.out.print("反转后的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

反转后的数组：5 4 3 2 1
  3. 两个有序数组合并成一个有序数组 
    import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = {1, 3, 5};
        int[] arr2 = {2, 4, 6};
        int[] merged = new int[arr1.length + arr2.length];

        int i = 0, j = 0, k = 0;

        while (i < arr1.length && j < arr2.length) {
            if (arr1[i] < arr2[j]) {
                merged[k++] = arr1[i++];
            } else {
                merged[k++] = arr2[j++];
            }
        }

        while (i < arr1.length) {
            merged[k++] = arr1[i++];
        }

        while (j < arr2.length) {
            merged[k++] = arr2[j++];
        }

        System.out.println("合并后的有序数组：" + Arrays.toString(merged));
    }
}


合并后的有序数组：[1, 2, 3, 4, 5, 6]
  4. 找出只出现一次的元素 
    public class Main {
    public static void main(String[] args) {
        int[] arr = {2, 3, 5, 4, 5, 3, 4};
        int result = 0;

        for (int num : arr) {
            result ^= num; // 利用异或运算，重复元素会抵消
        }

        System.out.println("只出现一次的元素是：" + result);
    }
}

只出现一次的元素是：2
  5. 移动数组中的0到末尾 
    public class Main {
    public static void main(String[] args) {
        int[] arr = {0, 1, 0, 3, 12};
        int index = 0; // 用于记录非零元素的插入位置

        for (int num : arr) {
            if (num != 0) {
                arr[index++] = num;
            }
        }

        while (index < arr.length) {
            arr[index++] = 0; // 填充剩余部分为 0
        }

        System.out.print("结果数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

结果数组：1 3 12 0 0
  6. 找到数组中和为目标值的两个数 
    import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        int[] nums = {2, 7, 11, 15};
        int target = 9;

        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                System.out.println("索引：" + map.get(complement) + " 和 " + i);
                return;
            }
            map.put(nums[i], i);
        }
    }
}

索引：0 和 1
avatar
文章
阅读
粉丝