数组及数组的简单应用

一、数组扩容

1.1 定义

• 数组中的数据有可能发生改变
• 可能是值的改变，也可能是数据数量的改变
• 如果新增加了数据，数据的个数超过了数组的长度，数组就需要扩容

1.2 扩容的方法–使用for循环

• 新创建数组，数据类型和原来的数组保持一致吗，长度根据自己的需求定义
• 使用for循环遍历原数组数据，给新的数组赋值

package com.qf.arr;

import java.util.Arrays;

public class Demo01 {
	public static void main(String[] args) {
		String[] shuiHu = {"西门庆","武松","潘金莲","武大郎"};
		
		String[] xiYou = {"孙悟空","猪八戒","沙僧","白龙马"};
		
		String[] names = new String[shuiHu.length + xiYou.length];
		
		// 放入shuihu中的人物
		for (int i = 0; i < shuiHu.length; i++) {
			names[i] = shuiHu[i];
		}
		
		// 放入xiyou中的人物
		for (int i = shuiHu.length; i < names.length; i++) {
			names[i] = xiYou[i-shuiHu.length];
		}
		
		System.out.println(Arrays.toString(names));
		
	}
}

1.3 扩容的方法–System.arrayCopy

• System提供了一个静态的方法arrayCopy，可以完成数组数据的复制
  • src - 源数组。
  • srcPos - 源数组中的起始位置。
  • dest - 目标数组。
  • destPos - 目标数据中的起始位置。
  • length - 要复制的数组元素的数量。

package com.qf.arr;

import java.util.Arrays;

public class Demo02 {
	public static void main(String[] args) {
		String[] shuiHu = {"西门庆","武松","潘金莲","武大郎"};
		String[] xiYou = {"孙悟空","猪八戒","沙僧","白龙马"};
		String[] names = new String[shuiHu.length + xiYou.length];
		
		// 使用System提供的拷贝的方法复制shuihu
		System.arraycopy(shuiHu, 0, names, 0, shuiHu.length);
		
		System.out.println(Arrays.toString(names));
		
		// 使用System提供的拷贝的方法复制xiyou
		System.arraycopy(xiYou, 0, names, shuiHu.length, xiYou.length);
		System.out.println(Arrays.toString(names));
	}
}

1.4 扩容的方法–Arrays.copyOf

• Arrays工具类提供的静态方法
  • original - 要复制的数组
  • newLength - 要返回的副本的长度

package com.qf.arr;

import java.util.Arrays;

public class Demo03 {
	public static void main(String[] args) {
		String[] shuiHu = {"西门庆","武松","潘金莲","武大郎"};
		String[] xiYou = {"孙悟空","猪八戒","沙僧","白龙马"};
		// 创建新的数组，长度是shuiHu.length+xiYou.length，新的数组会带着ShuiHu中的数据
		String[] names = Arrays.copyOf(shuiHu, shuiHu.length+xiYou.length);
		
		System.out.println(Arrays.toString(names));
		
		// 复制xiYou的数据到新数组中
		System.arraycopy(xiYou, 0, names, shuiHu.length, xiYou.length);
		System.out.println(Arrays.toString(names));
		
	}
}

二、引用数据类型的参数

2.1 定义

• 在方法中定义的形参，数据类型可以使基本类型，也可以是引用类型

2.2 案例01

package com.qf.arr;

public class Demo04 {
	public static void main(String[] args) {
		String[] xiYou = {"孙悟空","猪八戒","沙僧","白龙马"};
		printArr(xiYou);
		
		String[] shuiHu = {"西门庆","武松","潘金莲","武大郎"};
		printArr(shuiHu);

		show("张三", 23);
		
	}

	/**
	 * 展示个人信息的方法
	 * @param name
	 * @param age
	 */
	public static void show(String name, int age) {
		System.out.println("我的名字是:" + name + ",我今年" + age);
	}

	/**
	 * 数组类型的形参，打印数组中名字的方法
	 * @param names
	 */
	public static void printArr(String[] names) {
		for (int i = 0; i < names.length; i++) {
			System.out.println(names[i]);
		}
	}
	
}

2.3 基本类型和引用类型数据当做参数

package com.qf.arr;

public class Demo05 {
	public static void main(String[] args) {
		// 基本类型的数据当做参数传递，传递的是变量的字面值
		int num = 110;
		System.out.println("main:num = " + num);
		
		changeNum(num);
		System.out.println("main:num = " + num);
		
		System.out.println("=====================");
		
		// 引用类型的数据当做参数传递，传递的是地址值
		int[] arr = {111,222,333};
		System.out.println("main:arr[0] = " + arr[0]);
		System.out.println(arr);
		changeArr(arr);
		System.out.println("main:arr[0] = " + arr[0]);
		System.out.println(arr);
	}

	public static void changeArr(int[] arr) {
		arr[0] = 666;
		System.out.println("changeArr:arr[0] = " + arr[0]);
		System.out.println(arr);
	}

	public static void changeNum(int num) {
		num = num + 10;
		System.out.println("changeNum:num = " + num);
	}
}

2.4 引用类型数据当做返回值

• 合并两个数组
• 返回合并之后的结果

package com.qf.arr;

import java.util.Arrays;

public class Demo06 {
	public static void main(String[] args) {
		// 编写一个方法，传入两个数组，得到一个新的、包含原来两个数组的数组
		String[] shuiHu = { "西门庆", "武松", "潘金莲", "武大郎" };
		String[] xiYou = { "孙悟空", "猪八戒", "沙僧", "白龙马" };

		String[] names = mergeArr(shuiHu, xiYou);
		System.out.println(Arrays.toString(names));
	}

	/**
	 * 合并字符串数组的操作
	 * @param shuiHu	原数据数组1
	 * @param xiYou		原数据数组02
	 * @return			合并之后的数组，包含数组1和数组2中所有的数据
	 */
	public static String[] mergeArr(String[] shuiHu, String[] xiYou) {
		String[] names = new String[shuiHu.length + xiYou.length];
		// 合并的操作
		// 先拷贝shuiHu里面的数据
		System.arraycopy(shuiHu, 0, names, 0, shuiHu.length);

		// 再拷贝xiYou里面的数据
		System.arraycopy(xiYou, 0, names, shuiHu.length, xiYou.length);

		return names;
	}
}

三、不定长参数

3.1 定义

• 有的时候无法确定需要传入几个参数
• 如果是相同类型的参数可以使用不定长参数来接收同类型的数据
• 方法中接收到这些数据，会放入一个数组中

3.2 案例

package com.qf.change;

import java.util.Arrays;

public class Demo02 {
	public static void main(String[] args) {
		// 编写方法，计算任意个整数的和，获取结果
		int sum01 = getSum(3,6);
		int sum02 = getSum(3,6,9);
		int sum03 = getSum(3,6,9,12);
		int sum04 = getSum(3,6,9,12,15);
		System.out.println(sum04);
	}
	/**
	 * 计算两个整数的和
	 * @param i
	 * @param j
	 * @return
	 */
	public static int getSum(int i, int j) {
		return i + j;
	}
	
	/**
	 * 计算三个整数的和
	 * @param i
	 * @param j
	 * @param k
	 * @return
	 */
	public static int getSum(int i, int j, int k) {
		return i+j+k;
	}

	/**
	 * 计算4个整数的和
	 * @param i
	 * @param j
	 * @param k
	 * @param l
	 * @return
	 */
	public static int getSum(int i, int j, int k, int l) {
		return i+j+k+l;
	}
	
	/**
	 * 接收任意个数整数，计算它们的和
	 * @param nums	传入的所有的整数
	 * @return		整数的结果
	 */
	public static int getSum(int... nums) {
		System.out.println(nums);
		System.out.println(Arrays.toString(nums));
		
		// 记录整数的和
		int sum = 0;
		
		for (int i = 0; i < nums.length; i++) {
			sum += nums[i];
		}
		return sum;
	}
}

四、冒泡排序

• 大的上浮，小的下沉
• 大的的数值排到后面，小的数字排到前面

package com.qf.sort;

import java.util.Arrays;

public class BubbleSort {
	public static void main(String[] args) {
		int[] arr = {99,69,96,79,85};
		
		// 确定比较的次数
		for (int i = 0; i < arr.length - 1; i++) {
			// 确定每一轮比较的内容和次数
			for (int j = 0; j < arr.length - i - 1; j++) {
				// 确定比较的规则
				if (arr[j] > arr[j+1]) {
					// 如果j比j+1位置上的数字大，就交换它们的值
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		
		System.out.println(Arrays.toString(arr));
	}
}

五、选择排序

• 假定一个最小的元素，记录她的下标
• 用这个元素和后面的所有元素比较，如果发现更小的，就记录那个更小的元素的小标
• 一轮比较结束后，把原来假设的最小的元素和真正最小的元素交换位置
• 下一轮从下一个位置开始

package com.qf.sort;

import java.util.Arrays;

public class SelectionSort {
	public static void main(String[] args) {
		int[] arr = {99,69,96,79,85};
		
		// 确定比较的次数
		for (int i = 0; i < arr.length; i++) {
			// 假设每一轮的第一个是最小的元素的下标
			int minIndex = i;
			// 确定每一轮比较的次数和内容
			for (int j = i; j < arr.length; j++) {
				if (arr[minIndex] > arr[j]) {
					minIndex = j;
				}
			}
			
			// 发现了更小的元素，交换一下
			int temp = arr[i];
			arr[i] = arr[minIndex];
			arr[minIndex] = temp;
		}
		
		System.out.println(Arrays.toString(arr));
	}
}

六、Arrays提供的排序的方法

• JDK内置的数组工具类Arrays是专门操作数组的一个工具类
• 提供了复制、转换、排序的方法
• sort方法就是对可以比较的数组进行排序

package com.qf.sort;

import java.util.Arrays;

public class ArraysSort {
	public static void main(String[] args) {
		int[] arr = {99,69,96,79,85};
		System.out.println("排序前的arr:" + Arrays.toString(arr));
		
		// 排序
		Arrays.sort(arr);
		System.out.println("排序后的arr:" + Arrays.toString(arr));
		
	}
}

七、二维数组

7.1 定义

• 数组中的元素还是数组
• 数组的嵌套

7.2 创建二维数组

• 静态创建

package com.qf.arrtwo;

public class Demo01 {
	public static void main(String[] args) {
		int[] arr = {1,3,5};
		System.out.println(arr.length);
		
		// 静态创建二维数组
		int[][] arrr = {{11,22,33},{55,66,77,88}};
		System.out.println(arrr.length);
	}
}

• 动态创建

package com.qf.arrtwo;

public class Demo02 {
	public static void main(String[] args) {
		/**
		 * new int[3][5];	
		 * 	第一个方括号表示二维数组的长度是3---里面能存放3个一维数组
		 * 	第二个方括号的表示每一个一维数组的长度都是5
		 */
		int[][] arr = new int[3][5];
		// 输出二维数组的长度
		System.out.println(arr.length);
		
		// 输出一维数组的长度
		System.out.println(arr[0].length);
		System.out.println(arr[1].length);
		System.out.println(arr[2].length);
		
		
		// 动态创建
		int[] arr01 = new int[5];
		
		/**
		 * new int[][]
		 * 	第一个方括号表示二维数组的长度--这个二维数组中可以存放几个一维数组
		 * 	第二个方括号表示每一个一维数组的长度，创建的时候可以省略，后面需要使用的时候在实例化
		 */
		int[][] arrr01 = new int[3][];
		System.out.println(arrr01.length);
		for (int i = 0; i < arrr01.length; i++) {
			System.out.println(arrr01[i]);
		}
		
		// 给二维数组中的一维数组赋值
		arrr01[0] = new int[2];
		arrr01[1] = new int[3];
		arrr01[2] = new int[4];
		for (int i = 0; i < arrr01.length; i++) {
			System.out.println(arrr01[i]);
		}
	}
}

7.3 二维数组的遍历

• 先遍历二维数组，读取里面的每一个一维数组
• 再遍历每一个一维数组，读取每一个元素

package com.qf.arrtwo;

import java.util.Arrays;

public class Demo03 {
	public static void main(String[] args) {
		String[][] names = {
					{"西游记","奔波儿灞","霸波尔奔","金角大王","银角大王"},
					{"三国演义","马超","马岱","马腾","马谡"},
					{"水浒传","李逵","李鬼","扈三娘","王英"},
					{"红楼梦","贾宝玉","林黛玉","薛宝钗","王熙凤"}
				};
		/**
		 * 遍历
		 * 	先取出每一个一维数组
		 * 		再遍历每一个一维数组
		 */
		// 遍历二维数组，获取每一个一维数组
		for (int i = 0; i < names.length; i++) {
			System.out.println(Arrays.toString(names[i]));
			String[] name = names[i];
			
			// 遍历一维数组，获取每一个元素
			for (int j = 0; j < name.length; j++) {
				System.out.println(name[j]);
			}
		}
		
		System.out.println(names[1][2]);
	}
}

7.4 二维数组在内存中的表示