数组操作

数组操作

1.数组地址转移问题

public static void main(String[] args) {
    int[] arr1 = new int[10];
    int[] arr2 = new int[10];
    
    arr1[0] = 10;
    arr2[0] = 20;
    
    System.out.println("arr1[0]:" + arr1[0]);
    System.out.println("arr2[0]:" + arr2[0]);
    
    arr1[5] = 50;
    
    arr2 = arr1;
    
    arr1[0] = 30;
    arr2[0] = 100;
    
    System.out.println("arr1[0]:" + arr1[0]);
    System.out.println("arr2[0]:" + arr2[0]);
    System.out.println("arr2[5]:" + arr2[5]);
    /*
     结果  100 100 50 
     */

arr2 = arr1
这行代码将arr1在堆区空间里的的地址值给arr2使得两个数组指向了堆区里的同一个地方
即arr1 和 arr2 执行的空间为同一个数组空间

2.数组作为方法的参数

public static void main(String[] args) {

}

/*
(String[] args) 
	String[] args 就是给数组作为方法参数格式，这里main方法需要的参数是一个String 类型的数组

格式：
	public static 返回值类型 方法名(数据类型[] 数组参数名)

*/

3.方法实现与文档注释

/**
*  例1
* 在指定数组arr中，查询指定元素find所在的下标位置，找到返回值大于等于0，没有找到
* 返回-1
*
* @param arr  查询数据的源数据数组，int类型数组
* @param find 指定在数组中查询的数据，也是对应int类型
* @return 找到指定元素，返回值大于等于0，否则返回-1
*/
public static int indexOf(int[] arr, int find) {
    // 假设查询的数据不存在
    int index = -1;
    
    // 遍历整个数组
    for (int i = 0; i < arr.length; i++) {
        // 发现数组中下标为i的元素和find一致，找到内容，保存下标
        if (find == arr[i]) {
            index = i;
            // 终止循环
        	break;
        }
    }
    
    // 返回index中保存的数据
    return index;
}

4.总结

1. 数组作为方法参数的固定格式
	(数据类型[] 数组参数名)
2. 数组作为方法的实际参数的固定格式
	(数组名)
3. 数组名作为方法的参数，实际传递的是数组空间首地址，就是和数组地址转移问题是一致的
4. 方法执行需要参数，如果没有给予对应格式的实际参数，直接报错

5.练习

/*
需求:
    逆序数组
	存在一个int类型数组，使用方法逆序数组中的元素
	例如：
		int[] arr = 
		{1, 2, 3, 4, 5};
		执行之后
		{5, 4, 3, 2, 1};

方法分析：
	固定格式:
		public static 不要问
	返回值类型:
		void 
	方法名:
		reverse
	形式参数列表:
		int[] arr 这里需要一个int类型数组
		
方法声明：
	public staitc void reverse(int[] arr)
*/

/**
* 数组逆序
*
* @param arr 需要被逆序的int类型数组
*/
public staitc void reverse(int[] arr) {
    for (int i = 0; i < arr.length / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[arr.length - 1 - i];
        arr[arr.length - 1 - i] = temp;
        /*
        前提:
        	{11, 13, 25, 68, 90};
        1.
         i = 0;
         temp = arr[0]; temp ==> 11
         arr[0] = arr[arr.length - 1 - i]; arr[4] ==> 90 arr[0] = 90
         arr[arr.length - 1 - i] ==> arr[4] = 11;
        2 
         i = 1;
         temp = arr[1] temp = 13
         arr[1] = arr[5 - 1 - 1]; arr[1]  = 68 arr[3] = 68
         arr[3] = temp; arr[3] ==> 13
        */
    }
}
class Demo5 {
	public static void main(String[] args) {
		int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
		
		System.out.print("方法调用之前：");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		reverse(arr);
		
		System.out.print("方法调用之后：");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}
	
	/**
	* 数组逆序
	*
	* @param arr 需要被逆序的int类型数组
	*/
	public static void reverse(int[] arr) {
		for (int i = 0; i < arr.length / 2; i++) {
			int temp = arr[i];
			arr[i] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = temp;
		}
	}
}