数组的基本概念

数组的基本概念

1、 下列数组的声明有哪些是对的？错的应该怎么修改？
A. int [ ] a; B. int a[ ] = new int [3]; C. int[ ] a; a = {1,2,3,4,5}; D. int[] a = new int[3]{1,2,3};
数组的创建：
A. 先声明、再分配空间 ：

​ 数据类型 [] 数组名 ;

​ 数组名 = new 数据类型 [ 长度 ];

​ B. 声明并分配空间 ：

​ 数据类型 [ ] 数组名 = new 数据类型 [ 长度 ];

​ C. 声明并赋值（繁）：

​ 数据类型 [] 数组名 = new 数据类型 [ ]{value1,value2,value3,…};

​ D. 声明并赋值（简）：

​ 数据类型 [ ] 数组名 = {value1,value2,value3,…}; //显示初始化，注意：不可换行

​ **答：根据数组的创建方法，选项A与选项选项B**是正确的；

​ **选项 C：**必须把变量定义和显式初始化放在同⼀⾏。更改为： int [ ] a ={1,2,3,4,5 } 声明并赋值

2、 数组 的元素通过 下标 来访问， 数组Array 的⻓度为 Array.length

3、 数组下标访问超出索引范围时会抛出 下标越界 异常。

4、 引⽤数组元素时，数组下标可以是 整型变量 、整型表达式 。

5、 执⾏完代码 int[ ] x = new int[25]。以下选项正确的是 A 。
A. x[24]为0 B. x[24]未定义 C. x[25]为0 （越界） D. x[0]为null

6、 下列语句会造成数组 new int[10] 越界的是 D
A.a[0] +=9； B.a[9]=10； C.–a[9] D.for(int i = 0;i<=10;i++){ a[i]++}

7、 写⼀个函数，计算⼀个整数数组的平均值。

package com.qf.Qu_06;

public class TestQu7 {
	public static void main(String[] args) {
		int n[] = {10,15,20,25};
		System.out.println(arrayAvg(n));
	}
	//写⼀个函数，计算⼀个整数数组的平均值。
	public static  double arrayAvg(int [] n) {
		int sum=0;
		for(int i=0;i<n.length;i++) {
			sum+=n[i];
		}
		return (double)sum/n.length;
	}
}

8、 ⾃定义⼀个整数数组a，读⼊⼀个整数n，如果n在数组中存在，则输出n的下标；如果不存在，输出-1。

package com.qf.Qu_06;

import java.util.Scanner;

public class TestQu8 {

	public static void main(String[] args) {
		/**
		 * ⾃定义⼀个整数数组a，读⼊⼀个整数n，如果n在数组中存在，则输出n的下标； 如果不存在，输出-1。
		 */
		int[] a = { 1, 3, 5, 7, 11, 13 };
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个整数：");
		int n = sc.nextInt();
		for (int i = 0; i < a.length; i++) {
			if (a[i] == n) {
				System.out.println(i);
				return;
			}
		}
		System.out.println("-1");
	}
}

9、 给定⼀个数组，输出数组中的最⼤值和最⼩值。

package com.qf.Qu_06;

public class TestQu9 {
	public static void main(String[] args) {
		/** 9、 给定⼀个数组，输出数组中的最⼤值和最⼩值。 */
		int[] nums = { 1, 3, 4, 5, 8, 7, 9 };
		maxMin(nums);
	}

	// 定义一个求最大值最小值的方法
	public static void maxMin(int[] nums) {
		if (nums == null || nums.length == 0) {
			return;
		}

		int max = nums[0];
		int min = nums[0];
		for (int i = 1; i < nums.length; i++) {
			if (max < nums[i]) {
				max = nums[i];
				continue;
			}
			if (min > nums[i]) {
				min = nums[i];
				continue;
			}
		}
		System.out.println("数组中的最大值是：" + max);
		System.out.println("数组中的最小值是：" + min);
	}

}

10、 给定⼀个数组，把这个数组中所有元素顺序进⾏颠倒。

package com.qf.Qu_06;

public class TestQu10 {
	public static void main(String[] args) {
		/** 10、 给定⼀个数组，把这个数组中所有元素顺序进行颠倒。 */
		int[] nums = { 1, 3, 4, 5, 8, 7, 9 };
		printArray(nums);
		reverse(nums);
		printArray(nums);
	}

	// 定义颠倒数组的方法
	public static void reverse(int[] nums) {
		// i变化范围为数组长度的⼀半
		for (int i = 0; i < nums.length / 2; i++) {
			// 交换a[i]和a[a.length - i - 1]
			int temp = nums[i];
			nums[i] = nums[nums.length - 1 - i];
			nums[nums.length - 1 - i] = temp;
		}
	}

	// 定义打印数组的方法
	public static void printArray(int[] nums) {
		for (int i = 0; i < nums.length; i++) {
			System.out.print(nums[i] + "\t");
		}
		System.out.println();

	}
}

11、 完成数组的冒泡排序算法。
给定⼀个数组：int[] a = {1,3,2,7,5} 利⽤冒泡排序对其按照从⼩到⼤的顺序排序，然后输出结果。

package com.qf.Qu_06;

public class TestQu11 {
	public static void main(String[] args) {
		/**
		 * 11、 完成数组的冒泡排序算法。 给定⼀个数组：int[] a = {1,3,2,7,5} 利⽤冒泡排序对其按照从⼩到⼤的顺序排序，然后输出结果。
		 */
		int[] a = { 1, 3, 2, 7, 5 };
		bubbleMin(a);
		printArray(a);
		bubbleMax(a);
		printArray(a);

	}

	// 定义一个冒泡排序从小到大
	public static void bubbleMin(int[] a) {
		for (int i = 0; i < a.length - 1; i++) {
			for (int j = 0; j < a.length - 1 - i; j++) {
				if (a[i] > a[i + 1]) {
					int temp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = temp;
				}
			}
		}
	}

	// 定义一个冒泡排序从大到小
	public static void bubbleMax(int[] a) {
		for (int i = 0; i < a.length - 1; i++) {
			for (int j = 0; j < a.length - 1 - i; j++) {
				if (a[j] < a[j + 1]) {
					int temp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = temp;
				}
			}
		}
	}

	public static void printArray(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + "\t");
		}
		System.out.println();
	}
}