Java从零开始学习——Java数组
2021-01-06 15:31
标签：变量 部分 java数组 数据 最小 初始化 i++ style system 相同类型数据的有序集合 每个数组元素可以通过下标来访问它们(0~length-1) 数组的长度是确定的，一旦被创建，它的大小就不可改变 数组属于引用类型，也可以看成对象，每个数组元素相当于改对象的成员变量 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的 时间复杂度为O(n2) 当一个数组中大部分元素的值为0，或者为同一值时，可以用稀疏数组来保存该数组 稀疏数组的处理方式：记录数组有几行几列，有多少个不同值，将其记录在一个小规模的数组中，从而缩小规模 应用例子：五子棋程序中，存盘、续盘时，保存和读取。 Java从零开始学习——Java数组 标签：变量 部分 java数组 数据 最小 初始化 i++ style system 原文地址：https://www.cnblogs.com/kevinsblog/p/12975562.html数组
一、概述
二、声明与创建
1 //首选声明方式
2 dateType[] arrayRefVar = new dateType[arraySize];
3 //次选
4 dateType arrayRefVar[];
5 //下标从0开始访问，获取长度
6 arrayRefVar.length;
1、初始化
1 //静态初始化
2 int[] array1 = {1,2,3,4};
3 //动态初始化(包含默认初始化，值都是0)
4 int[] array2 = new int[10];
2、内存分析
1 //声明数组，在栈里压入一个array,堆里还是空的
2 int[] array = null;
3 //创建数组，在堆里开辟了一个内存
4 array = new int[10];
三、数组的使用
1 int[] arrays = new int[10];
2 //打印数组元素，以下方式只适用于遍历每个元素，但不能操作
3 for(int array : arrays)
4 {
5 System.out.println(array);
6 }
7 ?
8 //反转数组1
9 int[] arrays2 = new int[arrays.length];
10 for(int i = 0,int j = arrays.length - 1; i )
11 {
12 arrays2[i] = arrays[j];
13 }
14 ?
15 //反转数组2
16 for(int i = arrays.length - 1; i >= 0; i--)
17 {
18 arrays2[(arr.length-1)-i] = arr[i];
19 }
四、多维数组
1 int[][] array = {{1,1}，{2,2}};
2 int[][] array = new int[2][2];
3 ?
4 for(int i = 0; i )
5 {
6 for(int j = 0; j )
7 {
8 System.out.print(array[i][j] + " ");
9 }
10 System.out.println();
11 }
五、Arrays类
1 java.util.Arrays
2 //打印数组元素
3 System.out.println(Array.toString(arr));
4 //排序(升序)
5 Arrays.sort(arr);
6 //给数组赋值(填充)
7 Arrays.fill(a,0)
8 //给一定范围内的元素赋值
9 Arrays.fill(a,2,4,0)
冒泡排序
1 //每次比较都会出现一个最大或者最小的元素，下次循环就少一次比较
2 //外层循环为比较次数
3 for(int i = 0; i )
4 {
5 int tem = 0;
6 //优化，如果已经为有序序列，则不再循环
7 boolean flag = false;
8 //内存循环为两两比较,如果第一个数比第二个数大，就交换其位置
9 for(int j = 0; j )
10 {
11 if(array[j+1] array[j])
12 {
13 tem = array[j+1];
14 array[j+1] = array[j];
15 array[j] = tem;
16 flag = ture；
17 }
18 }
19 if(flag == false)
20 {
21 break;
22 }
23
24 }
六、稀疏数组
1 int[][] array = new int[11][11];
2 array[1][2] = 1;
3 array[2][3] = 2;
4 ?
5 //遍历得到有效的值的个数
6 int sum = 0;
7 for(int i = 0; i )
8 {
9 for(int j = 0; j )
10 {
11 if(array[i][j] != 0)
12 {
13 sum++;
14 }
15 }
16 }
17 int
18 //创建稀疏数组(二维)，行数为有效数个数+1，列数为3
19 int[][] array2 = new int[sum+1][3];
20 //第一列分别是原数组行数、列数、有效数个数
21 array2[0][0] = 11;
22 array2[0][1] = 11;
23 array2[0][2] = sum;
24 ?
25 int count = 0;
26 for(int i = 0; i )
27 {
28 for(int j = 0; j )
29 {
30 if(array[i][j] != 0)
31 {
32 count++;
33 array2[count][0] = i;
34 array2[count][1] = j;
35 array2[count][2] = array[i][j];
36 }
37 }
38 }
39 ?
40 //还原,数组行列数为稀疏数组第一行的前两个数值
41 int[][] array3 = new int[array2[0][0]][array2[0][1]];
42 //从第二行开始，还原有效数值
43 for(int i = 1; i )
44 {
45 array3[array2[i][0]][array2[i][1]] = array2[i][2];
46 }
上一篇：JAVA Integer类型自加
下一篇：C++中的类型转换
文章标题：Java从零开始学习——Java数组
文章链接：http://soscw.com/index.php/essay/40512.html