Java编程基础——数组和二维数组
摘要:本文主要对数组和二维数组进行简要介绍。
数组
定义
数组可以理解成保存一组数的容器,而变量可以理解为保存一个数的容器。
数组是一种引用类型,用于保存一组相同类型的数据。
数组定义的类型可以为任意类型,意思是我们可以定义int类型的数组,也可以定义String类型的数组,或其他任何类型的数组。
数组实际在内存的存储和基本类型不同,实际上是在堆中申请空间保存一组数,栈中只是有一个地址的引用。
声明数组
语法:
1 类型[] 数组名;2 类型 数组名[];
举例:
1 int[] sum;2 int color[];
说明:
此时只是声明了一个数组变量,并没有在内存中开辟空间。
开辟空间
语法:
1 数组名 = new 类型[长度];
举例:
1 sum = new int[5];
说明:
数组开辟空间时,必须要设置开辟的空间长度。
这时会根据类型对数组里的数据设置默认值。
数组赋值
语法:
1 数组名[下标] = 值;
举例:
1 sum[0] = 10;
说明:
在对数组进行赋值时,注意下标不要超过数组的长度范围,否则会产生错误。
使用数组
语法:
1 数组名[下标]
举例:
1 System.out.println(sum[0]);
说明:
同样需要注意下标不要超过数组的长度范围。
其他赋值方式
除了上面通过下标赋值,还可以在声明时开辟空间并赋值,或者在开辟空间时赋值。
语法:
1 数组名 = new类型[]{值, 值};2 类型[] 数组名 = {值, 值};
举例:
1 int[] sum = {1, 2};2 sum = new int[]{1, 2, 3};
说明:
这两种方式都需要在确定数组大小和值的内容的时候使用。
在开辟空间时赋值,不需要在中括号里面填写数组长度。
注意
数组不赋值也有默认值。
数组中每个元素的赋值和访问都是通过“数组名[下标]”实现的,不能直接使用数组名。
“数组名.length”代表的是数组的长度,经常用在循环中,提高代码的维护性。
数组的下标从 0 ~ 数组名.length - 1 ,如果不是这个范围,会导致一个数组下标越界的异常:ArrayIndexOutOfBoundsException。
数组没有开辟空间,直接使用,会导致一个空指针异常:NullPointerException。
进阶使用
数组的复制
◆ 引用类型的赋值:复制的是一个地址号,二者共同引用一个地址,其中一个对数组做了更改,都会影响另一个。
◆ 基本类型的赋值:复制的是数值内容,实际上是一个备份,其中一个对它更改,不会影响另一个。
复制引用地址:
复制的是一个地址号,二者共同引用一个地址,其中一个对数组做了更改,都会影响另一个。
1 int[] a1 = {1, 2, 3};2 int[] a2;3 a2 =a1;4 System.out.println(a2[0]);5 a1[0] = 100;6 System.out.println(a2[0]);
结果:
1 1
2 100
复制数组数据:
1 int[] a1={1, 7, 8};2 int[] a2 = new int[a1.length];3 for (int i = 0; i < a1.length; i++) {4 a2[i] =a1[i];5 }6 System.out.println(a2[0]);7 a2[1]=100;8 System.out.println(a2[0]);
结果:
1 1
2 1
数组的排序
1 int[] nums = {1, 9, 3, 5, 2, 8, 4};2 for(int i = 0; i < nums.length - 1; i++) {//控制轮数
3 for(int j = 0; j < nums.length - 1 - i; j++) {4 if (nums[j] < nums[j + 1]) {//交换
5 int temp =nums[j];6 nums[j] = nums[j + 1];7 nums[j + 1] =temp;8 }9 }10 }
数组的倒置
1 int[] nums = {1, 9, 3, 5, 2, 8, 4};2 for(int i = 0; i < nums.length / 2; i++) {3 int temp =nums[i];4 nums[i] = nums[nums.length - 1 -i];5 nums[nums.length - 1 - i] =temp;6 }
工具类
排序: Arrays.sort(nums);
填充: Arrays.fill(nums, 1);
转成字符串以便打印: Arrays.toString(nums);
比较: Arrays.equals(a1, a2);
二维数组
定义
二维数组可以看做是一个数组,里面存放的元素是一维数组。
声明数组
1 int[][] nums;2 intnums[][];3 int[] nums[];
开辟空间
1 nums = new int[3][];//行固定,列不固定。
2 nums = new int[3][2];//行固定,列固定。
数组赋值
动态初始化,使用时赋值,需要指明行和列:
1 nums[0][1] = 1;
静态初始化,声明时赋值,不必也不能指明行和列,否则会提示错误:
1 int[][] nums = new int[][]{{1}, {9, 3, 5, 2}, {7, 6}};2 int[][] nums = {{1}, {9, 3, 5, 2}, {7, 6}};
注意
如果在动态初始化时明确了二维数组的行数和列数,那么一维数组的长度就是固定的列数。
如果在动态初始化时仅仅明确了行数,或者通过静态初始化赋值,那么一维数组可以有不同的长度。
数组排序
冒泡排序
思路
属于交换排序。
从第一个元素开始,比较两个相邻的元素,如果两个元素位置不正确,则进行交换,否则继续比较下面相邻的两个元素。
代码
1 public voidtest() {2 int[] arr = new int[]{1, 7, 3, 8, 5};3 int len =arr.length;4 for (int i = 0; i < len - 1; i++) {5 for (int j = 0; j < len - i - 1; j++) {6 if (arr[j] > arr[j + 1]) {7 int temp =arr[j];8 arr[j] = arr[j + 1];9 arr[j + 1] =temp;10 }11 }12 }13 for (int i = 0; i < arr.length; i++) {14 System.out.println(arr[i]);15 }16 }
快速排序
思路
属于交换排序。
任取序列的某个元素作为界点,将序列分为两个子序列,左子序列的元素小于界点,右子序列的元素大于界点,然后递归每个子序列,直到每个子序列只有一个元素。
代码
1 public voidtest() {2 int[] arr = new int[]{8, 3, 11, 4, 9, 5, 1};3 sort(0, arr.length - 1, arr);4 for (int i = 0; i < arr.length; i++) {5 System.out.println(arr[i]);6 }7 }8 public void sort(int left, int right, int[] arr){9 int l =left;10 int r =right;11 int pivot = arr[(left + right)/2];//找中间值
12 int temp = 0;13 while(l pivot) r--;16 if(l >= r) break;17 temp =arr[l];18 arr[l] =arr[r];19 arr[r] =temp;20 if(arr[l] == pivot) --r;21 if(arr[r] == pivot) ++l;22 }23 if(l ==r){24 l++;25 r--;26 }27 if(left l) sort(l, right, arr);29 }
直接选择排序
思路
属于选择排序。
每次都选取最小值放在起始位上,一共通过n-1次。
代码
1 public voidtest() {2 int[] arr = new int[]{3, 2, 6, 10, 1, 9, 8};3 for (int i = 0; i < arr.length - 1; i++) {4 int index =i;5 for (int j = i + 1; j < arr.length; j++) {6 if (arr[index] >arr[j]) {7 index =j;8 }9 }10 int temp =arr[i];11 arr[i] =arr[index];12 arr[index] =temp;13 }14 for (int i = 0; i < arr.length; i++) {15 System.out.println(arr[i]);16 }17 }