数组知识点整理

数组引入

定义

• 数组是同类型的有序的数据集合
• 数组长度一旦确定就不能改变
• 数组类型可以是任何类型，包括基本型和引用型

数组的声明

数组的声明有两种方式

type[] arr_name; //（推荐使用这种方式）
type arr_name[];

注意数组声明并没有创建对象，只有在实例化数组时，JVM才会分配空间。所以申明一个数组时，数组并没有被真正的创建，需要指定数组长度。

数组的初始化

静态初始化

直接赋值定义

int[] num = { 1, 2, 3 };// 静态初始化基本类型数组；
Man[] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组；

动态初始化

声明数组并指定长度后通过下标为数组元素赋值

int[] num = new int[2];//动态初始化数组，先分配空间；
num[0]=1;//给数组元素赋值；
num[1]=2;//给数组元素赋值；

数组默认初始化

数组是引用类型的变量，它的元素相当于实例变量，因此在数组在分配空间时就会默认为元素赋值。int类型默认值为0；布尔类型默认值是false；字符串等引用类型默认值是null

数组遍历

for循环遍历

通过for循环实现数组元素下标递增，实现对数组的遍历。
注意，数组下标是从 0 到 length-1

foreach加强循环遍历

如下：

String[] ss = { "aa", "bbb", "ccc", "ddd" };
        for (String temp : ss) {
            System.out.println(temp);
        }

打印数组

手写打印数组的代码

public static String arrayToString(int[] arr) {
		String result = "";
		result += "[";
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				// 如果是最后一个元素,拼接数据
				result += arr[i];
			} else {
				// 如果不是最后一个元素,拼接数据+,_
				result += arr[i] + ", ";
			}
		}
		result += "]";
		return result;
	}

拷贝数组

System类中提供了arrayCopy方法

static void arraycopy(object src，int srcpos，object dest， int destpos，int length)

此方法将数组 src 内从索引 srcpos 开始长度为length 的元素拷贝给数组dest 且下标以destpos 为开始。
此方法不会给数组扩容，需要注意数组下标越界。

java.util.Arrays类

数组操作的几个思想

求和思想

	/*
	 * 功能:求数列中所有数值的和。
	 * 返回值类型: int
	 * 参数列表: int[] arr
	 * 方法名: getSum
	 */
	public static int getSum(int[] arr) {
		
		// 1.定义求和变量
		int sum = 0;
		
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		
		return sum;
	}

最值思想

	/*
	 * 功能: 求出最大值。
	 * 返回值类型: int
	 * 参数列表: int[] arr
	 * 方法名: getMaxValue
	 */
	public static int getMaxValue(int[] arr) {
		// 1.假设第一个数为最大值
		int max = arr[0];
		
		// 2.遍历数组中的每一个元素
		for (int i = 0; i < arr.length; i++) {
			// 获取到每一个元素arr[i]
			// 3.判断获取的元素是否比max大
			if (arr[i] > max) {
				// 4.设置arr[i]为最大值
				max = arr[i];
			}
		}
		
		return max;
	}
	
	/*
	 * 功能: 求出最小值。
	 * 返回值类型: int
	 * 参数列表: int[] arr
	 * 方法名: getMinValue
	 */
	public static int getMinValue(int[] arr) {
		// 1.假设第一个数为最小值
		int min = arr[0];
		
		// 2.遍历数组中的每一个元素
		for (int i = 0; i < arr.length; i++) {
			// 获取到每一个元素arr[i]
			// 3.判断获取的元素是否比min小
			if (arr[i] < min) {
				// 4.设置arr[i]为最小值
				min = arr[i];
			}
		}
		
		return min;
	}

倒置思想

	/*
	 * 功能: 将数组倒置并输出
	 * 返回值类型: void	
	 * 参数列表: int[] arr
	 * 方法名: reverseArray
	 * 
	 * {8,4,2,1,23,344,12} --> {12,344,23,1,2,4,8}
	 * 第一交换
	 * 	第一个数和最后一个数交换位置
	 *  int temp = 0;
	 *  temp = arr[0];
	 *  arr[0] = arr[arr.length - 1 - 0];
	 *  arr[arr.length - 1 - 0] = temp;
	 *  
	 * 第二次交换
	 * 	第二个数和倒数第二个数交换位置
	 * 	int temp = 0;
	 *  temp = arr[1];
	 *  arr[1] = arr[arr.length - 1 - 1];
	 *  arr[arr.length - 1 - 1] = temp;
	 *  
	 * 第三次交换
	 * 	第三个数和倒数第三个数交换位置
	 * 	int temp = 0;
	 *  temp = arr[2];
	 *  arr[2] = arr[arr.length - 1 - 2];
	 *  arr[arr.length - 1 - 2] = temp;
	 *  
	 * 循环体代码:
	 * 	int temp = 0;
	 *  tmep = arr[i];
	 *  arr[i] = arr[arr.length - 1 - i];
	 *  arr[arr.length - 1 - i] = temp;
	 *  
	 * 循环的次数
	 * 7个数  --> 交换3次
	 * 6个数  --> 交换3次
	 * 5个数  --> 交换2次
	 * 4个数  --> 交换2次
	 * i个数  --> 交换i/2次
	 */
	public static void reverseArray(int[] arr) {
		
		for (int i = 0; i < arr.length / 2; i++) {
			int temp = 0;
			temp = arr[i];
			arr[i] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = temp;
		}
		
	}

查找思想

	/*
	 * 数组查找:从键盘中任意输入一个数据，判断数列中是否包含此数。
	 * 返回值类型: boolean
	 * 参数列表: int[] arr, int num
	 * 方法名: isContainsNum
	 */
	public static boolean isContainsNum(int[] arr, int num) {
		// 默认概述在数组中不存在
		boolean flag = false;
		
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == num) {
				flag = true;
				break;
			}
		}
		
		return flag;
	}

	/*
	 * 数组查找:从键盘中任意输入一个数据，判断数列中是否包含此数。
	 * 返回值类型: int
	 * 参数列表: int[] arr, int num
	 * 方法名: baiscSearch
	 */
	public static int baiscSearch(int[] arr, int num) {
		int index = -1;
		
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == num) {
				index = i;
				break;
			}
		}
		
		return index;
	}

排序思想（八大排序思想）

冒泡排序

代码实现

public static int[] BubbleSort(int [] arr){
	int temp = 0;	
	for (int x = 0; x < arr.length-1; x++) {
			boolean flag = true;
			for (int n = 0; n < arr.length-x-1; n++) {
				if (arr[n] > arr[n+1]) {
					temp = arr[n+1];
					arr[n+1] = arr[n];
					arr[n] = temp;
					flag = false;
				}
			}
			if (flag) {
				break;
			}
		}
		return arr;
 }

选择排序