Java编程基础——数组和二维数组

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 int nums[][];
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 void test() {
 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 void test() {
 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 < r){
14         while(arr[l] < pivot) l++;
15         while(arr[r] > 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 < r) sort(left, r, arr);
28     if(right > l) sort(l, right, arr);
29 }

直接选择排序

思路

属于选择排序。

每次都选取最小值放在起始位上,一共通过n-1次。

代码

 1 public void test() {
 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 }

转载于:https://www.cnblogs.com/shamao/p/10109777.html

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值