Java学习心得(第三周)

时间：2023-03-13~03-19

地点：湖南文理学院新实验楼d602

讲师：谭sir

大概内容：循环（for和while）、break与continue的使用、随机数函数Random、idea的使用、数组、方法

1. while循环

执行内部循环体的条件为true；结束时条件为false或循环体内执行break代码

while特征：先判断，后执行，可能一次都不会执行

while特征：先执行(至少一次)，后判断

2. for循环

表达式1：初始化循环变量，只执行一次（格式：数据类型 循环变量名 = 值）

表达式2：判断条件是否满足继续执行循环，每次循环都要执行一次（bolean）

表达式3：修改循环变量，每次循环都要执行一次

执行顺序：表达式1-->表达式2（false）-->结束

（true）-->循环体-->表达式3-->表达式2......

for特征：先判断，后执行，可能一次都不会执行

注意：1.循环变量的作用域，默认在for内部有效，在for内部定义的变量其作用域，也仅在for内部生效

2.表达式123都能省，但分号不能省！

3. 循环中止符(break;continue;)

break：中止本次循环，退出switch

continue：跳出本次循环，进入下一次循环

4. Random函数

用于随机数的产生

使用步骤：1.导入Random函数(import java.until.Random;)

2.创建Random

3.调用Random中的方法

产生数 [n,m] ---> r.nextInt(m-n+1)+n;

5. 数组

使用步骤：

1. 声明数组，在内存中开辟一个数组

2. 开辟空间（数组名 = new 数据类型[数组长度]；）

数组在被开辟的同时，java虚拟机会自动根据数据类型赋初始值

合并：数据类型[] 数组名 = new 数据类型[长度]；

3. 给数组添加元素(赋值)-->下标

数组名[小标] = 值；

4. 使用数组元素，通过下标

数组名[下标]；

数组的遍历(通用格式)：

键盘录入数组：

import java.until.Scanner;

public class Test {

public static void main(String[] args) {

// 控制台打印出提示信息

System.out.println("请输入5个数字");

//定义一个数组用来装控制台输入的数字

int a[] = new int[5];

// 循环控制台输入次数，并把输入的数字赋值到数组容器

for (int i=0;i<a.length;i++){

Scanner s = new Scanner(System.in);

a[i] = s.nextInt();

}

}

}

内存分配：

数组元素的插入：

import java.util.Scanner;
public class Demo3 {
    public static void main(String[] args) {
        int[] arr= new int[100];
        arr[0] = 1;
        arr[1] = 4;
        arr[2] = 5;
        arr[3] = 77;
        arr[4] = 88;
        arr[5] = 101;

        Scanner input = new Scanner(System.in);
        System.out.println("请输入插入的元素");
        int num = input.nextInt();
        //1.找位置
        int index = 0; //找的位置
        for (int i = 0; i < arr.length; i++) {
            //如果找到数组后面都是空, 退出循环
            //找到数组第一个比插入的元素大
            if(arr[i] == 0||arr[i] > num){
                index = i;
                break;
            }
        }
        //2.往后移
        for (int i = arr.length-2; i >= index ; i--) {
            arr[i+1] = arr[i];
        }
        //3.插入
        arr[index] = num;

        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == 0){
                break;
            }
            System.out.print(arr[i]+", ");
        }
    }
}

数组元素的删除：

import java.util.Scanner;
public class Demo4 {

    public static void main(String[] args) {
        int[] arr= new int[6];
        arr[0] = 1;
        arr[1] = 4;
        arr[2] = 5;
        arr[3] = 77;
        arr[4] = 88;
        arr[5] = 101;

        Scanner input = new Scanner(System.in);
        System.out.println("请输入要删除的元素");
        int num = input.nextInt();

        //1.找位置
        int index = -1 ;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == 0){
                break;
            }
            if(arr[i] == num){
                index = i;
                break;
            }
        }
        //判断是否找到
        if(index <= -1){ //没有找到
            System.out.println("删除失败,数组中不包含该元素:"+num);
        }else{ //找到
           //删除元素
            //a.先移动元素
            for (int i = index; i < arr.length -1; i++) {
                arr[i] = arr[i+1]; //往前移

                //arr[i+1] = arr[i] //往后移
            }
            //把最后一个元素赋值为默认值
            arr[arr.length -1] = 0;
        }
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == 0){
                break;
            }
            System.out.print(arr[i]+", ");
        }
    }
}

数组的排序(冒泡与选择)：

/**
*冒泡排序
*/
public class Demo6 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7};

        //打印数组
        System.out.println("排序之前:");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+", ");
        }
        //使用冒泡排序,升序
        //控制轮数
        int count = 0;
        boolean flag = true; //排好,为了优化
        for (int i = 1; i <arr.length-1  ; i++) {
            //每一轮比较次数
            for (int j = 0; j <arr.length-i; j++) {
                count++;
                //比较, 如果违反规则,进行交换
                if(arr[j] > arr[j+1]){ //前一个数大于后一个数
                    //进来, 表示肯定没有排好
                    flag = false;//没有排好
                    int temp = arr[j]; //前一个数
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    //加减 异或  乘除
                }
            }

            //如果排好,退出循环
            if(flag){
                break; //退出外层循环
            }

        }

        System.out.println("循环次数:"+count);

        //打印数组
        System.out.println("\n排序之后:");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+", ");
        }
        // 时间复杂度:O(n的平方)  循环次数  最好: O(n)  
    }
}

/*
*选择排序
*/
public class XZ {

    public static void main(String[] args) {
        int[] arr = new int[]{4,11,6,3,10,8,1};
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i; // 用来记录最小值的索引位置，默认值为i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j; // 遍历 i+1~length 的值，找到其中最小值的位置
                }
            }
            // 交换当前索引 i 和最小值索引 minIndex 两处的值
            if (i != minIndex) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
            // 执行完一次循环，当前索引 i 处的值为最小值，直到循环结束即可完成排序
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

6. 二维数组

二维数组：由多个一维数组组成