回顾：Arrays工具在数组的应用和一些案例应用

有关数组 ：

1. Arrays工具类

public static native void arraycopy(Object src, int srcPos,Object dest, int destPos, int length);

主要介绍Arrays的在数组一些常用方法：

public class ArraysDemo {
   public static void main(String[] args) {
   	int[] arr = {22, 11, 66, 88, 99, 44};
   	// Arrays的遍历输出方法
   	System.out.println(Arrays.toString(arr));
   	
   	// Arrays的排序方法
//		Arrays.sort(arr);
   	System.out.println(Arrays.toString(arr));
   	
   	// Arrays的二分法查找方法
   	int index = Arrays.binarySearch(arr, 88);
   	System.out.println(index);
   	
   	// System的arraycopy方法,这是一个本地方法,底层不由Java实现,由C语言实现
   	int[] dest = {100, 200, 300};
   	// Object src, int  srcPos,Object dest, int destPos, int length
   	System.arraycopy(arr, 1, dest, 0 ,3);
   	System.out.println(Arrays.toString(dest));
   	
   	// 复制数组
   	int[] newArr = Arrays.copyOf(arr, arr.length);
   	System.out.println(Arrays.toString(newArr));
   	
   	// 数组扩容
   	int[] newArr2 = Arrays.copyOf(arr, arr.length + 1);
   	System.out.println(Arrays.toString(newArr2));
   	
   	// 缩小数组的容量
   	int[] newArr3 = Arrays.copyOf(arr, arr.length - 2);
   	System.out.println(Arrays.toString(newArr3));
   	
   	// 填充数组
   	 Arrays.fill(arr, 100);
        System.out.println(Arrays.toString(arr));
   	
   	// 填充数组的一部分  左闭右开原则 
   	 Arrays.fill(arr, 2, 4, 100);
   	 System.out.println(Arrays.toString(arr));

2.数组的扩容：

主要有四种方法：

动态扩容
1.使用for循环复制元素扩容
缺陷: 拷贝一部分元素需要计算索引,比较复杂

// 使用for循环复制元素扩容
//		for (int i = 0; i < src.length; i++) {
//			desc[i] = src[i];
//		}
//		System.out.println(Arrays.toString(desc));

2.System.arracopy()扩容
缺陷: 拷贝数组的一部分到目标数组,如果长度超过了目标数组的索引,会抛出异常

//      System.arracopy()扩容
//		System.arraycopy(src, 0, desc, 7, src.length); // 数组越界
//		System.out.println(Arrays.toString(desc));

3.Arrays.copyOf扩容
观察copyOf方法的源码:

 * 			public static int[] copyOf(int[] original, int newLength) {
 *		        int[] copy = new int[newLength];
 *		        System.arraycopy(original, 0, copy, 0,
 *		                         Math.min(original.length, newLength));
 *		        return copy;
 *		    }

4.利用Object类中一个 clone 方法,该方法是真正意义上的复制数组（暂时不做深究）

3.数组的“增删改查”：

数组也是一种数据结构

• 特点:
• 1.有索引
• 2.查询和修改效率高,方便
• 3.增加和删除的效率低

1.往数组中动态添加一个元素

	/*
	 * 动态扩容的原理
	 * 返回值类型: void
	 * 参数列表: int num
	 * 方法名: add
	 */
	/*public static void add(int num) {
		// 利用System.arraycopy方法处理
		int[] descArr = new int[srcArr.length + 1];
		// 复制数组
		System.arraycopy(srcArr, 0, descArr, 0, srcArr.length);
		// 将num赋值到目标数组的最后一个位置
		descArr[descArr.length - 1] = num;
		// 地址传递
		srcArr = descArr;
	}*/

	
	public static void add(int num) {
		int[] descArr = Arrays.copyOf(srcArr, srcArr.length + 1);
		descArr[descArr.length - 1] = num;
		srcArr = descArr;
	
	/*
	 * 往数组的任意位置插入一个元素
	 * 返回值类型: void
	 * 参数列表: int index, int num
	 * 方法名: insert
	 */
	public static void insert(int index, int num) {
		int[] descArr = new int[srcArr.length + 1];
		System.arraycopy(srcArr, 0, descArr, 0, index);
		descArr[index] = num;
		System.arraycopy(srcArr, index, descArr, index + 1, srcArr.length - index);
		srcArr = descArr;
	}

2.将数组中的某个索引处的元素删除

	/*
	 * 
	 * 返回值类型: void
	 * 参数列表: int index
	 * 方法名: remove
	 */
	public static void remove(int index) {
		int[] descArr = new int[srcArr.length - 1];
		System.arraycopy(srcArr, 0, descArr, 0, index);
		System.arraycopy(srcArr, index + 1, descArr, index, descArr.length - index);
		srcArr = descArr;
	}
	
	public static int get(int index) {
		return srcArr[index];
	}
	
	public static void set(int index, int num) {
		srcArr[index] = num;
	}
}

3.有些涉及到数组的一些案例详解：

1.现在给出两个数组
数组A：1,7,9,11,13,15,17,19
数组B：2,4,6,8,10
编写一个方法实现将两个数组合并成一个新的数组c，并且按照升序排序

public static void main(String[] args) {
		 int[] a= {1,7,9,11,13,15,17,19};
		 int[] b= {2,4,6,8,10};
		 int[] c= {1,7,9,19};
//		 int[] newarr =mix(a,b,c);
//		 Arrays.sort(newarr);   Arrays工具的应用
		 System.out.println(Arrays.toString(mix(a,b,c)));
	}
	
// 方法名：mix
//	返回值类型：int[]
	public static int[] mix(int[]... arrs) {   /* 可变参 */
		int index = 0;
		for (int[] arr : arrs) {				/* 1获取新数组的长度 */
			index +=arr.length;
		} 									
		int[] newarr=new int[index];
		
//		遍历每个数组并逐个复制进新数组
		int a= 0;
		for (int[] arr : arrs) {
			System.arraycopy(arr, 0, newarr, a, arr.length);
			a +=arr.length;
		}
		return newarr;
	}

2.现在有如下的一个数组：
int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} ;
要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为：
int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5}

public static int[] delZero(int[] oldArr) {
确定新数组的长度length
		int mark = 0;
		for (int i = 0; i < oldArr.length; i++) {
			if (oldArr[i]==0) {
				mark+=1;
			}
		}
定义新数组，并将老数组中不为零的数赋值给新数组		
		int[] newArr = new int[oldArr.length-mark];
		int index = 0;
		for (int i = 0; i < oldArr.length; i++) {
			if (oldArr[i]!=0) {
				newArr[index]=oldArr[i]; 注意这里需引入变量index，若为newArr[i]=oldArr[i]属数组越界
				index++;
			}						
		}
      return newArr;
		
	}
	public static void main(String[] args) {
		 int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
		 int[] newarr=delZero(oldArr); 方法引用
		 System.out.println(Arrays.toString(newarr));
	}

3.编写顺序查找的方法public static int[] ordinalSearch(int data[],int key)，
要求该方法返回一个数组（如果key存在，数组中各元素的值分别为关键字key在原数组data中的各下标；如果key不存在，则返回一个长度为1的数组，数组元素为-1）。

public static int[] ordinalSearch(int data[], int key) {
//	获取返回数组的的长度：
		int newarrLength = 0;
		for (int i = 0; i < data.length; i++) {
			if (data[i] == key) {
				newarrLength++;
			}
		}
		if (newarrLength == 0) {         ifelse如果未获取到则返回数组{-1}，否则进行下一步
			return new int[] { -1 };  
		} else {
			int[] newarr = new int[newarrLength];
//			将key与原数组相等的值的下标赋值给新数组
			int index = 0;
			for (int i = 0; i < data.length; i++) {
				if (data[i] == key) {
					newarr[index] = i;
					index++;
				}
			}
			return newarr;
		}
	}
	public static void main(String[] args) {
		int[] date = { 1, 5, 4, 6, 7, 4, 5, 8, 4, 3, 9, };
		int key =1;
		int[] getarr = ordinalSearch(date, key);
		System.out.println(Arrays.toString(getarr));
	}

总结：

通过Arrays工具可进行数组内的排序、查找、扩容、复制及增删改查等方法操作，实际中可以通过这些方法快速解决一些问题；