java复习第五天

第五天复习

1、break和continue关键字的使用

①break可以用在循环结构和switch-case结构中，而continue只能用在循环结构中

②break的作用是跳出当前整个循环，continue是跳出当前循环的本次循环，开始下一次循环

③如果有多层循环，想要跳出外层循环可以为循环起标识符，用break或continue+:标识符；跳出循环

2、数组

定义：长度不可变，内容可以变得存储同一数据类型的一种容器，数组本身是引用数据类型，其元素

类型可以是基本数据类型也可以是引用数据类型

格式: 数据类型[] 标识符=new 数据类型[]{元素1，…元素n}；

数据类型[] 标识符={元素1，…元素n}；

数据类型[] 标识符=new 数据类型[整数]；

长度在定义时会直接指定，元素有默认值

直接输出数组名得到的是数组的地址值（见案例一）

数组的应用

①获取数组的元素

数组名[下标]；

②赋值或修改数组数据

数组[下标]=数据；

③数组的长度

int a=数组名.length

④数组的遍历

a.通过for或者while循环遍历（见案例二）

b.增强for循环

for（声明变量：数组名）{

循环体；

}

c.通过API Arrays.toString（数组名）方法遍历数组

⑤查找数组的最大 最小元素和下标（见案例三）

⑥反转数组（两种方式）（见案例四）

⑦数组的排序（见案例五）

a.选择排序

b.冒泡排序

c.Arrays.sort方法排序

⑧数组的查找（见案例六）

a.循环遍历查找

b.二分法查找（前提是有序数组

⑨数组的复制

通过System.arrayCopy(原数组名，开始下标，数组名，存放开始的下标，复制的个数)

⑩数组的扩容

Arrays.copyOf(数组名，扩容后数组的长度)

3、二位数组

定义：用来保存多个一维数组的容器

格式：数据类型[][] 标识符=new 数据类型[整数1][整数2]；

整数1:一维数组的个数

整数2：一维数组中元素的个数

其中整数1必须要有，而整数二可以根据情况不写

长度：

一维数组的个数：数组名.length

每个一维数组的元素个数：数组名[下标].length

遍历二维数组

通过双层for循环遍历二维数组

public class Day05 {
    public static void main(String[] args) {
//    定义一维数组
        int[] arr;
        arr = new int[]{1, 3, 4, 9, 8, 2};
//     案例一: 直接输出数组名得到的是数组的地址值
        System.out.println(arr);//结果是[[email protected]

//        案例二：遍历数组
//        a.通过for或者while循环遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
//        b.通过增强for循环遍历
//        增强for循环无法更改数组内的元素
        for (int a : arr) {
            System.out.println(a);
        }
//        c.Arrays.toString 遍历数组  以字符串形式[1, 3, 4, 9, 8, 2]
        System.out.println(Arrays.toString(arr));


//      案例三：  查找数组的最大 最小元素和下标
//        a.查找数组的最大 最小值
//        将第一个元素赋值给max
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
//            从下标1的元素和max比较，始终把较大的值赋值给max
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        System.out.println(max);

//         第二种做法通过下标来找最大值
        int maxIndex = arr[0];
        for (int i = 1; i < arr.length; i++) {
//            得到最大值的下标
            if (arr[maxIndex] < arr[i]) {
                maxIndex = i;
            }
        }
//        输出最大值的下标和最大值
        System.out.println(maxIndex);
        System.out.println(arr[maxIndex]);
        //最小值同理最大值的方法

//       案例四：反转数组（两种方法）
//          第一种通过创建新数组的方式
        int[] arr1 = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arr1[i] = arr[arr.length - i - 1];
        }
        arr = arr1;
        System.out.println(Arrays.toString(arr));

//        第二种不用创建新数组
        for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
            int temp = arr[end];
            arr[end] = arr[start];
            arr[start] = temp;

        }
        System.out.println(Arrays.toString(arr));


//       案例五：数组的排序
//        a.选择排序（通过两两比较每一轮确定最小值）
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));

        int[] arr2 = {1, 3, 7, 5, 4, 2, 9};
//        b.冒泡排序（通过相邻的两个数两两比较，每一轮确定最大值）
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i; j++) {
                if (arr2[j] > arr2[j + 1]) {
                    int temp = arr2[j];
                    arr2[j] = arr2[j + 1];
                    arr2[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr2));


//        案例六:数组元素的查找
//        a.通过遍历数组查找
        int[] arr3 = {1, 5, 98, 65, 35, 4, 5, 11, 65};
        int k = 65;
//        定义一个flag用于记录数组是否存在该元素
        boolean flag = false;
        for (int i = 0; i < arr3.length; i++) {
            if (k == arr3[i]) {
//                如果存在输出元素下标
                System.out.println(k + "在数组中的下标为:" + i);
                flag = true;
            }
        }
        if (!flag) {
            System.out.println("数组中不存在该值");
        }


//        b.通过二分法来查找元素（前提该数组为有序数组）
        int[] arr4 = {1, 3, 5, 7, 9, 16, 23, 99, 156};
        int m = 99;
        int maxID = arr4.length - 1;
        int minID = 0;
        int midID = (minID + maxID) / 2;
        boolean flag1 = false;
        while (m != arr4[midID]) {
            if (m > arr4[midID]) {
                minID = midID + 1;
            } else {
                maxID = midID - 1;
            }
            if (minID > maxID) {
                flag1 = true;
                break;
            }
            midID = (minID + maxID) / 2;

        }
        if (flag1) {
            System.out.println("数组中没有" + m);
        } else {
            System.out.println(midID);
        }

    }
}