Java程序猿必学第五篇——数组

//1.数组基础（重点）

//1.1. 引入数组
//引言：为什么使用数组？
//需求： 请存储全班的成绩
//根据变量存： int score1=66;  int score2=68;  int score3=77; ...
//弊端： 60个学生成绩，则需要60个变量，冗余太多
//假设每个同学的成绩都+1分？  如何处理？
//弊端：每个变量，都需要做+1操作，不方便管理
//引入数组：
//概念：一组连续的内存空间，用于存储相同类型的元素
//数组特点：类型相同，长度固定

//===========================案例1============================
public class ArrayTest1 {
	public static void main(String[] args) {
		//需求： 请存储全班的成绩
		//数组是引用类型：往往需要先开辟空间，然后再存值
		int[] arr = new int[3]; //定义3个int类型的数组空间  
		//通过下标给数组元素赋值(存值)与取值   下标范围：0~长度-1
		arr[0] = 66;   //赋值
		arr[1] = 68;
		arr[2] = 77;
		//arr[3] = 99;  //ArrayIndexOutOfBoundsException: 数组越界异常
		//打印输出的优化---循环打印(遍历)
		System.out.println("数组长度："+arr.length);  //3
		for(int i=0;i<arr.length;i++) { //i=0
			System.out.println(arr[i]);  //arr[0],arr[1]..
		}
		//System.out.println(arr[3]);  //ArrayIndexOutOfBoundsException
		
	}
}



//===========================案例2============================
//案例2：给每个学生成绩都+1
public class ArrayTest2 {
	public static void main(String[] args) {
		int[] arr = new int[3]; //定义3个int类型的数组空间  
		//通过下标给数组元素赋值(存值)与取值   下标范围：0~长度-1
		arr[0] = 66;   //赋值
		arr[1] = 68;
		arr[2] = 77;
		for(int i=0;i<arr.length;i++) {
			arr[i] += 1; //arr[i]=arr[i]+1;
			
			System.out.println(arr[i]);
		}
		
	}
}



//1.2 数组的初始值与创建

//=======================数组的初始值========================
//数组的初始值问题：
public class Test1 {
	public static void main(String[] args) {
		int[] a = new int[3];  //创建3个存int值的空间
		System.out.println(a[0]);  //0   int类型初始为0
		
		double[] b = new double[3];
		System.out.println(b[0]);  //0.0 double类型初始值	
		
		boolean[] c = new boolean[3];
		System.out.println(c[0]);  //false
		
		char[] d = new char[3];
		System.out.println(d[0]);  //码值为0对应的字符
		
		String[] e = new String[3];
		System.out.println(e[0]);  //String类型初始为 null
	}
}


//=======================数组的创建========================

//数组的创建:
public class Test2 {
	public static void main(String[] args) {
		//----------动态赋值(有了空间，再一个个赋值)-----------
		//1.先声明，后创建空间
		int[] a;
		a = new int[3];
		
		//2.声明的同时，创建空间-（常用）
		int[] c = new int[3];
		
		//------------静态赋值(有了空间的同时赋值)-------------
		//3.创建空间的同时进行赋值
		int[] d = new int[]{1,3,5}; //数组的长度，由值的个数决定
		
		//4.创建空间的同时进行赋值（简化版-常用）
		int[] e = {1,3,5};
	}
}


//1.3 数组练习

//=======================案例1========================
//案例1：给定一个整数数组，统计数组元素的平均分
//分析：先遍历数组的所有元素； 再求和   在除以长度
public class Test1 {
	public static void main(String[] args) {
		int[] a = {68,75,83,63};
		double sum = 0;  //求和，初始为0
		int len = a.length;
		for(int i=0;i<len;i++) {
			sum += a[i];
		}
		System.out.println("数组元素的平均分为:"+(sum/len));
	}
}



//=======================案例2========================
//案例2：给定一个整数数组，输入一个整数n，如果在数组中存在，则输出下标；否则打印-1
//例如：      7   3  8  2  6
//录入1   -1     录入8   2
public class Test2 {
	public static void main(String[] args) {
		int[] a = {7,3,8,2,6};
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入一个值:");
		int n = sc.nextInt();
		int index = -1;  //记录下标
		for(int i=0;i<a.length;i++) { //0
			if(n==a[i]) {
				index = i;  //如果匹配上，进来了，得到了下标
				break;
			}
		}
		System.out.println("下标："+index);
	}
}




//2. 数组扩容
//数组扩容：
//从前面的数组特点中可知，数组的长度是固定的
//如果需要给数组扩容的话，需要重新创建空间
//扩容思路是： 创建一个比原数组更大的空间，再将原数组元素拷贝进来

//2.1 自定义数组扩容
public class Test1 {
	public static void main(String[] args) {
		int[] src = {1,3,5};
		int[] dest = new int[src.length+3];  //定义目标数组，比原数组空间要大
		for(int i=0;i<src.length;i++) {
			dest[i]=src[i];  //循环将原数组元素赋值给目标数组
		}
		for(int i=0;i<dest.length;i++) {
			System.out.print(dest[i]+"\t"); 
		}
		
		//假设数组扩容的实现，需要我们自己写，那么有哪些参数？
		//copyOf1();  源数组，目标数组，源位置，目标位置，拷长度
		//copyOf2();  源数组，扩容的长度-->返回扩容数组
	}
}


//系统提供的扩容方法调用：
public class Test2 {
	public static void main(String[] args) {
		int[] src = {1,3,5};  //原数组
		
		//-------扩容方式1-------
		//int[] dest = new int[src.length+3];  //目标数组
		//参数1：原数组  2.原的起始位置-一般为0   
		//3.目标数组   4.目标起始位置-一般为0    5.拷贝长度--一般是原数组长度
		//System.arraycopy(src, 0, dest, 0, src.length);
		
		//------扩容方式2------
		//参数1：原数组    参数2：要扩容的长度    返回值：扩容的目标数组
		int[] dest = Arrays.copyOf(src, src.length+3);
		
		for(int i=0;i<dest.length;i++) {
			System.out.print(dest[i]+"\t");
		}
		
	}
}

  

//3.数组中的方法封装(重点)

//3.1 关于方法的传参

//=====================传基本类型(值传递)=====================

//案例：通过方法调用，将变量以参数传入，在方法实现中改变参数值；
//在main方法打印该变量,看该变量的值是否进行改变?
//值传递： 形参的改变，不会影响实参
public class Test1 {
	public static void main(String[] args) {
		int a = 3;
		change(a);
		System.out.println("最终结果:"+a);  //3
	}

	private static void change(int a) {
		a = 5;
	}
}

 


//=====================传引用类型(地址传递)=====================
//案例2：将数组以参数传递，在方法实现中改变数组的元素
//在main方法中打印数组，查看是否改变?
//地址传递：形参的改变会影响实参
public class Test2 {
	public static void main(String[] args) {
		int[] a = {1,3,5};
		change(a);
		System.out.println(a[0]);  //9
	}

	private static void change(int[] a) {
		a[0] = 9;
	}
}

 


//3.2 可变参数

//可变参数：
//1，先从普通数组参数进行演变
//案例：通过方法封装，来打印数组
//可变参数： 可以接收可变化的实参   格式： int... a
public class Test3 {
	public static void main(String[] args) {
		//int[] a = {1,3,5};
		//printArray(new int[]{1,3,5});  //打印数组
		
		printArray(1,3,5);  //本质传入new数组
	}

	//可变参数---本质：数组   使用反编译工具，查看
	private static void printArray(int...a) {  
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+"\t");
		}
	}
}



//3.3 方法的返回值返回数组

//案例：在main方法中，传入一个原数组；在方法实现中对原数组进行扩容；
//且将扩容的数组返回
public class Test1 {
	public static void main(String[] args) {
		int[] a = {1,3,5};
		int[] b = copyOf(a,a.length+3);
		
		//在Arrays类中已经写好了数组的打印： 
		//toString: 将数组转字符串返回
		System.out.println(Arrays.toString(a));  //1,3,5
		
		System.out.println(Arrays.toString(b));  //1,3,5,0,0,0
	}


	private static int[] copyOf(int[] a,int len) { //输入原数组，及扩容长度
		//创建一个扩容数组
		int[] b = new int[len];
		//将原数组循环拷贝的扩容数组中
		for(int i=0;i<a.length;i++) {
			b[i]=a[i];
		}
		return b;
	}
}