1. 算术运算符

用于进行基本的数学运算，包括加法、减法、乘法、除法、取模等。不会改变数据类型。

示例：

int m1 = 10;
m1 += 5;  // 等价于 m1 = m1 + 5
System.out.println(m1);  // 输出15

注意：避免使用逻辑不清的代码，尽量保持表达式简洁明了。

2. 比较运算符

用于比较两个值的大小，结果为true或false。

image (27)

注意：==和!=也可以用于引用数据类型，比较的是内存地址是否相同。

3. 逻辑运算符

用于布尔值之间的逻辑操作。

image (29)
image (28)

4. 位运算符

直接操作二进制位。

示例：

int result = 2 << 3;  // 2*8，结果为16

image (30)

5. 条件运算符（三元运算符）

用于简化if-else语句 (条件表达式) ? 表达式1 : 表达式2

示例：

int m = 10;
int n = 20;
int max = (m > n) ? m : n;
System.out.println("较大值为：" + max);  // 输出 "较大值为：20"

应用示例：今天是周二，10天以后是周几

int week = 2;
week += 10;
week %= 7;
System.out.println((week == 0) ? "日" : week);

image (31)

6. 赋值运算符

将右边的值赋给左边的变量。

示例：

int m1 = 10;
m1 += 5;  // 等价于 m1 = m1 + 5

image (25)

image (26)

7. 运算符优先级

运算符有不同的优先级，优先级高的运算符在表达式中先执行。以下是优先级列表（从高到低）：

优先级 运算符说明 Java运算符
1 括号 ()、[]、{}
2 正负号 +、-
3 单元运算符 ++、--、~、!
4 乘法、除法、求余 *、/、%
5 加法、减法 +、-
6 移位运算符 <<、>>、>>>
7 关系运算符 <、<=、>=、>、instanceof
8 等价运算符 ==、!=
9 按位与 &
10 按位异或 ^
11 按位或 `
12 条件与 &&
13 条件或 `
14 三元运算符 ? :
15 赋值运算符 =、+=、-=、*=、/=、%=
16 位赋值运算符 &=、`

开发建议：

  1. 尽量不要过度依赖运算符优先级，建议使用()来控制表达式的执行顺序，确保代码清晰。
  2. 避免过于复杂的表达式，如果表达式复杂，建议分步计算以提高可读性。

image (32)

Java 流程控制语句

Java 支持顺序结构、分支结构和循环结构，允许程序根据条件执行特定的代码段或重复执行代码。

1. 顺序结构

顺序结构是按代码从上到下顺序执行。

2. 分支结构

Java 提供 if-else 和 switch-case 来控制分支结构。

3. 循环结构

Java 中有三种循环结构：for、while 和 do-while。

image (53)

示例代码和注意事项

示例1：判断 if-else 输出

int x = 4;
int y = 1;
if (x > 2) {
    if (y > 2) 
        System.out.println(x + y);
    System.out.println("atguigu"); // 输出 "atguigu"
} else {
    System.out.println("x is " + x);
}

说明：System.out.println(x + y); 受 if (y > 2) 控制，而 System.out.println("atguigu"); 不受影响。

示例2：赋值和比较的差别

boolean b = true;
if(b = false) // 赋值表达式，不是条件比较
    System.out.println("a");
else if(b)
    System.out.println("b"); // 输出 "b"

if-else 示例：判断输入的正负数

Scanner input = new Scanner(System.in);
int num = input.nextInt();
if (num > 0) {
    System.out.println(num + "是正整数");
} else if (num < 0) {
    System.out.println(num + "是负整数");
} else {
    System.out.println(num + "是零");
}
input.close();

switch-case 示例：星期的英文单词

Scanner input = new Scanner(System.in);
int weekday = input.nextInt();
switch(weekday) {
    case 1: System.out.println("Monday"); break;
    case 2: System.out.println("Tuesday"); break;
    // ...
    default: System.out.println("输入有误！");
}
input.close();

转换字符为大写

char word = 'c';
switch (word) {
    case 'a': System.out.println("A"); break;
    case 'b': System.out.println("B"); break;
    case 'c': System.out.println("C"); break;
    // ...
    default: System.out.println("other");
}

其他小技巧

Java 流程控制补充说明

1. 分支结构的注意事项

2. switch-case 语句的补充

image (37)
image (40)

image (41)

image (38)

3. 循环结构的补充

4. 运算符与数据类型

image (34)

5. 特殊字符转义

image (35)

6.如何获取一个随机数

1.可以使用java提供的api:Math random();
double d1 = Math.random();
调用后会返回一个0.0-1.0的值

7. (int)(Math.random()*101);

//注意括号 如果int运算random会一直输出0
image (36)

8.布尔类型不能与其它类型做运算

9.break 和 continue

image (42)

在 Java 中，可以使用 label 标签配合 break 和 continue 控制多层嵌套循环的跳出或继续。通过标签指定，可以控制跳出指定的循环层，或继续执行外层的循环。

10.使用 label 和 break

break label; 直接跳出指定标签的循环。

outerLoop: // 定义标签
for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
        if (i == 2 && j == 2) {
            break outerLoop; // 跳出outerLoop标签的循环
        }
        System.out.println("i=" + i + ", j=" + j);
    }
}
// 输出到 i=2, j=1 为止

使用 label 和 continue

continue label; 直接跳过指定标签的当前循环，继续下一次循环。

outerLoop:
for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
        if (j == 2) {
            continue outerLoop; // 跳过 outerLoop 循环的当前迭代
        }
        System.out.println("i=" + i + ", j=" + j);
    }
}
// 输出会跳过每一行中 j=2 的情况

image (43)

Java 数组相关概念

image (44)

1. 基本概念

2. 数组特点

image (45)

image (46)

3. 一维数组的使用

image (47)

4. 数组越界问题

5. 数组的长度

6. 数组遍历

7. 数组元素的默认值

8. 二维数组

image (49)

image (48)

9. 数组赋值

10. 数组常用算法

11. 常见操作

12. 排序算法分类

继续深入 Java 数组的使用与相关算法

13. 数组的反转

数组反转是将数组中元素的顺序进行颠倒的过程，常用的方法是使用一个临时变量来交换元素。以下是实现数组反转的示例代码：

public class ArrayReverse {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        reverseArray(arr);
        
        // 输出反转后的数组
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }

    public static void reverseArray(int[] array) {
        int left = 0;
        int right = array.length - 1;
        while (left < right) {
            // 交换元素
            int temp = array[left];
            array[left] = array[right];
            array[right] = temp;

            left++;
            right--;
        }
    }
}

14. 数组的扩容与缩容

在 Java 中，数组的大小一旦定义后就不能改变。如果需要改变数组的大小，通常的方法是创建一个新的数组，并将原数组的元素复制到新数组中。以下是扩容的示例：

public class ArrayResize {
    public static void main(String[] args) {
        int[] originalArray = {1, 2, 3};
        int[] newArray = resizeArray(originalArray, 5);

        // 输出扩容后的数组
        for (int num : newArray) {
            System.out.print(num + " ");
        }
    }

    public static int[] resizeArray(int[] oldArray, int newSize) {
        int[] newArray = new int[newSize];
        for (int i = 0; i < oldArray.length && i < newArray.length; i++) {
            newArray[i] = oldArray[i];
        }
        return newArray;
    }
}

15. 数组元素的查找

public class SequentialSearch {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};
        int target = 30;
        int index = sequentialSearch(arr, target);

        if (index != -1) {
            System.out.println("Element found at index: " + index);
        } else {
            System.out.println("Element not found.");
        }
    }

    public static int sequentialSearch(int[] array, int target) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == target) {
                return i; // 返回找到的下标
            }
        }
        return -1; // 返回 -1 表示未找到
    }
}
public class BinarySearch {
    public static void main(String[] args) {
        int[] sortedArray = {10, 20, 30, 40, 50};
        int target = 30;
        int index = binarySearch(sortedArray, target);

        if (index != -1) {
            System.out.println("Element found at index: " + index);
        } else {
            System.out.println("Element not found.");
        }
    }

    public static int binarySearch(int[] array, int target) {
        int left = 0;
        int right = array.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2; // 防止溢出
            if (array[mid] == target) {
                return mid; // 找到目标元素
            } else if (array[mid] < target) {
                left = mid + 1; // 目标在右半边
            } else {
                right = mid - 1; // 目标在左半边
            }
        }
        return -1; // 返回 -1 表示未找到
    }
}

16. 数组的排序算法

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 4, 2};
        bubbleSort(arr);

        // 输出排序后的数组
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }

    public static void bubbleSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    // 交换
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}
public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 4, 2};
        selectionSort(arr);

        // 输出排序后的数组
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }

    public static void selectionSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j; // 找到最小元素的索引
                }
            }
            // 交换
            int temp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = temp;
        }
    }
}

17. 衡量算法优劣

image (51)
image (52)

Java 数组的常见异常

在 Java 中，操作数组时可能会遇到各种异常。以下是一些常见的数组异常及其描述：

  1. ArrayIndexOutOfBoundsException：

    • 描述：当尝试访问数组的索引超出其有效范围时，抛出此异常。例如，访问一个长度为 5 的数组的第 6 个元素（索引为 5）。
    • 示例：
    int[] array = new int[5];
System.out.println(array[5]); // 会抛出 ArrayIndexOutOfBoundsException

  2. NullPointerException：

    • 描述：当尝试在未初始化的数组上执行操作时，抛出此异常。例如，尝试访问或修改一个尚未被分配内存空间的数组的元素。
    • 示例：
    int[] array = null;
System.out.println(array[0]); // 会抛出 NullPointerException

  3. NegativeArraySizeException：

    • 描述：当创建数组时，如果指定的数组大小为负数，会抛出此异常。
    • 示例：
    int[] array = new int[-1]; // 会抛出 NegativeArraySizeException

  4. ArrayStoreException：

    • 描述：当尝试将不兼容类型的元素赋值给数组时，会抛出此异常。例如，尝试将一个 String 对象赋值给一个 Integer 类型的数组。
    • 示例：
    Integer[] array = new Integer[10];
array[0] = "Hello"; // 会抛出 ArrayStoreException

  5. ClassCastException：

    • 描述：当尝试将一个对象强制转换为不兼容的类型时，抛出此异常。虽然这通常不是数组特有的，但在处理多维数组或数组的数组时可能会遇到。
    • 示例：
    Object[] objects = new Object[10];
objects[0] = new Integer(1);
String str = (String) objects[0]; // 会抛出 ClassCastException

  6. IllegalArgumentException：

    • 描述：当传递给方法的参数不合法时，可能会抛出此异常。虽然不是专门针对数组的，但在使用数组作为参数的方法中可能会遇到。
    • 示例：
    public void processArray(int[] array) {
    if (array == null) {
        throw new IllegalArgumentException("Array cannot be null");
    }
}

数组的概念与使用

数组可以理解为多个数据的组合，是程序中的一种容器，用于存储同一类型的数据。

1. 一维数组的使用（重要）

2. 一维数组的内存解析（难点）

3. 二维数组的使用（难点）