Java基础0.9_java中0.9类型-CSDN博客

本文链接：https://blog.csdn.net/singerDog/article/details/101670343

数组练习

public class Demo1 {
	punlic static void main(String[] args) {
		int[] array = {1,3,5,7,9,11,13}
		maxIndexInArray(array);
	}
	/*
    1. 定义一个方法，可以找出指定int类型数组中最大值下标位置

    方法分析：
        方法名:
            maxIndexInArray
        形式参数列表：
            这里需要一个int类型的数组 int[] array
        返回值类型:
            这里希望得到的是最大值下标，所有返回值类型是下标范围，就是int类型
            public static int maxIndexInArray(int[] array)
       */
       public static int maxIndexInArray(int[] array) {
        // 1. 假设下标为0的数据时最大值
			int maxIndex = 0;
		 /*
          2. 利用循环进行两两比较，并且数据比较从1开始
         */
			for(i=1;i<=array.leangh;i++) {
		// 3. 判断下标为maxIndex元素如果小于下标为 i的元素，保存下标 i的maxIndex去
				if(array[maxIndex] < array[i]) {
					maxIndex = i;
				}
		  }
		  return maxIndex;
	}
       /*
       2. 定义一个方法，可以找出指定int类型数组中最小值下标位置
       方法分析：
          方法名:
             minIndexInArray
          形式参数列表：
             这里需要一个int类型的数组 int[] array
          返回值类型:
              这里希望得到的是最小值下标，所有返回值类型是下标范围，就是int类型
         public static int minIndexInArray(int[] arra)
        */
      /**
        * 找出指定数组中最小下标的元素
        * @param array 指定的int类型数组
        * @return 当前数组中最小值的下标位置
      */
      public static int minIndexInArray(int[] arra) {
			int minIndex = 0;
			for(i = 1; i <= array.length; i++) {
				if(array[minIndex] > array[i]) {
					minIndex = i;
				}
			}
			return minIndex;
	}
	/*
	3. 定义一个方法，在指定int类型数组中，找出指定int类型数据所在的下标位置
	找到返回值下标值: 0 ~ arr.length - 1
	找不到返回 -1
	方法分析:
    	方法名:
        	indexOf
    形式参数列表:
        第一个: 需要一个 int类型的数据 int[] array
        第二个: 确定需要查询的数据， int    int find
    返回值类型：
            int类型，找到返回值大于等于0，没有找到返回-1
    public static int indexOf(int[] array, int find)
*/

/**
 * 找出指定数据在指定数组中下标位置，找到返回值大于等0，没有找到返回-1
 * @param array 查询数据的数组 int类型数组
 * @param find 查询的指定数据 int类型数据
 * @return 找到返回值大于等0，没有找到返回-1
 */
  public static int indexOf(int[] array, int find) {
  		//假设涨不到数据
  		int index = -1;
  		// 2. 利用循环，两两比较，找出指定数据在数组中下标位置，并且保存到index变量中
  		for(int i = 0; i <array.length; i++) {
  		// 3. 下标为 i的元素就是指定 find数据，你们保存 下标 i到 index变量中
  			if(array[i] == array[find]) {
  				index = i;
  				 // 如果找到数据，终止循环！！！break;
  				 break;
  			}
  		}
  		return index;
  }
}

数组算法示例

public class FindAllInArray {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9};
        int[] indexes = new int[arr.length];

        int count = findAllIndexes(arr, indexes, 5);
        System.out.println(count);

        for (int i = 0; i < count; i++) {
            System.out.println(indexes[i]);
        }
    }

    /*
    4. 在一个数组中，找出所有指定数据的下标位置 【难】
    方法分析:
        方法名:
            findAllIndexes 找出所有指定元素的下标位置
        形式参数列表：
            1. 哪一个数组中进行查询操作！！！ int[] arr
            2. 要查询的数据 int find
            3. 需要另外的一个数组，保存找到的下标位置
                a) 该数组是什么是就类型??? int类型数组
                b) 该数组的容量应该是什么???
                    和需要查询的目标数组容量是一致的！！！
        返回值类型；
            不考虑使用数组作为返回值，这里存在一定的隐患】
            boolean: 运行成功返回true，运行失败返回false
            int: ???
                返回找到的数据有多少个

        public static int findAllIndexes(int[] arr, int[] indexes, int find)
    */

    /**
     * 找出数组中指定元素 find在目标数组 arr的下标位置，并且保存到 indexes 数组中
     * 返回值是找到的元素个数，没有找到，返回 0
     * @param arr 查询数据目标数组，int类型
     * @param indexes 保存找到数据下标位置的数组，int类型
     * @param find 需要查询的数据，int类型
     * @return 返回值找到的元素个数，没有找到，返回 0
     */
    public static int findAllIndexes(int[] arr, int[] indexes, int find) {
        // 1. 参数合法性判断
        if (null == arr || null == indexes || arr.length == 0
                || indexes.length == 0 || indexes.length < arr.length) {
            System.out.println("Input parameter is invalid!");
            // 返回 0。结束方法，表示没有找到
            return 0;
        }

        // 2. 定义一个变量，计数
        int count = 0;

        // 3. 使用 for循环，遍历目标数组 arr，使用 if判断，找到目标元素
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == find) {
                /*
                a. 计数 count++ 
                b. 把找到的下标位置放到 indexes数组中
                第一次找到:
                    需要存放到下标为 0的位置，count++ count自增之前是 0
                第二次找到：
                    需要存放到下标为 1的位置，count++ count自增之前是 1

                indexes是存放下标位置的数组，count是计数有多少个目标数据
                i是找到的下标位置
                count同时可以表示当前 indexes数组中的有效元素个数
                 */
                indexes[count++] = i;
            }
        }

        return count;
    }
}

public class ArrayReplace {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 0, 0, 0, 0, 0};

        boolean ret = replace(array, 10);
        System.out.println(ret);
        System.out.println(Arrays.toString(array));
    }

    /*
    5. 完成一个方法，替换掉数组中所有元素之为0的元素，替换为指定元素
    方法分析:
        方法名:
            replace
        形式参数列表：
            需要替换数据的int类型数据
            需要指定的元素 int类型
            (int[] array, int newNumber)
        返回值类型：
            不推荐使用void，使用void作为返回值的方法，是一个黑盒方法！！！
            给予当前方法一个状态的监控！！！
            boolean 方法运行成功返回true，失败返回一个false
            这玩意能失败???
                1. 如果数组的容量为0？？？ 会失败！！！
                2. 数组名是一个引用数据类型，其中保存的内存地址不能为 null 会失败！！！

        public static boolean replace(int[] array, int newNumber)
    */

    /**
     * 替换指定数据中元素为 0的值，替换为 newNumber
     * @param array int类型数组
     * @param newNumber 替换的int类型数组
     * @return 方法运行成功返回 true，方法运行失败，返回 false
     */
    public static boolean replace(int[] array, int newNumber) {
        // 1. 参数合法性判断！！！
        if (null == array || array.length == 0) {
            System.out.println("输入参数不合法！！！");
            // 输入参数不合法，返回 false 告知调用者，方法执行失败！！！
            return false;
        }

        for (int i = 0; i < array.length; i++) {
            if (0 == array[i]) {
                array[i] = newNumber;
            }
        }

        return true;
    }

public class ArrayRemove {
    public static void main(String[] args) {
        int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};

        remove(array, 0);
        System.out.println(Arrays.toString(array));
    }

    /*
    6. 完成一个方法，删除指定下标的元素，要求从删除位置开始，之后的元素整体前移。【难】
    要求源数据数组是
        int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
        删除之后，需要在数组的末尾补0，0是无效元素
    方法分析:
        方法名:
            remove / delete
        形式参数列表：
            1. 删除数据的目标数组 int[] arr
            2. 指定删除数据的下标位置 int index
        返回值类型:
            boolean 删除成功返回true，失败返回false
            什么情况下会失败:
                a) 数组容量为0
                b) 数组中保存的地址为 null
                c) 给予的删除下标是一个非法下标
        public static boolean remove(int[] arr, int index)
    */

    /**
     * 在指定数组中，删除指定下标 index上的元素。
     * @param arr 指定的 int类型数组
     * @param index 指定的删除数据的下标，但是不能超出数组的有效下标范围 0 ~ arr.length - 1
     * @return 删除操作成功返回 true，失败返回 false
     */
    public static boolean remove(int[] arr, int index) {
        // 1. 参数合法性判断
        if (null == arr || arr.length == 0 || index < 0 || index > arr.length -1 ) {
            System.out.println("Input parameter is invalid!");
            return false;
        }

        /*
         2. 使用 for循环完成操作
         这里使用 arr[i] = arr[i + 1];
        */
        for (int i = index; i < arr.length - 1; i++) {
            arr[i] = arr[i + 1];
            /*
            index = 5; arr.length = 10;
            arr[5] = arr[6]; i++ == 6
            arr[6] = arr[7]; i++ == 7
            arr[7] = arr[8]; i++ == 8
            arr[8] = arr[9]; i++ == 9
            arr[9] = arr[10]; ArrayIndexOutOfBoundsException
             */
        }

        arr[arr.length - 1] = 0;

        return true;
    }


```java
public class ArrayInsert {
    public static void main(String[] args) {
        int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};

        add(array, 20, 30);

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

    /*
    7. 完成一个方法，添加指定元素到指定下标位置，要求从指定下标位置之后的元素，整体向后移动。【难】
    要求源数据数组是
        int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
        0是无效元素，表示目前数组存在一个空位置
    方法分析:
        方法名：
            add
        形式参数列表:
            1. 数组 int[] arr
            2. 指定下标位置 int index
            3. 添加的数据  int number
        返回值类型：
            boolean 成功返回true，失败返回false
            什么情况下会失败:
                a) 数组容量为0
                b) 数组中保存的地址为 null
                c) 给予的删除下标是一个非法下标

        public static boolean add(int[] arr, int index, int number)
    */

    /**
     * 在数组中指定位置，添加指定元素
     *
     * @param arr    指定的操作的数据，为 int类型
     * @param index  指定的下标位置，必须是在数组的有效下标范围以内 0 ~ 数组容量 - 1
     * @param number 添加的数据，为 int类型
     * @return 添加成功返回 true ，失败返回 false
     */
    public static boolean add(int[] arr, int index, int number) {
        // 1. 参数合法性判断
        if (null == arr || arr.length == 0 || index < 0 || index > arr.length - 1) {
            System.out.println("Input parameter is invalid!");
            return false;
        }

        // 2. 利用循环移动数组中的元素，从最后一位开始
        for (int i = arr.length - 1; i > index; i--) {
            arr[i] = arr[i - 1];
            /*
            index = 5; arr.length = 10;
            arr[9] = arr[8]; i-- == 8
            arr[8] = arr[7]; i-- == 7
            arr[7] = arr[6]; i-- == 6
            arr[6] = arr[5]; i-- == 5
             */
        }

        arr[index] = number;

        return true;
    }