Array数组基础.Arrays工具类

一.一维数组的创建规范

1.正确的创建

char []  a = new char[4];  //4是数组的长度
char []  b= new char[]{'a','b'};
char []  c= {'a','b'};

2.错误的创建方法

char []  d = new char[2]{'a','b'}; //报错
char []  e = new char[2]{};//报错

一.二维数组的创建

int[] aa = new int[5];/创建成功的数组 编译器会给数组每个元素自动赋予其初始值。

//第一
int arr1[][] = new int[][] {{45,78,12},{23,56,89}};
//第二
int arr2[][] = {{74,85,96},{41,52,63}};
//第三
int arr4[][] = new int[2][3];    //第一行就是二维数组的第一个元素
arr4[0]=new int[] {48,15,26};
//arr4[0]={48,15,26};          语法错误 必须用new方法
arr4[1][0] =11;
arr4[1][1] =22;
arr4[1][2] =33;

二.遍历二维数组：

第一种方法：for循环遍历数组 。 第二种方法：foreach循环遍历二维数组

第一种方法的应用：横版竖版遍历古诗。

char arr5[][] = new char[4][]; //合法
arr5[0]=new char[] {'春','眠','不','觉','晓'};
arr5[1]=new char[] {'处','处','闻','啼','鸟'};
arr5[2]=new char[] {'夜','来','风','雨','声'};
arr5[3]=new char[] {'花','落','知','多','少'};
for(int i =0 ;i<arr5.length;i++) {
	for(int q =0 ;q<arr5[i].length;q++) {
		System.out.print(arr5[i][q]);
	}
	if(i%2==0) {
		System.out.print("，");  //i是从0开始的
	}else {
		System.out.print("。");
	}
	System.out.println();
}
	
System.out.println("——竖版打印——");
	for(int j =0;j<arr5[0].length;j++) { 	//切记这里不可以写成 j<arr5[i].length ，因为arr5[4]会导致数组越界
		for(int h =3 ;h>=0 ;h--) {
			System.out.print(arr5[h][j]);
		}
		System.out.println();
	}
		System.out.print("。，。，");

第二种方法的应用：foreach循环遍历古诗

for(char[]a:arr5) {
	for(char b:a) {
		System.out.print(b);
	}
		System.out.println();
}

三.Arrays工具类：数组的填充（一维数组）

一.填充和批量替换数组元素的语法

 Arrays.fill(arr 数组, int value填充的值)
 Arrays.fill(arr 数组,int fromIndex开始位置（包括）,int tolndex结束（不包括）.int value)

例子：

int[] a = new int[5];
a[0]=4; //此时数组a第一个元素为4，其他四个元素为0
Arrays.fill(a, 2); //现在5个元素全部为2，之前的操作全部被覆盖
char[] b = new char[] {'a','b','c','d','e','f','g','h'};
Arrays.fill(b, 2,5,'改');//结果为： a b 改 改 改 f g h (5的索引不包括)

应用：电话号码掩码。

int[] num = new int[] {1,5,5,2,2,0,4,2,5,4,8};
Arrays.fill(num, 3, 7, 0);
for(int i=0;i<num.length;i++) {
	if(num[i]==0) {
		System.out.print("*");
	}else {
		System.out.print(num[i]);
	}
}
输出结果为：155****2548

四.Arrays工具类：对数组进行排序

语法： Arrays.sort（Object）方法可以对任意类型的数组进行升序排序。

例子：

String[] str = new String[] {"a","sd","S","FD","78s"};
Arrays.sort(str); //结果为： 78s  FD  S  a  sd  
//java中String数组的排序是按照字典编排顺序来排序的
//所以数字在字母前面，大写字符在小写字母前面

五.Arrays工具类：复制数组

一、copyOf方法
Arrays.copyOf(arr数组，复制后数组的长度)
Arrays.copyOfRange(arr数组，开始位置，结束位置（不包括）);

首先，我们先对数组进行一个存储状态的分析。

int[] a = new int[] {0,1,2,3,4,5,6,7};
int[] b = a;
String A = a.toString();
String B = b.toString();
//此时A和B的值 相等，说明此时 a和b 对应着相同的位置，他们为同一个对象。
a[2] =99; 		//此时 a，b数组均为 0 99 2 3 4 5 6 7 

例子：

int[] c = new int[] {0,1,2,3,4};
int[] d = Arrays.copyOf(c, 6);  //如果长度大于原数组长度则默认填充为该类型的默认值
// 这个方法为c数组开辟了一个新的内存区域
// c  d这两个数组分别指向两个独立的常量
c[0]=9;
//此时c数组为9 1 2 3 4 
//此时d数组为0 1 2 3 4 0

截取指定长度的数组

int[] c = new int[] {0,1,2,3,4};
int[] e = Arrays.copyOfRange(c, 1, 4);
//e的结果为 1 2 3

二.第二种拷贝数组的方法：（并非Arrays工具类）

System.arraycopy(src, srcPos, dest, destPos, length);
 *src 想要复制的数组
 *srcPos  想要复制的开始索引
 *dest  想复制到的数组
 *destPos  想复制到的数组的位置
 *length  想复制的长度

两者的区别在于，Arrays.copyOf()不仅仅只是拷贝数组中的元素，在拷贝元素时，会创建一个新的数组对象。而System.arrayCopy只拷贝已经存在数组元素。

我们看过Arrays.copyOf()的源码就会知道，该方法的底层还是调用了System.arrayCopyOf()方法。

案例一：
将一个数组的另一部分复制到另一个数组

int[] a = new int[] {1,2,3,4};
int[] b = new int[10];
System.arraycopy(a, 0, b, 0,4);
System.out.println(Arrays.toString(b)); //结果[1, 2, 3, 4, 0, 0, 0, 0, 0, 0]

案例二：
从数组中删除某些元素 （本质上还是数组的拷贝）
例如我们打算删除数组中第二个元素，这里用自己复制给自己的方法比较好。

String[] str = new String[] {"aa","bb","cc","dd","ee"};
System.arraycopy(str, 3, str, 3-1, 2);
str[str.length-1]=null;
System.out.println(Arrays.toString(str));

本案例应用 封装一个删除数组中 某些元素的方法 并将原数组返回

//想要删除数组中s中索引为index的元素
public static String[] removeElements(String[] s,int index) {
	System.arraycopy(s, index+1, s, index, s.length-1-index);
	s[s.length-1]=null;
	System.out.println(Arrays.toString(s));
	return s;
}

案例三：
数组的扩容 本质上是 先定义一个更大的数组 ，然后将原数组内容原封不动拷贝到新数组

public static void extendRange() {
	int[] a = new int[] {4,6,5,6,1,4,587,42,4};
	int[] b = new int[a.length+10];
	System.arraycopy(a, 0, b, 0, a.length);
	System.out.println(Arrays.toString(b));
}

案例四：（综合练习）
封装一个方法，使调用该方法可以往指定的数组之中添加新的指定元素

第一种思路：
public static String[] putInsertElement(String[] s1,int index,String str) {
	String[] s2 = new  String[s1.length+1];
	System.arraycopy(s1, 0, s2, 0, index);
	System.arraycopy(s1, index, s2, index+1, s1.length-index);
	s2[index] = new String(str);
	System.out.println(Arrays.toString(s2));
	return s2;
}
第二种思路：
public static String[] putInElement(String[] s,int index,String str) {
	String[] s2 = new String[s.length+1];
	System.arraycopy(s, 0, s2, 0, s.length);
	System.arraycopy(s2, index, s2, index+1, s.length-index);
	s2[index]=new String(str);
	for(int i=0;i<s2.length;i++) {
		System.out.println(i+"---"+s2[i]);
	}
	return s2;
}

六.Arrays工具类：输出数组内容

方法：Arrays.toString()和Arrays.deepToString()

首先，我们先来看一维数组

int[] a= {1,2,45,3,4,5};
System.out.println(a);//结果为  [I@27716f4
System.out.println(Arrays.toString(a));//结果为  [1, 2, 45, 3, 4, 5]

其次我们再来看二维数组

int[][] b = {{1,2,3,4},{5,6,7,8}};
System.out.println(b);//结果为：[[I@27716f4
System.out.println(Arrays.toString(b));//结果为：[[I@8efb846, [I@2a84aee7]
System.out.println(Arrays.deepToString(b));//结果为：[[1, 2, 3, 4], [5, 6, 7, 8]]

##总结一小下，当用一维数组的时候，可以用Arrays.toString(数组名)来输出此格式的数组元素内容；当用二维数组的时候，可以用Arrays.deepToString()(数组名)来输出此格式的数组元素内容。

七.Arrays工具类：数组查询

方法：Arrays.binarySearch（数组名，值）
Arrays.binarySearch（数组名，开始的索引，结束的索引（不包括），值）；

	如果值包含在数组之中，则返回搜索值的索引，否则返回-1或“-”(插入点)，插入点是搜索键将要插入的数组的哪一个点，即第一个大于此键的元素索引。
第二个方法返回查找值在指定范围内是否存在，并返回在整个数组中的索引或“-”插入点

前提：必须要在调用此方法前使用Arrays.sort（）方法对数组进行排序，否则会发生无法正确得出结果。

int[] c = {40,1,3,2,25,10};
Arrays.sort(c);
Arrays.toString(c); // 1 2 3 10 25 40
	//数组元素中没有8，8在10前，所以插入点元素为10 → 1 2 3 8 10 25 40，插入点的索引为4
System.out.println(Arrays.binarySearch(c, 8));// -4
	//数组元素中没有80，80在40之后，所以插入点为? → 1 2 3 10 25 40 80 ? ,插入点的索引为7
System.out.println(Arrays.binarySearch(c, 80)); //-7
	//10是数组元素，返回10在数组中的索引 3
System.out.println(Arrays.binarySearch(c, 10)); //3

	int[]d = {1,2,3,4,5,6,7,8,9};
	//第二个方法返回查找值在指定范围内是否存在，并返回在整个数组中的索引或“-”插入点
	System.out.println(Arrays.binarySearch(d,2,7,5));//结果是4
	//61不在截取的数组内，61在77前，所以77位插入点 。在整个数组中1,2,3,4,5,6,61,77,88,99，插入点索引为7
	System.out.println(Arrays.binarySearch(d,4,8,61));//-7
	//6不在截取的数组内，6在5的后面，所以第二个6为插入点。在整个数组中1,2,3,4,5,6,6,77,88,99，插入点索引为6
	System.out.println(Arrays.binarySearch(d,1,5,6));//-6