Java语言基础

标识符

标识符是用来命名变量、方法、类等的名称。其中：

1. 首字符必须以字母（A-Z 或 a-z）、下划线_或美元符号$开头。
2. 后续字符可以是字母、下划线_、美元符号$或数字。

Java是区分大小写的，即identifier和Identifier被视为不同的标识符。

不能使用Java的关键字作为标识符。例如，this是关键字，不能用作标识符。

Java关键字如下：

基本数据类型

基本数据类型是 Java 语言操作数据的基础，包括 boolean、char、byte、short、int、long、float 和 double，共 8 种。

注意，变量可以分为局部变量、成员变量和静态变量。

当变量是局部变量时（比如在方法中定义的变量）必须先初始化再使用。否则会报错：The local variable xxx may not have been initialized。

当变量时成员变量或者静态变量时，可以不进行初始化，此时会有默认值，如下所示：

基本数据类型	默认值	大小
boolean	false	1 比特
char	'\u0000'	2 字节
byte	0	1 字节
short	0	2 字节
int	0	4 字节
long	0L	8 字节
float	0.0f	4 字节
double	0.0	8 字节

引用数据类型

引用数据类型在Java中是一种特殊的数据类型，它们存储的是对象的引用地址，而不是对象本身。

1. 引用数据类型： 除了基本数据类型以外的所有类型都属于引用数据类型。这包括数组、类（对象）以及接口。
2. 内存存储： 引用数据类型的变量在内存中存储的是一个引用地址，这个地址指向实际对象的内存地址。
3. 操作对象： 通过引用，我们可以操作对象，调用对象的方法、访问对象的属性等。

包装器类型

包装器类型（Wrapper Types）是Java中一组用于将基本数据类型转换为对象的类。在Java中，基本数据类型（如int、char、boolean等）是不具备对象特性的，但有时候需要在对象上执行操作，这时就需要使用包装器类型。

每个基本数据类型都有对应的包装器类，它们属于java.lang包。以下是基本数据类型及其对应的包装器类型：

• Byte（对应 byte）
• Short（对应 short）
• Integer（对应 int）
• Long（对应 long）
• Float（对应 float）
• Double（对应 double）
• Character（对应 char）
• Boolean（对应 boolean）

这些包装器类型提供了一些额外的功能，例如转换为字符串、解析字符串、比较对象等。

// （1）转换为字符串
Integer intValue = 42;
String stringValue = intValue.toString(); // 将Integer对象转换为字符串
System.out.println("String value: " + stringValue);

// （2）解析字符串
String numberStr = "123";
Integer parsedValue = Integer.valueOf(numberStr); // 将字符串解析为Integer对象
System.out.println("Parsed value: " + parsedValue);

另外，包装器也用于在集合类（如集合框架中的List、Map等）中存储基本数据类型的值，因为集合类只能存储对象。

使用包装器类型可以方便地进行对象操作，但在实际编程中，也可以通过自动装箱（Autoboxing）和自动拆箱（Unboxing）来方便地在基本数据类型和包装器类型之间进行转换。例如：

// 自动装箱
Integer num = 42; // 将int类型自动装箱为Integer对象

// 自动拆箱
int value = num; // 将Integer对象自动拆箱为int类型

总体而言，包装器类型在Java中用于处理基本数据类型与对象之间的转换和操作，提供了更多的灵活性。

运算符

Java的运算符可分为多个类别，包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符，以及三元运算符。

1. 算术运算符：

   • +：加法
   • -：减法
   • *：乘法
   • /：除法
   • %：取模（求余）

   int a = 10, b = 3;
   // 加法
   int sum = a + b; // 13
   // 减法
   int difference = a - b; // 7
   // 乘法
   int product = a * b; // 30
   // 除法
   int quotient = a / b; // 3
   // 取模
   int remainder = a % b; // 1

2. 关系运算符：

   • ==：等于
   • !=：不等于
   • >：大于
   • <：小于
   • >=：大于等于
   • <=：小于等于

   int x = 5, y = 10;
   // 等于
   boolean isEqual = x == y; 	// 结果为 false
   // 不等于
   boolean isNotEqual = x != y; // 结果为 true
   // 大于
   boolean isGreaterThan = x > y; // 结果为 false
   // 小于
   boolean isLessThan = x < y; // 结果为 true

3. 逻辑运算符：

   • &&：逻辑与（AND）
   • ||：逻辑或（OR）
   • !：逻辑非（NOT）

   boolean condition1 = true, condition2 = false;
   // 逻辑与
   boolean resultAnd = condition1 && condition2; // 结果为 false
   // 逻辑或
   boolean resultOr = condition1 || condition2; // 结果为 true
   // 逻辑非
   boolean resultNot = !condition1; // 结果为 false

4. 位运算符：

   • &：按位与
   • |：按位或
   • ^：按位异或
   • ~：按位取反
   • <<：左移
   • >>：右移
   • >>>：无符号右移

   int num1 = 5, num2 = 3;
   // 按位与
   int bitwiseAnd = num1 & num2; // 结果为 1
   // 按位或
   int bitwiseOr = num1 | num2; // 结果为 7
   // 按位异或
   int bitwiseXor = num1 ^ num2; // 结果为 6
   // 按位取反
   int bitwiseNot = ~num1; // 结果为 -6

5. 赋值运算符：

   • =：赋值
   • +=：加法赋值
   • -=：减法赋值
   • *=：乘法赋值
   • /=：除法赋值
   • %=：取模赋值
   • &=：按位与赋值
   • |=：按位或赋值
   • ^=：按位异或赋值
   • <<=：左移赋值
   • >>=：右移赋值
   • >>>=：无符号右移赋值

   int num3 = 10;
   num3 += 5; // 等同于 num3 = num3 + 5;

6. 三元运算符：

   • ? :：条件运算符，根据条件的真假选择不同的值。

   int a = 5, b = 10;
   // 条件运算符
   int result = (a > b) ? a : b; // 结果为 10

流程控制语句

流程控制语句在Java中用于控制程序的执行流程。

1. 简单条件语句（if）:

   int x = 10;
   if (x > 5) {
       System.out.println("x 大于 5");
   }

2. 复合条件语句（if…else）:

   int y = 8;
   if (y % 2 == 0) {
       System.out.println("y 是偶数");
   } else {
       System.out.println("y 是奇数");
   }

3. 开关语句（switch）:

   int dayOfWeek = 2;
   switch (dayOfWeek) {
       case 1:
           System.out.println("星期一");
           break;
       case 2:
           System.out.println("星期二");
           break;
       // 其他情况
       default:
           System.out.println("其他天");
   }

4. 布尔表达式（三元运算符）:

   int a = 5, b = 10;
   int result = (a > b) ? a : b;
   System.out.println("较大的值是：" + result);

5. 循环语句：

   • for循环:

     for (int i = 1; i <= 5; i++) {
         System.out.println("循环次数：" + i);
     }

   • while循环:

     int count = 0;
     while (count < 3) {
         System.out.println("循环次数：" + (count + 1));
         count++;
     }

   • do…while循环:

     int num = 1;
     do {
         System.out.println("循环次数：" + num);
         num++;
     } while (num <= 4);

6. 中止循环（break, continue, return）:

   • break: 用于跳出循环。
   • continue: 用于跳过当前循环的剩余代码，继续下一次循环。
   • return: 用于在方法中返回值并中止方法的执行。

for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        break; // 当 i 等于 3 时跳出循环
    }
    System.out.println("循环次数：" + i);
}

for (int j = 1; j <= 5; j++) {
    if (j == 3) {
        continue; // 当 j 等于 3 时跳过当前循环的剩余代码，继续下一次循环
    }
    System.out.println("循环次数：" + j);
}

public int findNumber(int target) {
    for (int i = 0; i < 10; i++) {
        if (i == target) {
            return i; // 找到目标值时返回并中止方法的执行
        }
    }
    return -1; // 如果未找到目标值，则返回 -1
}

Math

java.lang.Math 类提供了一系列用于数学运算的静态方法和常量。

1. 方法：

   • abs(double d)： 返回参数 d 的绝对值。

     double absoluteValue = Math.abs(-5.67); // 返回 5.67

   • min(double d1, double d2)： 返回参数 d1 和 d2 中的小者。

     double minValue = Math.min(3.14, 2.71); // 返回 2.71

   • max(double d1, double d2)： 返回参数 d1 和 d2 中的大者。

     double maxValue = Math.max(3.14, 2.71); // 返回 3.14

   • sqrt(double d)： 返回参数 d 的平方根。

     double squareRoot = Math.sqrt(9); // 返回 3.0

   • pow(double d1, double d2)： 返回 d1 的 d2 次幂。

     double powerResult = Math.pow(2, 3); // 返回 8.0

   • random()： 返回 [0, 1) 范围内的随机数。

     double randomValue = Math.random(); // 返回 [0, 1) 范围内的随机数

2. 常量：

   • PI： 圆周率 π，类型为 double。

     double piValue = Math.PI; // 圆周率，约 3.141592653589793

   • E： 自然对数的底 e，类型为 double。

     double eValue = Math.E; // 自然对数的底，约 2.718281828459045

String

String 类是 Java 中表示字符串的不可变类，它提供了丰富的方法来处理字符串。由于字符串是不可变的，每次对字符串进行操作都会生成一个新的字符串对象。

1. 创建字符串：

   • 使用字面值创建字符串：

     String str1 = "Hello";

   • 使用构造函数创建字符串：

     String str2 = new String("World");

2. 字符串长度：

   • 使用 length() 方法获取字符串的长度：

     String text = "Hello, World!";
     int length = text.length(); // 返回 13

3. 字符串连接：

   • 使用 + 运算符或 concat() 方法连接字符串：

     String greeting = "Hello";
     String name = "John";
     String message = greeting + ", " + name + "!";
     // 或者
     String concatenatedMessage = greeting.concat(", ").concat(name).concat("!");

4. 提取子串：

   • 使用 substring(int beginIndex) 或 substring(int beginIndex, int endIndex) 提取子串：

     String original = "Java Programming";
     String subString1 = original.substring(5);      // 返回 "Programming"
     String subString2 = original.substring(0, 4);  // 返回 "Java"

5. 查找字符或子串：

   • 使用 indexOf(char ch) 或 indexOf(String str) 查找字符或子串的索引：

     String text = "Hello, World!";
     int indexOfComma = text.indexOf(',');           // 返回 5
     int indexOfWorld = text.indexOf("World");      // 返回 7

6. 替换字符或子串：

   • 使用 replace(char oldChar, char newChar) 或 replace(CharSequence target, CharSequence replacement) 替换字符或子串：

     String original = "Hello, Java!";
     String replaced = original.replace('Java', 'World');  // 返回 "Hello, World!"

7. 转换大小写：

   • 使用 toLowerCase() 或 toUpperCase() 转换大小写：

     String text = "Java Programming";
     String lowercase = text.toLowerCase();  // 返回 "java programming"
     String uppercase = text.toUpperCase();  // 返回 "JAVA PROGRAMMING"

8. 去除首尾空白：

   • 使用 trim() 方法去除字符串首尾的空格：

     String paddedText = "   Trim Me!   ";
     String trimmedText = paddedText.trim();  // 返回 "Trim Me!"

9. 判断字符串相等：

   • 使用 equals() 或 equalsIgnoreCase() 方法判断字符串是否相等：

     String str1 = "Hello";
     String str2 = "hello";
     boolean isEqual = str1.equals(str2);              // 返回 false
     boolean isEqualIgnoreCase = str1.equalsIgnoreCase(str2);  // 返回 true

需要注意的是，由于字符串是不可变的，对字符串的任何修改操作返回的都是一个新的字符串对象。

字符串与其他类型的转换

字符串和数值之间的转换：

• 使用 Integer.parseInt(String str) 将字符串转换为整数。

  String strNumber = "123";
  int intValue = Integer.parseInt(strNumber); // 结果为 123

• 使用 Double.parseDouble(String str) 将字符串转换为双精度浮点数。

  String strDouble = "3.14";
  double doubleValue = Double.parseDouble(strDouble); // 结果为 3.14

• 使用 String.valueOf(类型 value) 将数值转换为字符串。

  int intValue = 42;
  String strValue = String.valueOf(intValue); // 结果为 "42"

• 或者直接使用数值类型的 toString() 方法。

  double doubleValue = 3.14;
  String strDouble = Double.toString(doubleValue); // 结果为 "3.14"

注意！在进行字符串转换为数值时，要确保字符串的格式是合法的数值格式，否则可能会抛出 NumberFormatException。

字符串和字符数组之间的转换：

• 使用 toCharArray() 方法将字符串转换为字符数组。

  String str = "Hello";
  char[] charArray = str.toCharArray(); // 结果为 {'H', 'e', 'l', 'l', 'o'}

• 使用 String(char[] value) 构造函数将字符数组转换为字符串。

  char[] charArray = {'H', 'e', 'l', 'l', 'o'};
  String str = new String(charArray); // 结果为 "Hello"

• 使用 String.valueOf(char[] data) 方法将字符数组转换为字符串。

  char[] charArray = {'H', 'e', 'l', 'l', 'o'};
  String str = String.valueOf(charArray); // 结果为 "Hello"

• 使用 new String(char[] value, int offset, int count) 构造函数可以指定字符数组的子串。

  char[] charArray = {'H', 'e', 'l', 'l', 'o'};
  String str = new String(charArray, 1, 3); // 结果为 "ell"

StringBuffer

StringBuffer 是 Java 中表示可变字符串的类，与 String 不同，StringBuffer 的内容可以动态修改。这种可变性使得 StringBuffer 更适合频繁进行字符串操作的场景。

1. 创建 StringBuffer 对象：

   • 使用无参构造函数创建空的 StringBuffer：

     StringBuffer buffer1 = new StringBuffer();

   • 使用带容量参数的构造函数创建指定容量的 StringBuffer：

     StringBuffer buffer2 = new StringBuffer(20);

   • 使用字符串作为初始值创建 StringBuffer：

     StringBuffer buffer3 = new StringBuffer("Hello");

2. 获取容量和长度：

   • 使用 capacity() 获取 StringBuffer 对象的总容量：

     int totalCapacity = buffer1.capacity();

   • 使用 length() 获取 StringBuffer 对象中字符串的长度：

     int currentLength = buffer1.length();

3. 追加字符串：

   • 使用 append(类型 s) 在字符串末尾追加内容：

     StringBuffer buffer = new StringBuffer("Hello");
     buffer.append(", World!"); // 结果为 "Hello, World!"

4. 插入字符串：

   • 使用 insert(int offset, 类型 s) 在指定位置插入内容：

     StringBuffer buffer = new StringBuffer("Hello");
     buffer.insert(5, ", World!"); // 结果为 "Hello, World!"

5. 删除字符或子串：

   • 使用 deleteCharAt(int index) 删除指定位置的字符：

     StringBuffer buffer = new StringBuffer("Hello, World!");
     buffer.deleteCharAt(5); // 结果为 "HelloWorld!"

   • 使用 delete(int start, int end) 删除指定范围的字符：

     StringBuffer buffer = new StringBuffer("Hello, World!");
     buffer.delete(5, 13); // 结果为 "Hello!"

6. 替换字符或子串：

   • 使用 replace(int start, int end, String str) 替换指定范围的字符串：

     StringBuffer buffer = new StringBuffer("Hello, Java!");
     buffer.replace(7, 11, "World"); // 结果为 "Hello, World!"

7. 反转字符串：

   • 使用 reverse() 方法反转 StringBuffer 中的字符顺序：

     StringBuffer buffer = new StringBuffer("Hello");
     buffer.reverse(); // 结果为 "olleH"

8. 获取子串：

   • 使用 substring(int start) 或 substring(int start, int end) 获取子串：

     StringBuffer buffer = new StringBuffer("Hello, World!");
     String subString1 = buffer.substring(7);      // 返回 "World!"
     String subString2 = buffer.substring(0, 5);  // 返回 "Hello"

9. 转换为 String：

   • 使用 toString() 将 StringBuffer 对象转换为 String 对象：

     StringBuffer buffer = new StringBuffer("Hello");
     String result = buffer.toString();

一维数组

一维数组是一种基本的数据结构，用于存储相同数据类型的元素集合。在 Java 中，一维数组是对象，可以通过索引访问数组中的元素。

1. 数组的声明和初始化：

   • 声明数组：

     // 声明整型数组
     int[] intArray;
     
     // 声明字符串数组
     String[] stringArray;

   • 初始化数组：

     // 初始化整型数组
     intArray = new int[5]; // 创建长度为 5 的整型数组
     
     // 初始化字符串数组
     stringArray = new String[]{"Java", "Python", "C++"};	// 注意，这里不能指定元素个数

2. 访问数组元素：

   • 使用索引访问数组元素，索引从 0 开始：

     int[] numbers = {1, 2, 3, 4, 5};
     int firstElement = numbers[0]; // 获取数组的第一个元素，值为 1

3. 数组的长度：

   • 使用 length 属性获取数组的长度：

     int[] numbers = {1, 2, 3, 4, 5};
     int arrayLength = numbers.length; // 获取数组的长度，值为 5

4. 遍历数组：

   • 使用循环遍历数组中的所有元素：

     int[] numbers = {1, 2, 3, 4, 5};
     for (int i = 0; i < numbers.length; i++) {
         System.out.println(numbers[i]);
     }

   • 使用增强型 for 循环（for-each）遍历数组：

     int[] numbers = {1, 2, 3, 4, 5};
     for (int num : numbers) {
         System.out.println(num);
     }

5. 数组的初始化方式：

   • 动态初始化： 在声明数组的同时为其分配空间并指定长度。

     int[] dynamicArray = new int[3];

   • 静态初始化： 在声明数组的同时为其指定元素值。

     int[] staticArray = {1, 2, 3};

6. 多维数组：

   • 一维数组的元素可以是另一个一维数组，形成多维数组。

     int[][] twoDArray = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};	// 二维数组

7. 数组的注意事项：

   • 数组的索引越界：访问不存在的索引会导致 ArrayIndexOutOfBoundsException。
   • 数组的长度不可变：一旦数组被创建，其长度不可改变。

Arrays

Arrays 类是 Java 中用于操作数组的工具类，它提供了一系列静态方法，用于对数组进行排序、搜索、比较等操作。Arrays 类中的方法都是静态方法，直接通过类名调用即可。

以下是 Arrays 类的一些常用方法：

1. 数组排序：

   • 使用 sort(类型[] array) 方法对数组进行升序排序。对于对象数组，要求元素类型实现 Comparable 接口。

     int[] numbers = {5, 2, 8, 1, 7};
     Arrays.sort(numbers); // 结果为 {1, 2, 5, 7, 8}

   • 使用 sort(类型[] array, Comparator<? super 类型> comparator) 方法进行自定义排序，要求提供一个比较器。

     String[] names = {"John", "Alice", "Bob", "Charlie"};
     Arrays.sort(names, Comparator.reverseOrder()); // 结果为 {"John", "Charlie", "Bob", "Alice"}

2. 数组搜索：

   • 使用 binarySearch(类型[] array, 类型 key) 方法在有序数组中进行二分查找。对于对象数组，要求元素类型实现 Comparable 接口。

     int[] numbers = {1, 2, 5, 7, 8};
     int index = Arrays.binarySearch(numbers, 5); // 结果为 2

   • 使用 binarySearch(类型[] array, int fromIndex, int toIndex, 类型 key) 在指定范围内进行二分查找。

     int[] numbers = {1, 2, 5, 7, 8};
     int index = Arrays.binarySearch(numbers, 0, 3, 5); // 结果为 -3

3. 数组填充：

   • 使用 fill(类型[] array, 类型 value) 方法将数组的所有元素填充为指定值。

     int[] numbers = new int[5];
     Arrays.fill(numbers, 42); // 结果为 {42, 42, 42, 42, 42}

   • 使用 fill(类型[] array, int fromIndex, int toIndex, 类型 value) 在指定范围内填充数组元素。

     int[] numbers = new int[5];
     Arrays.fill(numbers, 1, 4, 42); // 结果为 {0, 42, 42, 42, 0}

4. 数组复制：

   • 使用 copyOf(类型[] original, int newLength) 方法复制数组的一部分。

     int[] source = {1, 2, 3, 4, 5};
     int[] destination = Arrays.copyOf(source, 3); // 结果为 {1, 2, 3}

   • 使用 copyOfRange(类型[] original, int from, int to) 复制数组的指定范围。

     int[] source = {1, 2, 3, 4, 5};
     int[] destination = Arrays.copyOfRange(source, 1, 4); // 结果为 {2, 3, 4}

5. 数组比较：

   • 使用 equals(类型[] a, 类型[] b) 方法比较两个数组是否相等。

     int[] arr1 = {1, 2, 3};
     int[] arr2 = {1, 2, 3};
     boolean isEqual = Arrays.equals(arr1, arr2); // 结果为 true

   • 使用 deepEquals(Object[] a1, Object[] a2) 方法递归比较两个对象数组是否相等。

     int[][] arr1 = {{1, 2}, {3, 4}};
     int[][] arr2 = {{1, 2}, {3, 4}};
     boolean isEqual = Arrays.deepEquals(arr1, arr2); // 结果为 true

二维数组

二维数组是一种特殊的数组，它可以看作是数组的数组。在 Java 中，二维数组是一个由行和列组成的表格状数据结构。

以下是关于二维数组的一些基本概念和操作：

1. 定义和初始化：

   • 定义二维数组的语法如下：

     // 数据类型[][] 数组名 = new 数据类型[行数][列数];
     int[][] matrix = new int[3][4]; // 3行4列的二维数组

   • 初始化二维数组时，可以同时指定元素的值：

     int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

2. 访问元素：

   • 通过指定行和列的索引访问二维数组的元素：

     int value = matrix[1][2]; // 访问第2行第3列的元素，结果为 6

3. 遍历二维数组：

   • 使用嵌套循环遍历二维数组的所有元素：

     for (int i = 0; i < matrix.length; i++) {
         for (int j = 0; j < matrix[i].length; j++) {
             System.out.print(matrix[i][j] + " ");
         }
         System.out.println(); // 换行
     }

4. 获取行数和列数：

   • 使用 length 属性获取二维数组的行数和列数：

     int rows = matrix.length;    // 获取行数，结果为 3
     int columns = matrix[0].length; // 获取列数，结果为 3

5. 不规则二维数组：

   • 二维数组的各行可以有不同的长度，创建不规则二维数组时，只需指定每行的长度即可：

     int[][] irregularMatrix = {{1, 2, 3}, {4, 5}, {6, 7, 8, 9}};

6. 使用 Arrays 类操作二维数组：

   • 使用 Arrays.deepToString(Object[] array) 方法可以方便地将二维数组转换为字符串，便于输出和调试：

     System.out.println(Arrays.deepToString(matrix));

   • 使用 Arrays.copyOf 或 Arrays.copyOfRange 可以复制部分或全部二维数组：

     int[][] copyMatrix = Arrays.copyOf(matrix, matrix.length);
     int[][] subMatrix = Arrays.copyOfRange(matrix, 0, 2);

   • 使用 Arrays.fill(类型[] array, 类型 value) 可以为二维数组的所有元素赋相同的值。