0424数组练习

0424数组操作

重点

数组作为参数进行传递格式：
    方法调用时仅仅在方法中调用数组名即可
    方法定义时需完整定义：int[] arr
class Demo5 {
	public static void main(String[] args) {
		int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
		reverse(arr);
	}


	public static void reverse(int[] arr) {
	}

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]);
    /*
    1. 报错
    2. 30 30 50 
    3. 100 100 50 true
    4. 30 100 50
    5. 50 100 50
    6. 30 100 0
    */
}

问题总结:
	1. 
    int[] arr1 = new int[20];
    int[] arr2 = new int[10];
    
    arr1 = arr2;
    
    arr1[15] ???; 错误的 
    arr1 和 arr2 执行的空间为同一个数组空间

	2. 
	int[] arr1 = new int[10];
	int[] arr2 = new int[10];
	
	arr1[0] = 10;
	arr2[0] = 20;
	arr2[5] = 100;
	
	arr1[0] = arr2[0];
	
	arr1[0] ? 
	arr1[5] ?
	20, 0
	赋值操作完成的是对于元素直接内容的转换，不涉及数组地址转移
	
    3.
    是否可以展示数组中 arr[0] arr[5]元素的空间首地址
    不好意思，不能！！！

2. 数组作为方法的参数

2.1 还是比葫芦画瓢

​ 【使用数组作为返回值---慎用！！！】

public static void main(String[] args) {

}

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

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

2.2 数组作为参数分析过程

/*
a. 在一个int类型数组中，存储的内容是1 ~ 10
	int[] arr = {10, 8, 35, 67, 31, 25, 11, 30, 28, 99};
	使用代码找出，元素 == 30 所在下标位置
	
	找出元素30对应的下标位置
		1. 这里需要利用循环遍历数组，查询操作
		2. 查询结果不确定，有可能找到，有可能找不到
		3. 在查询之前我们假设对应的数据时不存在的
			-1 作为保存目标数据的初始值

方法分析：
	固定格式:
    	public static 不要问
    返回值类型:
    	void: 
    		没有返回值，功能变成数据找到直接打印，没有返回到方法外，这是一个黑盒
    		方法。黑盒方法是数据传入之后，没有任何的返回
    	int:
    		返回指定元素的下标位置，没有找到返回-1
   	方法名:
   		indexOf 
   		获取指定元素对应下标
   	形式参数列表:
   		int[] arr:
   			查询数据的源数组，在哪一个数组中进行查询操作,这里需要一个int类型数组
   		int find:
   			指定在数组中查询的元素
   		(int[] arr, int find)
   
方法声明:
	public static int indexOf(int[] arr, int find)
*/

2.3 方法实现和文档注释

/**
* 在指定数组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;
}

2.4 方法验证和传参方式

class Demo2 {
	public static void main(String[] args) {
		int[] array = {10, 8, 35, 67, 31, 25, 11, 30, 28, 99};
		int find = 13;
		
		// 调用的方法需要数组作为方法的参数，
		// 这里传入【数组名】
		int index = indexOf(array, find);
		
		if (index >= 0) {
			System.out.println("index : " + index);
		} else {
			System.out.println("Not Found!");
		}
	}	
	
	/**
	* 在指定数组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;
	}
}

2.5 方法运行内存图【难点】

2.6 总结

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

2.7 练习

2.7.1 保存数据到数组中

/*
需求
	完成一个方法，给int类型数组保存的元素进行赋值操作，所有元素内容全部赋值为100

方法分析:
	固定格式:
		public static 不要问
	返回值类型:
		void 没有返回值
	方法名:
		assignIntArray
		赋值int类型数组
	形式参数列表:	
		int[] arr 这里需要一个int类型数组

方法声明:
	public static void assignIntArray(int[] arr)
*/

/**
* 传入一个int类型数组，把当前int类型数组中所有的元素全部赋值为100
*
* @param arr int类型数组
*/
public static void assignIntArray(int[] arr) {
    // 利用循环遍历数组，循环赋值操作
    for (int i = 0; i < arr.length; i++) {
        arr[i] = 100;
    }
}

class Demo3 {
	public static void main(String[] args) {
		int[] intArray = new int[10];
		
		System.out.print("方法调用之前：");
		for (int i = 0; i < intArray.length; i++) {
			System.out.print(intArray[i] + " ");
		}
		
		System.out.println();
		
		assignIntArray(intArray);
		
		System.out.print("方法调用之后：");
		for (int i = 0; i < intArray.length; i++) {
			System.out.print(intArray[i] + " ");
		}
		
		System.out.println();
	}
	
	/**
	* 传入一个int类型数组，把当前int类型数组中所有的元素全部赋值为100
	*
	* @param arr int类型数组
	*/
	public static void assignIntArray(int[] arr) {
		// 利用循环遍历数组，循环赋值操作
		for (int i = 0; i < arr.length; i++) {
			arr[i] = 100;
		}
	}
}

2.7.2 使用A数据，替换指定数组中B数据

/*
需求:
	使用A数据，替换指定数组中B数据
	例如:
		原始数据:
		int[] arr = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
		替换所有元素值 == 5 ==> 100
		结果 Result
		int[] arr = {1, 2, 3, 4, 100, 1, 2, 3, 4, 100}

方法分析:
	固定格式:
		public static 不要问
	返回值类型:
		void 没有返回值
	方法名:
		replace 替换
	形式参数列表:
		这里需要三个参数:
			a. 指定的数组 int[] arr
			b. A数据 int newNum
			c. B数据 int oldNum
			(int[] arr, int oldNum, int newNum);

方法声明:
	public static void replace(int[] arr, int oldNum, int newNum)
*/

/**
* 使用newNum数据替换指定数组arr中，oldNum数据
*
* @param arr    指定的int类型数据
* @param oldNum 需要被替换的数据，int类型
* @param newNum 替换使用的新数据，int类型
*/ 
public static void replace(int[] arr, int oldNum, int newNum) {
    for (int i = 0; i < arr.length; i++) {
        if (oldNum == arr[i]) {
            arr[i] = newNum;
        }
    }
}

class Demo4 {
	public static void main(String[] args) {
		int[] arr = {1, 11, 111, 1111, 11111, 1, 11, 111, 1111, 11111};
		
		System.out.print("方法调用之前：");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		replace(arr, 11, 22222);
		
		System.out.print("方法调用之后：");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}
	
	/**
	* 使用newNum数据替换指定数组arr中，oldNum数据
	*
	* @param arr    指定的int类型数据
	* @param oldNum 需要被替换的数据，int类型
	* @param newNum 替换使用的新数据，int类型
	*/ 
	public static void replace(int[] arr, int oldNum, int newNum) {
		for (int i = 0; i < arr.length; i++) {
			if (oldNum == arr[i]) {
				arr[i] = newNum;
			}
		}
	}
}

2.7.3 逆序数组

/*
需求:
	存在一个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;
		}
	}
}