数组的使用

数组在方法中的使用【熟练】

数组排序【重点】

Arrays工具类

二维数组【了解】

引用类型的深入理解【理解】

复习

取值的语法：

​ 数据类型 变量名 = 数组名[下标];

赋值的语法:

​ 数组名[下标] = 值;

数组的遍历:

​ for(int i = 0;i < arr.length;i++) {

 int e = arr[i]; 	

​ }

例题：

4. 在一个数组中，找出所有的指定数据的下标位置并返回 【难】
   [1,2,8,4,5,7,8,7,8,9]
   // 简化: 找到指定元素的所有下标,输出

package com.qf.homework;

public class Homework {

	public static void main(String[] args) {
		
		// 返回的返回值是数组,接收也需要使用数组
		int[] arr = getAllIndexByElement(7);
		System.out.println("元素7的所有下标");
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		
	}
	// 在一个数组中，找出所有的指定数据的下标位置并返回
	/*
	 * 1 需要返回多个下标,需要使用数组来返回数据
	 *   所以,方法的返回值类型指定为int[]
	 * 2 用来装下标的数组的长度?
	 * 	 跟原数组长度一样.
	 * 3 再创建一个数组,长度是找到下标的个数
	 *   然后进行数组拷贝
	 */
	public static int[] getAllIndexByElement(int e) {
		int[] arr = {1,2,8,4,5,7,8,7,8,9};
		
		// 创建一个数组,用来存储所有的下标
		int[] indexArr = new int[arr.length];
		// 声明一个初始的下标
		int index = 0;
		
		for (int i = 0; i < arr.length; i++) {
			if (e == arr[i]) {
				indexArr[index] = i;
				index++;
			}
		}
		// 新建一个数组
		int[] retArr = new int[index];
		// 拷贝数组
		for (int i = 0; i < retArr.length; i++) {
			// 将之前数组的元素取出,赋值给新的数组
			retArr[i] = indexArr[i];
		}
		return retArr;
	}	
}

数组在方法中的使用【重要】

1以当做方法的返回值

因为方法的定义,返回值类型是各种数据类型;java的数据类型有两大类,基本类型和引用类型.引用类型中有数组,类,接口.

public static 返回值数据类型 方法名(){}	
例如
public static int[] findIndex(){
    return null;// 因为数组是引用类型,引用类型默认值都是null
    // null意味着在内存没有创建对象
}

2数组可以当做方法的参数

方法的定义

public static void 方法名(数据类型 参数名) {}
例如
public static void 方法名(int[] arr) {}

数组排序【重点】

1冒泡排序

package com.qf.array;

public class Demo3 {

	public static void main(String[] args) {
		
		int[] arr = {9,6,8,5,4,5,10,7,3,8,2,1};
		// 排序前,遍历
		foreach(arr);
		
		// 排序
		sort(arr);
		
		// 排序后,遍历
		foreach(arr);
	}

	public static void sort(int[]  arr) {
		// 外层循环控制趟数(-1,目的是少一趟比较)
		for(int i = 0;i < arr.length-1;i++) {
			// 内层循环控制比较的次数(-i,目的是减少每次比较的次数)
			for(int j = 0;j < arr.length-1-i;j++) {
				if (arr[j] > arr[j+1]) {
					int temp = arr[j+1];
					arr[j+1] = arr[j];
					arr[j] = temp;
				}
			}
		}
	}
	public static void foreach(int[] arr) {
		String result = "[";
		for(int i = 0;i < arr.length;i++) {
			result += arr[i];
			if (i != arr.length -1) {
				result += ",";
			} else {
				result += "]";
			}
		}
		System.out.println(result);
	}
}

总结: 冒泡排序会有很多次的元素交换位置

2选择排序

package com.qf.array;

public class Demo4 {


	public static void main(String[] args) {
		int[] arr = {9,6,8,5,4,5,10,7,3,8,2,1};
		foreach(arr);
		
		selectionSort(arr);
		
		foreach(arr);
		
		
	}
	
	public static void selectionSort(int[] arr) {
		for(int i = 0;i < arr.length-1;i++) {
			
			// 假设当前位置值最小
			int minIndex = i;
			// 循环一趟,找到最小值的下标
			for (int j = i+1;j < arr.length;j++) {
				if (arr[j] < arr[minIndex]) {
					minIndex = j;
				}
			}
			
			// 开始换位
			int temp = arr[minIndex];
			arr[minIndex] = arr[i];
			arr[i] = temp;
		}
	}
	
	public static void foreach(int[] arr) {
		String result = "[";
		for(int i = 0;i < arr.length;i++) {
			result += arr[i];
			if (i != arr.length -1) {
				result += ",";
			} else {
				result += "]";
			}
		}
		System.out.println(result);
	}	
}

Arrays工具类

Arrays是Java提供的一个操作数组的工具类.提供了很多方法操作数组,常用的有两个:

toString()

sort()

---

特殊的,Arrays类是工具类,其中的方法是通过类名.方法名()直接调用

例如: Arrays.toString(), Arrays.sort()

ps: 暂时不用深入研究为什么这么调用,后续讲完面向对象才能理解

1 toString()

该方法是Arrays类提供的一个方法,用来将数组的元素以字符串返回

import java.util.Arrays;	

	int[] arr = {9,6,8,5,4,5,10,7,3,8,2,1};
		
		// 将数组以字符串形式返回
		String line = Arrays.toString(arr);
		System.out.println(line);

2 sort

将数组排序.只能进行升序排序.

public static void main(String[] args) {
		
		int[] arr = {9,6,8,5,4,5,10,7,3,8,2,1};
		
		// 将数组以字符串形式返回
		String line = Arrays.toString(arr);
		System.out.println(line);
		
		// 升序排序
		Arrays.sort(arr);
		
		// 遍历
		System.out.println(Arrays.toString(arr));
	}

引用类型的理解【理解】

java的数据类型: 基本类型和引用类型.

引用类型: 数组,类,接口

---

基本类的值传递和引用类型的值传递

5.1 演示:值传递

package com.qf.array;

public class Demo6 {

	public static void main(String[] args) {
		int a = 1;
		System.out.println("1 a = " + a); // 1
		
		changeBasicValue(a); // 基本类型,是指传递,只是将1赋值给变量a
		
		System.out.println("4 a = " + a); // 1
	}

	// 改变基本类型变量的值
	/*
	 * 基本类型是进行值传递
	 * ----------------
	 * 方法执行会进栈,方法执行完会弹栈
	 */
	public static void changeBasicValue(int a) {// a是值1
		System.out.println("2 a = " + a); // 1
		a = a * 10;
		System.out.println("3 a = " + a); // 10
	}
}

栈结构: 先进后出

方法执行先进栈,执行完后弹栈

引用传递

package com.qf.array;

import java.util.Arrays;

public class Demo6 {

	public static void main(String[] args) {
		int[] arr = { 4, 2, 1, 3, 5 };
		System.out.println("1 " + Arrays.toString(arr));
		changeArray(arr); // 参数赋值,传递是地址值,即是引用
		System.out.println("4 " + Arrays.toString(arr));
	}

	/*
	 * 数组是引用类型,引用类型是引用传递
	 * ---------------------------
	 * 凡是new对象,都会在堆中创建对象
	 * 对对象得出操作,对所有方法都生效
	 */
	public static void changeArray(int[] arr) {// 是数组的地址
		System.out.println("2 " + Arrays.toString(arr));
		for (int i = 0; i < arr.length - 1; i++) {

			// 假设当前位置值最小
			int minIndex = i;
			// 循环一趟,找到最小值的下标
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[j] < arr[minIndex]) {
					minIndex = j;
				}
			}

			// 开始换位
			int temp = arr[minIndex];
			arr[minIndex] = arr[i];
			arr[i] = temp;
		}
		System.out.println("3 " + Arrays.toString(arr));
		
	}

	// 改变基本类型变量的值
	/*
	 * 基本类型是进行值传递 ---------------- 方法执行会进栈,方法执行完会弹栈
	 */
	public static void changeBasicValue(int a) {
		System.out.println("2 a = " + a); // 1
		a = a * 10;
		System.out.println("3 a = " + a); // 10
	}
}

重要:凡是new对象,都会在堆中创建对象