Java基础（方法和数组）

1.方法

1.1 方法基本格式

权限修饰符 是否静态 返回值类型 方法名 (形式参数列表) {方法体}
核心：形式参数列表， 返回值类型

1.2 方法分类

// 有参数有返回值 (重点)
publicstaticintadd (intnum1 , intnum2){
    returnnum1+num2;
}
// 无参数无返回值
publicstaticvoidtest () {
    System.out.println('无参数无返回值');
}
// 无参数有返回值
publicstaticintgiveMeNumber() {
    return666;
}
// 有参数无返回值
publicstaticvoidprintIntValue(intnum) {
    System.out.println("用户提供的数据："+num);
}

1.3方法案例

1.3.1封装一个方法，返回两个整数里较大的数

    /**
     * 返回调用者提供两个 int 类型数据章较大那个
     * @param num1 用户提供的 int 类型数据
     * @param num2 用户提供的 int 类型数据
     * @return 返回较大的数
     */
    privatestaticintmaxOfNum(intnum1, intnum2) {
        returnnum1>num2?num1 : num2;
    }

1.3.2封装一个方法，返回两个浮点数里较小的数

    /**
     * 返回调用者提供两个 double 类型数据章较小那个
     * @param num1 用户提供的 double 类型数据
     * @param num2 用户提供的 double 类型数据
     * @return 返回较小的数
     */
    privatestaticdoubleminOfNum(doublenum1, doublenum2){
        returnnum1<num2?num1 : num2;
    }

1.3.3封装一个方法，判断一个字符是否是大写字母

    /**
     * 判断字符是否是大写字母
     * @param ch 需要进行判断的 char 类型字符
     * @return 是大写字母返回 true，不是返回 false
     */
    privatestaticbooleanisMyUpper(charch) {
        returnch>='A'&&ch<='Z';
    }

1.3.4封装一个方法，判断一个字符是否是数字字符

   /**
     * 判断字符是否是数字字符
     * @param ch 需要进行判断的 char 类型字符
     * @return 是数字字符返回 true，不是返回 false
     */
    publicstaticbooleanisMyNumber (charch){
        returnch>='0'&&ch<='9';
    }

1.3.5封装一个方法，传入一个字符，如果是大写则转化为小写，否则保持不变

    /**
     * 传入字符是大写字母则转换为小写字母，不是则不变
     * @param ch 用户提供的 char 类型字符
     * @return 返回 char 类型字符
     */
    publicstaticchartoMyLower (charch){
        if(ch>='A'&&ch<='Z'){
            ch+='a'-'A';
        }
        returnch;
    }

1.3.6封装一个方法，实现正整数逆序

    /**
     * 实现逆序操作
     * @param number 用户提供的想要逆序的 int 类型数据
     */
    publicstaticvoidreverse(intnumber) {
        while (number>0 ){
            System.out.print(number%10);
            number/=10;
        }
    }

1.3.7封装一个方法，判断输入年份是否是闰年

    /**
     * 判断是否是闰年
     * @param year 用户输入的年份
     * @return 是闰年返回 true，否则返回 false
     */
    publicstaticbooleanisLeap (intyear) {
        returnyear%4==0&&year%100!=0||year%400==0;
    }

2.数组

2.1 数组解决的问题和尚未解决的问题

数组作为一个最为基础的整体性数据，可用以存储

1. 相同数据

2. 多个数据元素

面临其他问题

1. 数据类型支持不友好

2. 数据容量不可变

3. 数值配套方法少

2.2 数组的基本格式

数据类型[] 数组名 = new 数据类型[容量]

数据类型

明确当前数组存储数据类型，严格要求数据类型一致化

[]

表示当前创建的为数组类型

数组名

1. 操作数组使用的名称，存储当前数组占用内存空间首地址

2. 数组名为引用类型

new

1. 根据当前数据所需，在内存的【堆区】申请所需的内存空间

2. 对当前内存空间中的数据进行擦除操作

数据类型

前后一致，严格遵守数据类型一致化要求

[容量]

1. 在 int 范围内，最大值是 Integer.Max_VALUE - 8

2. 数据容量一旦确定，无法修改

2.3数组案例

2.3.1指定数组最大值下标位置

    /**
     * 获取指定数组中最大值下标位置
     * @param arr 目标 int 类型数组
     * @return 数组中最大值下标位置
     */
    private static int getMaxValueIndex(int[] arr) {
        // 假设最大值在下标为 0 的位置
        int max = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > arr[max]) {
                max = i;
            }
        }
        return max;
    }

2.3.2指定数组最小值下标位置

    /**
     * 找出数组中最小值下标位置
     * @param arr 目标 int 类型数组
     * @return 最小值下标位置
     */
    private static int getMinIndex(int[] arr) {
        // 假设下标为 0 位置是最小值
        int min = 0;
        for (int i = 1; i < arr.length; i++) {
            if(arr[i] < arr[min]){
                min = i;
            }
        }
        return min;
    }

2.3.3指定数组最大值元素个数

      /**
     * 找出数组中最大值数据个数
     * @param arr 指定查询数据的 int 类型数组
     * @return 最大值数据个数
     */
    private static int getMaxValueCount(int[] arr) {
        // count 计数器
        int count = 1;
        // 假设下标为 0 为最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                // 发现当前 max 存储数据不是最大值
                // max 存取较大值，同时 count 重新赋值为 1
                max = arr[i];
                count = 1;
            }else if(max == arr[i]) {
                // max 和当前数组中下标为 i 的元素一致，count 计数
                count ++;
            }
        }
        return count;
    }

2.3.4找出指定元素在在指定数组中第一次出现的下标位置

    /**
     * 在目标数组中，找到数据的第一次下标位置
     * @param arr 用户指定的 int 类型目标数组
     * @param num 用户指定的 int 类型目标数据
     * @return 如果目标存在，返回值大于等于 0，否则返回值为 -1
     */
    private static int indexOf(int[] arr, int num) {
        /*
        index 初始化为 -1
        如果找到目标元素，将目标元素下标赋值给 index ，index 大于等于 0
        如果目标数据未找到， index == -1
         */
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if  (num == arr[i]) {
                index = i;
                break;
            }
        }
        return index;
    }

2.3.5找出指定元素在在指定数组中最后一次出现的下标位置

    /**
     * 在目标数组中找到指定数据最后一次出现的下标位置
     * @param arr 用户指定的 int 类型目标数组
     * @param num 用户指定的 int 类型目标数据
     * @return 如果目标数据存在，返回值大于等于 0 ，否则返回值为 -1
     */
    private static int lastIndexOf(int[] arr, int num) {
        int index = -1;
        for (int i = arr.length -1; i >= 0; i--) {
            if (num == arr[i]) {
                index = i;
                break;
            }
        }
        return index;
    }

2.3.6指定数组内容逆序

    /**
     * 数组内容逆序
     * @param arr 进行逆序操作的数组
     */
    private static void reverse(int[] arr) {
        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
        System.out.println(Arrays.toString(arr));
    }

2.3.7在指定下标位置添加元素

    /**
     * 指定下标位置，添加目标数据
     * @param arr 添加数据的目标数组
     * @param index 指定下标位置
     * @param number 添加数据内容
     * @return 添加操作成功返回 true ，否则返回 false
     */
    private static boolean add(int[] arr, int index, int number) {
        // 判断输入下标是否合法
        if(index < 0 || index > arr.length - 1){
            return false;
        }
        //需要利用循环进行数组元素移动
        for (int i = arr.length - 1; i > index; i--) {
            arr[i] = arr[i - 1];
        }
        // 指定下标位置添加目标元素
        arr[index] = number;
        return true;
    }

2.3.8删除数组中指定下标元素内容

    /**
     * 指定数组中，删除指定下标元素，返回值是被删除的元素数据内容
     * @param arr 删除操作的源数据数组
     * @param index 指定删除的下标位置
     * @return 被删除的数据内容
     */
    private static int remove(int[] arr, int index) {
        if(index < 0 || index > arr.length -1) {
            throw new IllegalArgumentException("输入数据不合法");
        }
        // 【核心】使用一个变量，存储被删除数据内容，以防用户误删数据
        int temp = arr[index];
        // 利用循环移动数据，进行删除才操作，从删除数据下标位置开始，到最后一个有效元素结束
        for (int i = index; i < arr.length - 1; i++) {
            arr[i] = arr[i + 1];
        }
        // 原本数组最后一个有效元素位置默认赋值为 0
        arr[arr.length - 1] = 0;
        return temp;
    }

2.3.9选择排序算法实现

    /**
     * 针对 int 类型数组选择排序算法实现
     * @param arr int[] 类型数组
     */
    private static void selectSort(int[] arr) {
        // 完成排序算法，执行的核心模块次数是当前数组有效元素个数
        for (int i = 0; i < arr.length - 1; i++) {
            // 按照排序规则要求，找极值对应的下标位置
            int index = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[index] < arr[j]) {
                    index = j;
                }
            }
            // 进行数据交换操作，和目标存储极值对应的下标数据进行交换
            if (index != i) {
                int temp = arr[index];
                arr[index] = arr[i];
                arr[i] = temp;
            }
        }
    }

2.3.10冒泡排序算法实现

    /**
     * 针对 int[] 类型数组冒泡排序算法实现
     * @param arr int[] 类型数组
     */
    private static void bobbleSort(int[] arr) {
        for (int i = 0; i < arr.length -1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }