4.数组_数组 [4][1]-CSDN博客

本文链接：https://blog.csdn.net/TonyMor/article/details/78270193

1.定义

数组是一种容器，用于存储同一类型的数据

2.一维数组格式

//格式1
元素类型[] 数组名  = new 元素类型[元素个数或数组长度];
例： int[] arr = new int [1024];
//格式2
元素类型[] 数组名  = new 元素类型[]{元素,元素,...};
例： int[] arr = new int[]{1,2,3,4};
   int[] arr = {1,2,3,4};

3.常见异常

public class ArrayDemo {
	public static void mian(String[] args) {
		int[] arr = new int[3];

		System.out.println(arr[3]);// 数组越界ArrayIndexOutOfBoundsException
									// 访问的数组角标不存在，发生该异常
		arr = null;
		System.out.println(arr[0]);// 空指针异常NullPointerException
									// 引用型变量没有实体指向，仍用其操作实体，发生该异常
	}
}

4.常见操作

a.遍历

int[] arr={1,34,54,8,9};
for(int x=0;x<arr.length;x++){
	System.out.println(arr[x]);
}

b.最值(最大值、最小值)

public class ArrayDemo {
	public static void main(String[] args) {
		int[] arr = { 1, 34, 54, 8, 9 };

		getMin(arr);
		getMax(arr);
	}

	private static void getMax(int[] arr) {
		int max = arr[0];
		for (int i = 0; i < arr.length; i++) {
			if (max < arr[i])
				max = arr[i];
		}
		System.out.println(max);
	}

	private static void getMin(int[] arr) {
		int min = arr[0];
		for (int i = 0; i < arr.length; i++) {
			if (min > arr[i])
				min = arr[i];
		}
		System.out.println(min);
	}
}

c.排序(选择排序、冒泡排序)

选择排序

图解：

public class SelectSortDemo {

	public static void main(String[] args) {
		int[] arr = { 55, 13, 8, 29, 104 };
		selectSort(arr);
		for (int x = 0; x < arr.length; x++) {
			System.out.print(arr[x] + " ");
		}
	}

	private static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[i] > arr[j]) {
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}

	}

}

冒泡排序

图解：

public class BubbleSortDemo {

	public static void main(String[] args) {
		int[] arr = { 55, 13, 8, 29, 104 };
		bubbleSort(arr);
		for (int x = 0; x < arr.length; x++) {
			System.out.print(arr[x] + " ");
		}
	}

	private static void bubbleSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
	}

}

d.查找

public class SearchDemo {
	public static void main(String[] args) {
		int[] arr={4,1,5,7,3,8,2};
		int index=getIndex(arr,0);
		System.out.println("index="+index);
	}

	private static int getIndex(int[] arr, int key) {// 查找
		for(int x=0;x<arr.length;x++){
			if(arr[x]==key)
				return x;
		}
		return -1;
	}
}

折半查找

前提：数组是有序的

public class BinarySearchDemo {

	public static void main(String[] args) {
		int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
		int index = binarySearch(arr, 6);
		System.out.println("index=" + index);
	}

	private static int binarySearch(int[] arr, int key) {
		int max, min, mid;
		min = 0;
		max = arr.length - 1;
		mid = (max + min) / 2;

		while (arr[mid] != key) {
			if (key > arr[mid])
				min = mid + 1;
			else if (key < arr[mid])
				max = mid - 1;
			if (max < min)
				return -1;
			mid = (max + min) / 2;
		}
		return mid;
	}

}

5.二维数组

		// 格式1
		int[][] arr = new int[3][2];
		/*
		 * 解释： 定义了名称为arr的二维数组
		 *     二维数组中有3个一维数组 每个一维数组中有2个元素
		 *     一维数组的名称分别是arr[0],arr[1],arr[2] 
		 *     给第一个一维数组1交表赋值为78写法是：arr[0][1]=78;
		 */
		System.out.println(arr);//打印二维数组                 [[I@15db9742
		System.out.println(arr[0]);//打印一维数组              [I@6d06d69c
		System.out.println(arr[0][0]);//打印一维数组中的元素   0

//		// 格式2：
		int[][] arr = new int[3][];
		/*
		 * 解释： 二维数组中有3个一维数组 
		 *     每个一维数组都是默认初始化值null 
		 *     每个一维数组长度不固定
		 *     可以对这三个一维数组分别进行初始化
		 *     arr[0] = new int[3];
		 *     arr[1] = new int[1];
		 *     arr[2] = new int[2];
		 */
		System.out.println(arr);//打印二维数组                      [[I@15db9742
		System.out.println(arr[0]);//打印一维数组                   null
		System.out.println(arr[0][0]);//打印一维数组中的元素 不存在 NullPointerException

6.数组的应用

进制转换----查表法

什么时候使用数组？

当数据出现了对应关系，而且对应关系的一方是有序的数字编号，并作为角标使用时

可将这些数据存储到数组中，根据运算结果作为角标去查数组中对应的元素

public class ArrayDemo {
	public static void main(String[] args) {
		toBinary(15);
		toOctal(15);
		toHex(15);
	}

	// 十进制-->十六进制
	public static void toHex(int num) {
		trans(num, 15, 4);
	}

	public static void toBinary(int num) {
		trans(num, 1, 1);
	}

	public static void toOctal(int num) {
		trans(num, 7, 3);
	}

	public static void trans(int num, int base, int offset) {
		if (num == 0) {
			System.out.println("0");

		}

		char[] chs = { // 定义一个对应关系表
				'0', '1', '2', '3', 
				'4', '5', '6', '7', 
				'8', '9', 'A', 'B',
				'C', 'D', 'E', 'F' };

		char[] arr = new char[32];
		int pos = arr.length;

		while (num != 0) {
			int temp = num & base;
			arr[--pos] = chs[temp];
			num = num >>> offset;
		}

		for (int x = pos; x < arr.length; x++) {
			System.out.print(arr[x]);
		}
		System.out.println();
	}

}