2021年7月22日

讲师：王博

Id：10.8.159.99

昨日回顾

方法的声明

无参数无返回值：public static void 方法名（）{}

无参数有返回值：public static 数据类型 方法名（）{}

有参数无返回值：public static void 方法名（数据类型 形参）{}

有参数有返回值：public static 数据类型 方法名(数据类型 形参){}

Break:终止的作用

Continue：跳出当前循环，继续下一次的循环

数组的声明：int [] arr = new int[8];

Int [] arr1 = {1,2,3,4};

Int [] arr2 = new int[] {4,5,6,7,8};

数组：

赋值

取值

今日内容

1. 定义一个方法，找出int数组中最大值的索引下标
2. 定义一个方法，找出int数组中最小值的索引下标
3. 定义一个方法，找出数组中指定元素的下标
4. 在一个数组中，找出所有指定数据的下标位置【*】
5. 替换数组中数据为0的元素，使用指定的元素进行替换
6. 删除指定下标的元素，要求从删除的位置开始，之后的元素前移一位
7. 添加指定的元素，到指定的位置，后面的元素整体后移一位
8. 冒泡排序
9. 选择排序
10. 找出数组中最大的元素，放到下标为0的位置
11. 在上一道题的基础上，不考虑下标为0的元素，找出数组中最大的元素，放倒下标为1的位置

定义一个方法，找出int数组中最大值的索引下标

package com.liujinghe.app;

/**
 * 封装方法的写法
 * 返回int类型数组最大值下标
 */
public class Demo2 {
    public static void main(String[] args) {
        int[] arr = {2, 4, 5, 665, 4, 665, 66};
        //问题：如果数组有两个最大值，怎么把两个最大值的索引打印
        int i = maxIndexArray(arr);
        System.out.println("最大值的索引" + i);
    }

    /**
     * 方法的分析
     * 方法的名字 maxIndexArray
     * 形参：一个int类型的数组
     * 返回值：int类型
     *
     * @param arr
     * @return
     */
    public static int maxIndexArray(int[] arr) {
        int maxIndex = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] >= arr[maxIndex]) {
                maxIndex = i;
            }
        }
        return maxIndex;

    }
}

 

定义一个方法，找出int数组中最小值的索引下标

package com.liujinghe.app;

/**
 * 2.定义一个方法，找出int数组中最小值的索引下标
 */
public class Demo3 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        int i = minIndexArray(arr);
        System.out.println("最小值的索引为：" + i);
    }

    /**
     * 方法分析
     * 方法名：minIndexArray
     * 形参：int 类型数组
     * 返回值：int类型
     */
    public static int minIndexArray(int[] arr) {
        //假设最小值的索引为0
        int minIndex = 0;
        for (int i = 1; i < arr.length; i++) {
            /**
             * [1,2,3,4,5,6]
             * i=1 1<6 true arr[1]<=arr[0] false i++
             * i=2 2<6 true arr[2]<=arr[0] false i++
             * i=3 3<6 true arr[3]<=arr[0] false i++
             * i=4 4<6 true arr[4]<=arr[0] false i++
             * i=5 5<6 true arr[5]<=arr[0] false i++
             * i=6 <6 false 循环结束
             */
            if (arr[i] <= arr[minIndex]) {
                minIndex = i;
            }
        }
        return minIndex;
    }
}

 

定义一个方法，找出数组中指定元素的下标

package com.liujinghe.app;

public class Demo6 {
    //定义一个方法，找出数组中指定元素的下标
    public static void main(String[] args) {
        int [] arr = {1,2,3,4,5,6};
        int i = indexOf(arr, 3);
        System.out.println("查找元素的索引为："+i);
    }
    /**
     * 方法分析
     *  方法的名字：indexOf
     *  方法的参数：int类型数组，int类型数据
     *  返回值：int
     */
    public static int indexOf(int [] arr,int find){
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == find){
                index = i;
                //数据找到，结束循环
                break;
            }
        }
        return index;
    }
}

 

在一个数组中，找出所有指定数据的下标位置【*】

{1,2,3,1,2,3,1,2,3}

1 索引 0,3,6

package com.liujinghe.app;

import java.lang.reflect.Array;

public class Demo8 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,1,2,3,1,2,3};
        int[] indexex = new int[arr.length];
        int[] allIndexes = findAllIndexes(arr, 2, indexex);
        for (int i = 0; i < allIndexes.length; i++) {
            System.out.print(allIndexes[i]+",");
        }

    }
    /**
     * 方法的分析
     *  方法的名字：findAllIndexes
     *  参数：
     *      int类型数组
     *      int类型数据
     *      int类型数组，一个空的数组来接收找到的索引值
     *  返回值：int类型数组
     */
    public static int[] findAllIndexes(int [] arr,int find,int[] indexes){
        //判断参数的合法性
        if(arr == null ){
            System.out.println("参数不合法");
            return new int[]{-1};
        }
        //定义一个变量进行计数
        int count = 0;
        //使用for循环进行查找
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == find){
                indexes[count++] = i;
            }
        }
        return indexes;
    }
}

 

替换数组中数据为0的元素，使用指定的元素进行替换

package com.liujinghe.app;

import java.util.Arrays;

public class Demo10 {
    public static void main(String[] args) {
        int [] arr = {1,2,3,0,0,0,0,0,0,0,0};
        boolean replace = replace(arr, 89);
        System.out.println(replace);
        System.out.println(Arrays.toString(arr));
    }
    //
    //替换数组中数据为0的元素，使用指定的元素进行替换
    //
    /**
     * 方法分析
     *  方法名字：replace
     *  形式参数
     *      第一个参数：int类型数组
     *      第二个参数：替换的数值int
     *   返回值
     *      布尔类型数据
     */
    public static boolean replace(int [] arr,int newNumber){
        //1.参数的合法性
        if(arr == null){
            System.out.println("参数不合法，数组不能为空");
            return false;
        }
        //2.使用for循环进行替换
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == 0){
                arr[i] = newNumber;
            }
        }
        return true;

    }
}

 

删除指定下标的元素，要求从删除的位置开始，之后的元素前移一位

 

添加指定的元素，到指定的位置，后面的元素整体后移一位

 

冒泡排序

 

选择排序

 

找出数组中最大的元素，放到下标为0的位置

package com.liujinghe.app;

import java.util.Arrays;

//找出数组中最大的元素，放到下标为0的位置
public class Demo8 {
    public static void main(String[] args) {
        int [] arr = {1,3,4,5,78,56};
        int index=0;
        //找最大值的下标
        for (int i = 0; i < arr.length; i++) {
            if(arr[index]<arr[i]){
                index = i;
            }
        }
        System.out.println(index);
        //交换位置
        if(index != 0){
            int temp=arr[index];
            arr[index] = arr[0];
            arr[0] =temp;
        }
        System.out.println(Arrays.toString(arr));
    }
}

 

在上一道题的基础上，不考虑下标为0的元素，找出数组中最大的元素，放倒下标为1的位置