6. 数组（一维数组）

@一贤不穿小鞋

1.数组

• 在内存中开辟一段连续的空间存值.

1.1:数组是一种引用数据类型的变量.

1.2:数组组成

• 数组名,数据类型,元素(数组的每个空间存的值),索引(下标).

1.3:同一个数组中元素的数据类型相同,不同的数组数据类型可以不相同,但是必须是java支持的类型.

1.4:数组的长度

• 数组名.length

1.5:获得数组中每个元素

• 数组名[索引]

1.6:数组的索引范围

• 0-数组的长度-1

1.7:数组索引如果超过取值范围报数组索引越界异常

• ArrayIndexOutOfBoundsException

1.8:数组一旦分配了空间,它的长度就固定了.

1.9:数组直接输出,输出的是内存地址.

1.10:数组只要分配了空间就有默认值

• String类型的数组 默认值为null
• int类型的数组 默认值为0
• double类型的数组 默认值为0.0
• char类型的数组 默认值为\u0000,在window系统上看就是空格
• boolean类型的数组 默认值为false

1.11:数组一旦分配了空间就可以使用.

2.数组的使用:

2.1:声明数组的语法:

	数据类型[] 数组名; (推荐)
	数据类型 数组名[];  
	eg://声明数组
		String[] stuNames;
	    int stuAges[];

2.2:给数组分配空间

• 给已经声明的数组分配空间的语法:数组名=new 数据类型[长度];

• 在声明数组的同时分配空间的语法:
  数据类型[] 数组名=new 数据类型[长度];
  或 数据类型 数组名[]=new 数据类型[长度];

2.3:给数组赋值:

2.3.1:动态赋值:给数组的每一个空间单独赋值.

• 适用场景:适用于任何情况.
• 语法: 数据名[索引]=值;
• 注意:能给数组动态赋值的前提条件是,数组已经分配了空间.

eg://给数组动态赋值
		stuNames[0]="张三";
		stuNames[1]="李四";
		stuNames[2]="王五";
	   stuNames[3]="赵麻子";

2.3.2:静态赋值:一次性给数组中所有空间赋值.

• 将声明数组,给数组分配空间及赋值合三为一.
• 适用场景:对数组中元素已知.

2.3.2.1:语法

• 数据类型[] 数组名=new 数据类型[]{值1,值2…};
• 或 数据类型 数组名[]=new 数据类型[]{值1,值2…};

eg://给数组静态赋值:将声明数组和给数组分配空间并赋值合三为一,也可以分成两名代码
	    //int[] stuAges2=new int[]{18,19,20,30,50};
	    int[] stuAges2;
		 stuAges2=new int[]{18,19,20,30,50};

2.3.2.2:语法

• 数据类型[] 数组名={值1,值2…};
• 或 数据类型 数组名[]={值1,值2…};

eg://给数组静态赋值:将声明数组和给数组分配空间并赋值合三为一,不能分成两句代码
double[] stuHeights2= {1.6,1.65,1.7,1.8};	

2.4:遍历数组:

• 遍历:访问数组中每个空间的元素.

2.4.1:用for循环遍历数组

eg://用for遍历数组:访问数组每个空间中值
		for (int i = 0; i <stuAges2.length; i++) {
			System.out.println(stuAges2[i]);
		}

2.4.2:增强版的for循环(变态for循环,foreach循环)

• 用来遍历数组或集合.
• 语法:for(数据类型 别名:数组/集合){
  }
• 语法解析:增强版的for循环,小括号中:表示遍历,它会自动从数组/集合的第一个空间中元素遍历最后一个元素;每遍历一个元素,就将元素存在别名;小括号中数据类型指数组/集合中每个元素的数据类型或者说是别名的数据类型.

eg://用增强版的for循环遍历数组
		for (String name: stuNames) {
			System.out.println(name);
		}

3.数组的扩容

• 因为数组一旦分配了空间,长度是固定的.所以扩容实际上是声明一个新数组,将原数 组的元素复制到新数组中存着.

3.1:声明一个新数组,将原数组中值一一复制到新数组中.

3.2:System.arraycopy(原数组,原数组起始索引,新数组,新数组起始位置,复制元素个数)

3.3:Arrays.copyOf(原数组, 新数组的长度);

eg:public static void main(String[] args) {
		//准备数组
		int[] nums1= {11,88,33,44};
		
		/*将原数组扩容到8个长度:本质就是重新声明一个长度为8的数组,将原数组的元素复制过来*/
		//第一种:直接扩容
		int[] newNums2=new int[8];
		for (int i = 0; i <nums1.length; i++) {
			newNums2[i]=nums1[i];
		}
		
		//第二种:System.arrayCopy();
		int[] newNums3=new int[8];
		System.arraycopy(nums1, 0, newNums3, 0, 4);
		
		//第三种:Arrays.copyOf();
		int[] newNums4=Arrays.copyOf(nums1, 8);
		
		//遍历新数组
		for (int i : newNums4) {
			System.out.println(i);
		}
	}

4.动态参数(可变长参数)

• 在方法声明的小括号中用,表示0到多个参数.
• 语法:数据类型…参数名

4.1:动态参数表示0个到多个参数.

4.2:动态参数在方法中当作已知数组来用.

4.3:动态参数的实参可以直接传递一个数组.

4.4:方法的形参中可以有动态参数也可以有其他参数,动态参数必须形参的最后一个.

4.5:一个方法中最多只能用一个动态参数.

eg:public class DynamicParameter {
	public static void main(String[] args) {
		//调用方法
		double result1=add("sx");
		System.out.println("结果1为:"+result1);
		
		//调用方法
		double result2=add("sx",11,22,44,55);
		System.out.println("结果2为:"+result2);
		
		//准备一个数组
		double[] counts= {5,8,1,7}; 
		//调用方法
		double result3=add("sx",counts);
		System.out.println("结果3为:"+result3);

	}
	
	/**
	 * 用动态参数来计算数字之和
	 * @param nums
	 * @return double
	 */
	public static double add(String name,double...nums) {
		System.out.println(name+"正在计算中");
		//声明一个变量存总和
		double sum=0;
		//将动态参数当作已知的数组来用
		for (int i = 0; i < nums.length; i++) {
			sum=sum+nums[i];
		}
		return sum;
	}
}

5.数组排序:

5.1:求最大值和最小值:打擂台方式

eg:public static void main(String[] args) {
		//准备一个数组
		int[] nums= {5,8,1,7,6,3};
		
		//声明一个变量存最大值
		int max=nums[0];
		//声明一个变量存最小值
		int min=nums[0];
		
		//遍历数组
		for (int i = 1; i < nums.length; i++) {
			//让数组中每个元素依次与最大值比
			if (max<nums[i]) {
				max=nums[i];
			}
			
			//让数组中每个元素依次与最小值比
			if (min>nums[i]) {
				min=nums[i];
			}
		}
		
		System.out.println("最大值为:"+max);
		System.out.println("最小值为:"+min);
	}

5.2:冒泡排序

• 将一列数从第一个数开始进行两两相邻比较,每一轮求出最大值或最小值,再将剩下数进行依此类推的比较方式求出最大值或最小值,直到把这一列数的所有数比完,这列数就全部排好序.
• 

			eg:public static void main(String[] args) {
		//准备一个数组
		int[] nums= {5,8,1,7,6,3};
		
		//遍历原数组
		for (int i : nums) {
			System.out.print(i+"\t");
		}
		System.out.println();
		System.out.println("------------------------");
		
		//冒泡排序
		//外层循环控制比较轮数
		for (int i = 0; i < nums.length-1; i++) {
			//内层循环控制比较的次数,从第一个数开始两两比较
			for (int j = 0; j < nums.length-1-i; j++) {
				//两两比较
				if (nums[j]<nums[j+1]) {
					int temp=nums[j];
					nums[j]=nums[j+1];
					nums[j+1]=temp;
				}
			}
		}
		
		//遍历排序后的数组
		for (int i : nums) {
			System.out.print(i+"\t");
		}
		System.out.println();
	}

5.3:选择排序

• 将一列数从第一个数开始,依次与后面每个数比较,求最大值或最小值;剩下数依此类推.

		eg:public static void main(String[] args) {
		//准备一个数组
		int[] nums= {5,8,1,7,6,3};
		
		//遍历原数组
		for (int i : nums) {
			System.out.print(i+"\t");
		}
		System.out.println();
		System.out.println("------------------------");
		
		//选择排序
		//外层循环控制比较轮数
		for (int i = 0; i < nums.length-1; i++) {
			//内层循环控制比较索引
			for (int j = i+1; j < nums.length; j++) {
				//两两比较
				if (nums[i]>nums[j]) {
					int temp=nums[i];
					nums[i]=nums[j];
					nums[j]=temp;
				}
			}
		}
		
		//遍历排序后的数组
		for (int i : nums) {
			System.out.print(i+"\t");
		}
		System.out.println();
	}

5.4:java中jdk排序

• Arrays.sort(数组名);
• 对数组进行升序排序

eg:public static void main(String[] args) {
		//准备一个数组
		int[] nums= {5,8,1,7,6,3};
		
		//遍历原数组
		for (int i : nums) {
			System.out.print(i+"\t");
		}
		System.out.println();
		System.out.println("------------------------");
		
		//用jdk排序
		Arrays.sort(nums);
		
		//遍历排序后的数组
		for (int i : nums) {
			System.out.print(i+"\t");
		}
		System.out.println();
	} 		

6.Arrays:数组的工具类.

6.1:Arrays.toString(数组名);

• 将数组转换为字符串

6.2:Arrays.sort(数组名);

• 对数组进行升序排序.

6.3:Arrays.binarySearch(数组名, 要查找的元素);

• 对已经排好序的数组进行二分查找

6.4:Arrays.copyOf(原数组, 新数组的长度);

• 将原数组中元素复制指定长度的新数组中

6.5:Arrays.copyOfRange(原数组, 起始索引, 终止索引);

• 将原数组中指定索引范围内元素复制新数组中.

6.6:Arrays.fill(数组名, 值);

• 将数组中每个元素赋相同的值.

	eg:public static void main(String[] args) {
		//准备一个数组
		int[] nums= {5,8,1,7,6,3};
		
		//将原数组转换为字符串输出
		System.out.println("原数组为:"+Arrays.toString(nums));
		
		//将数组进行升序排序
		Arrays.sort(nums);
		
		System.out.println("排序后数组为:"+Arrays.toString(nums));
		
		Scanner input=new Scanner(System.in);
		System.out.println("请输入要查找的整数:");
		int find=input.nextInt();
		
		//用二分查找法对已经排好序的数组进行查找
		int index=Arrays.binarySearch(nums, find);
		
		if (index>=0) {
			System.out.println("数组中包含元素"+find+",查找元素的索引位置为:"+index);
		} else {
			System.out.println("数组中查无此元素");
		}
		
		//将原数组中指定索引范围内元素复制新数组中.包括起始索引,不包括终止索引
		int[] newNum1=Arrays.copyOfRange(nums, 1, 4);
		
		//声明一个数组
		int[] nums2=new int[4];
		
		//给数组赋相同的值
		Arrays.fill(nums2, 6);
		
		System.out.println("新数组为:"+Arrays.toString(nums2));
	}