数组数组 1. 概念 2. 创建方式 3. 下标和访问 4. 遍历 5.数组的默认值 6. 数组的存储 7. 课堂练习

数组

1. 概念

一组连续的存储空间，存储多个数据类型相同的值，空间连续，长度固定。

2. 创建方式

先声明、再分配空间：
数据类型[] 数组名;

数组名 = new 数据类型[长度];
声明并分配空间：

数据类型[] 数组名 = new 数据类型[长度];
声明并赋值（繁）：数据类型[] 数组名 = new 数据类型[]{value1,value2,value3,...};

声明并赋值（简）：
数据类型[] 数组名 = {value1,value2,value3,...}; //显示初始化，注意：不可换行

package com.qfedu.test1;
/**
 * 	创建数组的四种方式
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		// 方式1  先声明 再分配空间
		int [] arr1;
		arr1 = new int[6];
		
		// 方式2  连声明 带分配空间
		int [] arr2 = new int[10];

		// 方式3 声明并且赋值(繁琐)
		int [] arr3 = new int[] {10,20,30,50};
		
		// 方式4 声明并且赋值(简单)
		int [] arr4 = {1,2,3,4,5};
		
	}
}

package com.qfedu.test1;
/**
 * 	各种类型数组写法
 * @author WHD
 *
 */
public class Test2 {
	public static void main(String[] args) {
		byte [] b1 = new byte[10];
		
		short [] s1 = {1,2,3,4,5};
		
		int [] i1 = new int[] {1,2,3,4,5};
		
		long [] l1 = new long[20];
		
		float [] f1 = new float[5];
		
		double [] d1 = new double[2];
		
		boolean [] bl1 = {true,false,true,false,false};
		
		char [] ch1 = {'a','b',65,66,67,68,'\u4e2d'};
		
		String [] strs = new String[] {"hello","hhh","heiheihei","中文","汉语"};
		
		
		
		
		
	}
}

3. 下标和访问

数组中的每个数据格被称为“数组元素”。

对每个元素进行赋值或取值的操作被称为“元素的访问”。

访问元素时，需要使用“下标”（从0开始，依次+1）。

访问的语法：数组名[下标]; //例如存：a[0]=10; 取：a[0];

package com.qfedu.test2;
/**
 * 	数组的访问：赋值和取值统称为数组的访问
 * 	访问数组中的元素通过下标：下标从0开始 ，依次+1
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		int [] arr1 = new int[5];
		
		// 存值
		arr1[0] = 11;
		arr1[1] = 22;
		arr1[2] = 33;
		arr1[3] = 44;
		arr1[4] = 55;
//		arr1[5] = 66; 访问不存在的下标 都将出现数组下标越界异常 ArrayIndexOutOfBoundsException
		
		// 取值
		System.out.println(arr1[0]);
		System.out.println(arr1[1]);
		System.out.println(arr1[2]);
		System.out.println(arr1[3]);
		System.out.println(arr1[4]);
//		System.out.println(arr1[6]); 访问不存在的下标 都将出现数组下标越界异常 ArrayIndexOutOfBoundsException
	}
}

4. 遍历

package com.qfedu.test2;
/**
 * 	使用for循环遍历数组
 * @author WHD
 *
 */
public class Test2 {
	public static void main(String[] args) {
		int [] arr1 = {11,22,33,44,55,66};
		
		System.out.println(arr1[0]);
		System.out.println(arr1[1]);
		System.out.println(arr1[2]);
		System.out.println(arr1[3]);
		System.out.println(arr1[4]);
		System.out.println(arr1[5]);
		
		System.out.println("----------------------------------------");
		for(int i = 0;i < 6;i++) {
			System.out.println(arr1[i]);
		}
		
		
	}
}

数组的属性 length 表示数组的长度是一个int类型的整数通过数组名.length 来使用

package com.qfedu.test2;
/**
 * 	通过for循环遍历数组取值
 * 	数组的属性 length 表示数组的长度 是一个int类型的整数 通过数组名.length 来使用
 * @author WHD
 *
 */
public class Test3 {
	public static void main(String[] args) {
		int [] arr1 = {1,2,3,4,5,6,4556,78,12,475,12,45,12,454,21,454,57,211,547,87,12,45};
		
		System.out.println(arr1.length);
		
		for(int i = 0;i < arr1.length;i++) {
			System.out.println(arr1[i]);
		}
		
	}
}

package com.qfedu.test2;

import java.util.Scanner;

/**
 * 	通过循环给数组赋值  
 * @author WHD
 *
 */
public class Test4 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		
		int [] arr1 = new int[6];
		
		for(int i = 0;i < arr1.length;i++) {
			System.out.println("请输入第"+ (i + 1) +"个元素的值");
			
			arr1[i] = input.nextInt();
		}
		
		System.out.println("-------------------------------------");
		
		for (int i = 0; i < arr1.length; i++) {
			System.out.println("通过循环取值：" + arr1[i]);
		}
		
		
		System.out.println("程序结束");
	}
}

5.数组的默认值

数组中的元素是有默认值的，当我们给数组开辟空间，默认值即存在。

数组的默认值

整数：0

小数：0.0

布尔：false

字符：\u0000

其他引用数据类型：null

package com.qfedu.test3;
/**
 * 	数组的默认值
 * 	整数：0
 * 	小数：0.0
 * 	布尔：false
 * 	字符：\u0000
 * 	其他引用数据类型：null
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		byte [] b1 = new byte[3];
		for (int i = 0; i < b1.length; i++) {
			System.out.print(b1[i] + "\t");
		}
		System.out.println();
		
		short [] s1 = new short[5];
		for (int i = 0; i < s1.length; i++) {
			System.out.print(s1[i] + "\t");
		}
		System.out.println();
		
		int [] i1 = new int[4];
		for (int i = 0; i < i1.length; i++) {
			System.out.print(i1[i] + "\t");
		}
		System.out.println();
		
		long l1[] = new long[10];
		for (int i = 0; i < l1.length; i++) {
			System.out.print(l1[i] + "\t");
		}
		System.out.println();
		
		float [] f1 = new float[2];
		for (int i = 0; i < f1.length; i++) {
			System.out.print(f1[i] + "\t");
		}
		System.out.println();
		
		double [] d1 = new double[1];
		for (int i = 0; i < d1.length; i++) {
			System.out.print(d1[i] + "\t");
		}
		System.out.println();
		
		char [] ch1 = new char[3];
		for (int i = 0; i < ch1.length; i++) {
			System.out.print(ch1[i] + "-");
		}
		System.out.println();
		
		boolean [] bl1 = new boolean[4];
		for (int i = 0; i < bl1.length; i++) {
			System.out.print(bl1[i] + "\t");
		}
		System.out.println();
		
		String [] strs = new String[5];
		for (int i = 0; i < strs.length; i++) {
			System.out.print(strs[i] + "\t");
		}
		System.out.println();
	}
}

6. 数组的存储

数组作为引用数据类型，引用(名称)存在栈中，值存在堆中

数组引用中保存的是hash值所以直接打印将输出hash值

数组的存储.png

7. 课堂练习

package com.qfedu.test4;
/**
 * 	求数组中的最大值  / 最小值
 * 	分析：
 * 	先假设一个最大值，然后依次与后续的元素来比较，
 * 	如果遇到比当前 元素还大值，则交换头衔，最后保留最大值头衔的
 * 	元素 就是我们最终需要的值
 * @author WHD
 *
 */
public class Test4 {
	public static void main(String[] args) {
		int [] nums = {567,4445,56,2300,12457,885,99632,22};
		
		int min = nums[0];
		
		for(int i = 0;i < nums.length; i ++) {
			if(min > nums[i]) {
				min = nums[i];
			}
		}
		
		System.out.println("最小值是：" + min);
	}
}

8.复制数组

8.1 方式1

循环将原数组中所有元素逐一赋值给新数组。

package com.qfedu.test4;
/**
 * 	数组扩容(复制)
 * 	1.创建一个长度大于原数组的数组 然后依次将原数组的元素 复制 到新数组中
 * @author WHD
 *
 */
public class Test2 {
	public static void main(String[] args) {
		int [] nums1 = {11,22,33,44,55};
		
		int [] nums2 = new int[nums1.length * 2];
		
		for(int i = 0;i < nums1.length;i++) {
			nums2[i] = nums1[i];
		}
		
		for(int i = 0;i < nums2.length;i++) {
			System.out.print(nums2[i] + "\t");
		}
		System.out.println();
		
		
	}
}

8.2 方式2

System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);

package com.qfedu.test5;

import java.util.Arrays;

/**
 * 	数组的复制
 * 	2.System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		int [] oldArr = {1,2,3,4,5};
		int [] newArr = new int[10];
		
		System.arraycopy(oldArr, 4, newArr, 5, 1);
		
		for (int i = 0; i < newArr.length; i++) {
			System.out.print(newArr[i] + "\t");
		}
		
		System.out.println();
	}
}

8.3 方式3

3.java.util.Arrays.copyOf(原数组, 新长度);//返回带有原值的新数组。

package com.qfedu.test5;

import java.util.Arrays;

/**
 * 	数组的复制
 *	3.java.util.Arrays.copyOf(原数组, 新长度);//返回带有原值的新数组。
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
	int [] nums = {1,2,3,4,5};
		
		int [] nums1 = Arrays.copyOf(nums, 3);
		for (int i = 0; i < nums1.length; i++) {
			System.out.print(nums1[i] + "\t");
		}
		System.out.println();
		System.out.println("-------------------------------");
		
		
		int [] nums2 = Arrays.copyOf(nums, 6);
		for (int i = 0; i < nums2.length; i++) {
			System.out.print(nums2[i] + "\t");
		}
		System.out.println();
		
	}
}

9. 面试题

值传递和引用传递的区别？

值传递，传递的是值的副本，在方法中对值的操作不会影响原来的变量

引用传递，传递的是地址，根据这个地址对数据的操作，会影响原来的变量

String类型是特殊的引用数据类型，作为参数传递不会影响原来的变量

package com.qfedu.test6;
/**
 * 	面试题：Java中值传递和引用传递的区别？
 * 	值传递，传递的是值的副本，在方法中对值的操作不会影响原来的变量
 * 	引用传递，传递的是地址，根据这个地址对数据的操作，会影响原来的变量
 * 	String类型是特殊的引用数据类型，作为参数传递不会影响原来的变量
 * @author WHD
 *
 */
public class Test2 {
	public static void main(String[] args) {
		int a = 10;
		m1(a);
		System.out.println(a);
		System.out.println("----------------------------------------------");
		
		int [] arr1 = {1,2,3,4,5};
		System.out.println(arr1);
		m2(arr1);
		for (int i = 0; i < arr1.length; i++) {
			System.out.print(arr1[i] + "\t");
		}
	}
	public static void m2(int [] arr2) {
		System.out.println(arr2);
		for (int i = 0; i < arr2.length; i++) {
			arr2[i] += 1;
		}
	}
	
	public static void m1(int num) {
		num+= 10;
	}
	
}

10. 数组参数和返回值

数组作为参数和作为返回值与之前的使用方式一致。

package com.qfedu.test1;

import java.util.Scanner;

/**
 * 	需求：
 * 	1.编写方法实现 让用户输入5门成绩 并且返回这些成绩
 * 
 * 	2.编写方法根据用户传入的成绩数组 遍历成绩 并且打印
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		double[]  scores = inputScore();
		printScore(scores);
	}
	public static double[] inputScore(){
		Scanner input = new Scanner(System.in);
		double [] scores = new double[5];
		for (int i = 0; i < 5; i++) {
			System.out.println("请输入第"+ (i + 1) +"个人的成绩");
			double score = input.nextDouble();
			scores[i] = score;
		}
		return scores;
	}
	public static void printScore(double [] scores) {
		for (int i = 0; i < scores.length; i++) {
			System.out.println("第" + (i + 1)+"个人的成绩是：" + scores[i]);
		}
	}
}

11. 可变长参数

可变长参数：可接收多个同类型实参，个数不限(0个或者N个)，使用方式与数组相同

语法：数据类型... 形参名

要求：必须定义在形参列表的最后，且只能有一个。

package com.qfedu.test1;
/**
 * 	可变长参数：可接收多个同类型实参，个数不限(0个或者N个)，使用方式与数组相同
 * 	语法：数据类型... 形参名 
 * 	要求：必须定义在形参列表的最后，且只能有一个。
 * @author WHD
 *
 */
public class Test2 {
	public static void main(String[] args) {
		
		
		int [] nums = {1,2,3};
		arrayPrint(nums);
		
		printNum(1,2,3,4,5,6);
	}
	public static void printNum(int...nums) {
		for(int i = 0;i < nums.length;i++) {
			System.out.print("循环体中打印数字：" + nums[i] + "\t");	
		}
		System.out.println();
		System.out.println("printNum方法执行完毕");
	}
	
	public static void arrayPrint(int [] nums) {
		for (int i = 0; i < nums.length; i++) {
			System.out.println(nums[i]);
		}
	}
	

}

12. 排序

12.1 冒泡排序

冒泡排序：相邻的两个数值比较大小，互换位置。

外层循环控制比较的轮数轮数永远是长度-1 n -1

内层循环控制每一轮比较的次数最多的一次是长度-1 后续每轮依次递减1 n - 1 - i

冒泡排序1.gif

package com.qfedu.test2;

import java.util.Arrays;

/**
 * 	排序算法：冒泡排序，选择排序，归并排序，桶排序，猴子排序，快速排序，二叉树排序
 * 	冒泡排序：相邻的两个数值比较大小，互换位置。
 * 
 * 	外层循环控制比较的轮数 轮数永远是长度-1    n -1 
 * 	内层循环控制每一轮比较的次数 最多的一次是长度-1  后续每轮依次递减1  n - 1 - i
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		int c = a;
		a = b;
		b = c;
		System.out.println(a);
		System.out.println(b);
		
		int [] nums = {442,12,0,3,69,55,231,147,5};
		
		for (int i = 0; i < nums.length - 1; i++) {// 外层循环 控制比较的轮数 长度 - 1
			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;
				}
			}
		}
		
		System.out.println(Arrays.toString(nums));
		
		for (int i = 0; i < nums.length; i++) {
			System.out.print(nums[i] + "\t");
		}
	}
}

12.2 选择排序

选择排序：固定值与其他值依次比较大小，互换位置。

回顾冒泡排序存在哪些问题：大拿 160 广坤 175 赵四 180

选择排序

外层循环控制比较的数A 外层循环 n - 1

内层循环控制比较的数B 内层循环初始值 i + 1

选择排序2.gif

package com.qfedu.test3;

import java.util.Arrays;

/**
 * 	选择排序：固定值与其他值依次比较大小，互换位置。
 * 	回顾冒泡排序存在哪些问题：大拿 160  广坤 175     赵四 180
 * 
 * 	选择排序
 * 	外层循环 控制比较的数A
 * 	内层循环 控制比较的数B
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		int [] nums = {-1,442,12,0,3,69,55,231,147,5};
		int count = 0;
		
		for(int i = 0;i < nums.length -1;i++) {
			int index = i; 
			
			for(int j = i + 1;j < nums.length;j++) {
				if(nums[index] < nums[j]) {
					index = j;
				}
			}
			if(index != i) {
				int temp = nums[i];
				nums[i] = nums[index];
				nums[index] = temp;
				count++;
			}
			System.out.println("第"+(i + 1)+"轮比较完数列的顺序：" +Arrays.toString(nums));
		}
		
		System.out.println(Arrays.toString(nums));
		System.out.println("一共交换了"+ count +"次位置");
		
		
	}
}

12.3 JDK排序

JDK提供的排序 Arrays.sort(数组名) 只支持升序

package com.qfedu.test4;

import java.util.Arrays;

/**
 * 	JDK提供的排序  Arrays.sort(数组名) 只支持升序
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		int [] nums = {-1,442,12,0,3,69,55,231,147,5};
		Arrays.sort(nums);
		System.out.println(Arrays.toString(nums));
	}
}

13. 二维数组

二维数组，数组中的元素还是数组

package com.qfedu.test4;
/**
 * 	二维数组，数组中的元素 还是数组
 * @author WHD
 *
 */
public class Test2 {
	public static void main(String[] args) {
		int [] nums1 = {1,2,3,4,5};
		int [][] nums2 = {{1,2,3},{4,5},{6,7,8},{11,22,33,44,55}};
		
		System.out.println(nums2[0]);
		System.out.println(nums2[0][0]);
		System.out.println(nums2[0][1]);
		System.out.println(nums2[0][2]);
		System.out.println("-------------------------------------");
		System.out.println(nums2[1][0]);
		System.out.println(nums2[1][1]);
		System.out.println("-------------------------------------");
		System.out.println(nums2[2][0]);
		System.out.println(nums2[2][1]);
		System.out.println(nums2[2][2]);
	}
}

package com.qfedu.test4;

public class Test3 {
	public static void main(String[] args) {
		int [][] nums1 = new int[3][];
		
		nums1[0] = new int[5];
		nums1[0][0] = 11;
		nums1[0][1] = 12;
		nums1[0][2] = 13;
		nums1[0][3] = 14;
		nums1[0][4] = 15;
		
		
		nums1[1] = new int[3];
		nums1[1][0] = 11;
		nums1[1][1] = 22;
		nums1[1][2] = 33;
		
		
		nums1[2] = new int[2];
		nums1[2][0] = 55;
		nums1[2][1] = 66;
		
		for (int i = 0; i < nums1.length; i++) {
//			System.out.println(nums1[i]);
			for(int j =0;j < nums1[i].length;j++) {
				System.out.print(nums1[i][j] + "\t");
			}
			System.out.println("-----------------------------");
		}
		
		
		
		
	}
}