一、switch

注意： 不加break会穿透，如果满足条件1但是没有break，会执行语句2而不会去判断条件2

switch细节

switch和if的比较

二、for循环

三、while循环

四要素：
1、循环变量初始化
2、循环条件
3、循环体
4、循环变量迭代

四、do while循环

四要素：
1、循环变量初始化
2、循环体
3、循环变量迭代
4、循环条件

五、多重循环控制（重难点）

案例–九九乘法表

  /*
         * 1*1
         * 1*2 2*2
         * 1*3 2*3 3*3
         * */
         //i控制行，j控制列，同时观察发现式子都是 列*行
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + " * " + i + " = " + (j * i) + "\t");
            }
            System.out.println("");
        }
1
2
3
4
5
6
7
8
9
10
11
12

案例–金字塔（实心）

 /*           		  *       1行1个*  4个" "
         *           ***      2行3个*  3个" "
         *          *****     3行5个*  2个" "
         *         *******    4行7个*  1个" "
         *        *********   5行9个*  0个" "
         * */
        for (int i = 1; i <= 5; i++) {
            //控制空格
            for (int j = 1; j <= 5 - i; j++) {
                System.out.print(" ");
            }
            //控制*
            for (int k = 1; k <= 2 * i - 1; k++) {
                System.out.print("*");
            }
            System.out.println("");
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

案例–金字塔（空心）

   @Test
    public void f3() {
        /*            *       1行1个*  4个" "  0个" "
         *           * *      2行3个*  3个" "  1个" "
         *          *   *     3行5个*  2个" "  3个" "
         *         *     *    4行7个*  1个" "  5个" "
         *        *********   5行9个*  0个" "  0个" "
         * */

        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= 5 - i; j++) {
                System.out.print(" ");
            }
            for (int j = 1; j <= 2 * i - 1; j++) {
                if (j == 1 || j == 2 * i - 1 || i == 5) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            System.out.println("");
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

案例–空心菱形

@Test
    public void f4() {
        int n = 7;
        //    *    第1行2个* 3个空格 6
        //   * *   第2行2个* 2个空格 5
        //  *   *  第3行2个* 1个空格 4
        // *     * 第4行2个* 0个空格 3
        //  *   *  第5行2个* 1个空格 2
        //   * *   第6行2个* 2个空格 1
        //    *    第7行1个* 3个空格 0

        for (int i = 1; i <= n; i++) {
            if (i <= n / 2 + 1) {
                for (int j = n / 2; j >= i; j--) {
                    System.out.print(" ");
                }
                for (int k = 1; k <= 2 * i - 1; k++) {
                    if (k == 1 || k == 2 * i - 1) {
                        System.out.print("*");
                    } else {
                        System.out.print(" ");
                    }
                }
            } else {
                for (int j = n - i; j < n / 2; j++) {
                    System.out.print(" ");
                }
                for (int k = 1; k <= 2 * (n - i) + 1; k++) {
                    if (k == 1 || k == 2 * (n - i) + 1) {
                        System.out.print("*");
                    } else {
                        System.out.print(" ");
                    }
                }
            }
            System.out.println("");
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

五、break和continue

break

break可以用来跳出循环，也可以通过标签指明要终止的是哪一层的语句块

continue

六、数组

定义数组

1、动态初始化

int[] arr = new int[5];
1

2、先声明数组再new

int [] arr;//声明数组，还没有分配内存空间
arr = new int[5];//分配了空间
1
2

3、静态初始化

int [] arr = {1,2,3,4};
1

使用数组的注意事项：

数组赋值机制

1. 基本数据类型的赋值是值传递，即值拷贝
2. 引用数据类型的赋值是引用/地址传递，即拷贝的是地址，在栈中存放地址名称，实际地址空间在堆中。
   

数组拷贝

//方法1、把数组a中的值一一赋复制给b
//方法2、int [] b = a.clone();
1
2

数组反转

//方法一：
        int[] a = {11, 22, 33, 44, 55, 66, 77};
        int temp = 0;
        for (int i = 0; i < a.length / 2; i++) {
            temp = a[i];
            a[i] = a[a.length - i - 1];
            a[a.length - i - 1] = temp;
        }
        for (int i : a) {
            System.out.print(i + " ");
        }
//方法二：新建一个数组，把第一个数组中的数逆序遍历并赋值给第二个数组，最后把第二个数组指向第一个数组
1
2
3
4
5
6
7
8
9
10
11
12

数组扩容

        Scanner scanner = new Scanner(System.in);
        int[] arr = {1, 2, 3};
        while (true) {
            System.out.println("是否继续添加？");
            String ans = scanner.next();
            if (ans.equals("y")) {
                System.out.println("请输入添加的数字：");
                int num = scanner.nextInt();
                int[] arr2 = new int[arr.length + 1];
                for (int i = 0; i < arr.length; i++) {
                    arr2[i] = arr[i];
                }
                arr2[arr.length] = num;
                arr = arr2;
            } else {
                break;
            }
        }
        for (int i : arr) {
            System.out.print(i + " ");
        }
```# 排序
## 排序分类
1. 内部排序：在内存中进行排序
2. 外部排序：数据量太大，在堆中进行排序

## 冒泡排序
思路：相邻元素进行比较，把大的元素排到后面
```java
        int[] arr = {3, 5, 1, -7, 4, 9, -6, 8, 10, 4};
        int temp = 0;
        boolean flag;//用来标识是否进行元素交换
        for (int i = 0; i < arr.length - 1; i++) {
            flag = true;//true代表不发生交换
            for (int j = 0; j < arr.length - 1 - i; j++) {//排序到后面几轮的时候，后面的元素是有序的，所以排序次数越来越少
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = false;//不发生交换说明排序完毕
                }
            }
            if (flag) {
             //在arr[j]与arr[j + 1]比较时没有发生交换说明已经排完了，对于i没有必要在排了
                break;
            }
        }
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

七、查找

分类

1. 顺序查找：和数组中的元素一一对比
2. 二分查找：首先要求数组有序，要查的数每次和中间的数进行对比，然后范围减半
   …
   具体数据结构再说吧

八、二维数组

定义

1、动态初始化

int [][] arr = new int [5][3];//可以看作五行三列
int [][] arr;//先声明再开空间 
arr = new int[2][3];
//列数不确定时
int[][] arr = new int[2][];
        for (int i = 0; i < arr.length; i++ {// 要给每个一维数组开空间，否则就是{null,null}
            arr[i] = new int[2];//{{0,0},{0,0}}
        }

1
2
3
4
5
6
7
8
9

2、静态初始化

int [][] arr={{23,145,132,230,108},{2,21,225,139,13},{104,8,3,24,26}};//3行5列
int [][] arr2 = {{3,2,1},{2},{2,3}};//3行多列
1
2

二维数组的内存布局

注意：数组是引用/地址传递

杨辉三角

//自己偶然发现的一种方法,应该是最简单的方法了吧哈哈
/*
  		1
        1	1
        1	2	1
        1	3	3	1
        1	4	6	4	1
        1	5	10	10	5	1
        1	6	15	20	15	6	1
        1	7	21	35	35	21	7	1
        1	8	28	56	70	56	28	8	1
        */
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入行数：");
        int row = scanner.nextInt();
        int[][] arr = new int[row][];
        for (int i = 0; i < arr.length; i++) {
        	//初始化
            arr[i] = new int[i + 1];
            arr[i][0] = 1;
            arr[i][i] = 1;
            for (int j = 1; j < i; j++) {
               //使用j使第2行开始，每行的下标为j的元素为上面的元素及它左边元素之和
               arr[i][i - j] = arr[i - 1][i - j - 1] + arr[i - 1][i - j];
            }
        }
        for (int[] i : arr) {
            for (int j : i) {
                System.out.print(j + "\t");
            }
            System.out.println("");
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

细节

练习

注意这种声明方式

此博客主要为韩顺平老师java课程的笔记总结，详细内容可以去b站看韩老师的相关课程