数组相关知识

概念：一组连续的存储空间，存储多个相同数据类型的值。

特点：类型相同，长度固定。

1、数组的定义：数据类型[] 数组名 = new 数据类型[长度]；

赋值与取值

public class Array1 {
	public static void main(String[] args) {
		//数组定义： 可以先创建空间，再给空间的每个元素赋值； (数组是引用类型，先有空间，再存值)
		//生活案例： 设计好书柜有3个格子空间，然后再去放书
		int[] a = new int[3];
		//存值--通过下标方式存和取，下标范围：从(0-长度-1)
		a[0] = 76;
		a[1] = 66;
		a[2] = 99;
		//a[3] = 89;  //数组存值时下标越界
		//取值
		System.out.println(a[0]);  //取值
		System.out.println(a[1]);  //取值
		System.out.println(a[2]);  //取值
		//System.out.println(a[3]);  //数组取值时下标越界
		
	}
}

2、数组的遍历

//数组的遍历（循环取元素）
public class Array2 {
	public static void main(String[] args) {
		//数组定义： 可以先创建空间，再给空间的每个元素赋值； (数组是引用类型，先有空间，再存值)
		//生活案例： 设计好书柜有3个格子空间，然后再去放书
		int[] a = new int[3];
		//存值--通过下标方式存和取，下标范围：从(0-长度-1)
		a[0] = 76;
		a[1] = 66;
		a[2] = 99;
	
		//取值
		for(int i=0;i<a.length;i++) { //i=0  a[0] a[1] a[2]
			System.out.println(a[i]);  //取值
		}
		System.out.println("==========="+a.length);
		//统一给存的值分别+1
		for(int i=0;i<a.length;i++) {
			a[i] += 1;
			System.out.println(a[i]);
		}
		
	}
}

3、数组的默认值

public class Array3 {
	public static void main(String[] args) {
		//数组的默认值: int--0(常用)  double--0.0  String--null（常用）
		           //boolean--false  char---控制（码值为0）
		int[] a = new int[3];
		a[0] = 66;
		for(int i=0;i<a.length;i++) {
			System.out.println(a[i]); //66 0 0
		}	
		double[] b = new double[3];
		System.out.println(b[0]); //0.0
		
		String[] c = new String[3];
		System.out.println(c[0]);  //null
		
		boolean d[] = new boolean[3]; //不推荐   数据类型 数组[];
		System.out.println(d[0]); //false
		
		char[] e = new char[3];
		System.out.println(e[0]);  //码值为0
		
	}
}

3. 数组的应用

3.1数组的创建方式

public class Create1 {
	public static void main(String[] args) {
		
		//----------动态赋值：先有空间，再手动赋值------------
		//数组的创建方式1： 先声明，再定义空间
		int[] a;
		a = new int[3];
		//数组创建方式2： 声明的同时定义空间
		int[] b = new int[3];  //常用
		
		
		//----------静态赋值：由赋值直接决定空间大小------------
		//数组创建方式3： 定义空间的同时进行赋值(繁琐)； 数组的长度由值确定
		int[] c = new int[]{3,6,5};
		
		//数组创建方式4： 定义空间的同时进行赋值(简化)；数组的长度由值确定
		int[] d = {3,6,5};  //常用    注意，该方式不能换行，例如：下面的
		//int [] e;
		//e = {3,6,5};
		//结论： 先考虑静态，再考虑动态
	}
}

3.2数组的应用案例

案例1：给定一个整数数组，统计所有元素的平均值

//分析： 1.给定静态赋值  2.循环遍历，使用变量接收变量的值  3.求平均值
public class Create2 {
	public static void main(String[] args) {
		int[] a = {66,87,54,98};
		double sum = 0;  //记录总和
		for(int i=0;i<a.length;i++) {
			sum += a[i];
		}
		System.out.println("平均值为:"+sum/a.length);
	}
}

案例2：给定一个整数数组，输入一个整数n，如果n在数组元素中存值，则输出下标；不存在则输出-1

//分析：1.静态赋值定义数组  2.循环遍历数组，判断是否等于n   3.得到结果
public class Create3 {
	public static void main(String[] args) {
		int[] a = {1,3,5,8,9};
		System.out.println("请输入一个正整数n:");
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		
		int index = -1;   //记录下标额标记  默认没有找到的标记-1
		//循环遍历，判断
		for(int i=0;i<a.length;i++) {
			if(a[i]==n) {
				index = i;  //记录匹配上元素的下标
				break;
			}
		}
		System.out.println("下标为："+index);
	}
}

4、数组的扩容

扩容数组：在原数组的基础上，创建一个更大的数组，再将元素在的值，拷贝到扩容数组中

4.1 自定义扩容方式

public class ExtendsArr {
	public static void main(String[] args) {
		int[] a = {1,5,3};   //定义原数组
		int[] b = new int[a.length+1];  //定义扩容数组：在原先数组长度基础上增加的
		//将原数组元素挨个拷贝;  注意：循环的长度为原数组长度
		for(int i=0;i<a.length;i++) {
			b[i] = a[i];
		}
		//循环遍历b数组
		for(int i=0;i<b.length;i++) {
			System.out.print(b[i]+" ");
		}
	}
}

4.2 系统给予的扩容方式

//系统提供的扩容方法：System.arraycopy
//系统提供的扩容方法2：copyof
public class ExtendsArr2 {
	public static void main(String[] args) {
		System.out.println("=========arraycopy===========");
		int[] a = {1,5,3};
		int[] b = new int[a.length+1];
		//参数1： 原数组   参数2： 原数组位置-0  参数3：目标数组   参数4：目标位置-0，参数5：拷贝原的长度
		System.arraycopy(a, 0, b, 0, a.length);  //方法调用-具体实现在System类里面
		
		//Arrays类中提供了拼接所有元素，并以字符串类型返回方式（类似之前for循环遍历数组）
		System.out.println(Arrays.toString(b));  //打印数组
		
		System.out.println("=========copyof===========");
		int[] c = Arrays.copyOf(a, a.length+1); //参数1，原数组   参数2：扩容的长度  返回值：扩容后的数组
		System.out.println(Arrays.toString(c));  //打印数组
		
	}
}

5、数组传参

5.1 传参案例

//数组的参数：参数为数组类型
public class ArrayArg {
	public static void main(String[] args) {
		//打印数组元素的具体方法使用；模拟Arrays.toString
		int[] a = {1,3,5};
		printArray(a);  //方法调用
	}

	// int[] a = a
	private static void printArray(int[] a) { //方法实现
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+" ");
		}
	}
}

5.2 值传递与地址传递

//方法的参数是基本类型和引用类型的区别
public class ArrayArg2 {
	public static void main(String[] args) {
		//方法参数为基本类型：形参的改变，不影响实参（值传递）
		int a = 3;
		set(a);  //方法调用
		System.out.println(a);  //3 
		
		
		//方法参数为引用类型： 数组 , 形参的改变，会影响实参（地址传递） 
		int[] b = {1,3,6}; 
		setArr(b);  //方法调用
		System.out.println(b[0]);  //2
	}

	private static void setArr(int[] b) { //{2,3,6}
		b[0]+=1;
	}

	private static void set(int a) {  //方法实现
		a+=1;
	}
}

6、返回值为数组

//返回值为数组类型（返回多个值）
//案例： 分析copyof的具体实现
public class ReturnArr {
	public static void main(String[] args) {
		int[] a = {1,3,5};
		int[] b = copyof(a,a.length+1); //自定义扩容的方法封装
		System.out.println(Arrays.toString(b)); //打印扩容后的数组
	}

	private static int[] copyof(int[] a, int lenght) {
		//1.定义一个扩容的空间
		int[] b = new int[lenght];//引用类型一定要看new空间
		//2.循环遍历把原数组拷贝到扩容数组
		for(int i=0;i<a.length;i++) {
			b[i] = a[i];  //循环赋值
		}
		return b;
	}
}

7、可变长参数

//可变长参数：用于接收实参的多个同类型变量
//好处：简化传参写法
public class VarArg {
	public static void main(String[] args) {
		//printArray(new int[]{1,5,3});
		
		printArray(2,4,6); //反编译工具中自动new数组-new int[]{2,4,6}
	}

	//int... a: 可变长参数：用于接收实参的多个同类型变量
	//可变长参数的本质： 数组,查看反编译工具 xjad
	//注意：可变长参数必须放参数最后；且一个方法只能有一个可变长参数
	private static void printArray(int... a) { //int a[]
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+" ");
		}
	}
	
	/*
	private static void printArray(int[] a) {
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+" ");
		}
	}*/
}