Day5-JAVA-数组

发表于 阅读次数： 本文字数： 4.1k 阅读时长 ≈ 4 分钟

JAVA-数组

Day5-JAVA-数组

数组的定义

  • 数组就是相同类型数据的有序集合
  • 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
  • 其中，每一个数据都称作一个数据元素，每个数据元素可以通过一个下表来访问他们

数组使用

声明–>开辟空间–>赋值

1
2
3
4
// 声明
dataType[] arrayName;		// 首选的方法
或
dataType arrayNme[];		// 效果相同
1
2
3
4
// 开辟空间
arrayName = new dataType[arraySize];
或
dataType[] arrayName = new dataType[arraySize];
1
2
// 赋值(通过下标)
arrayName[index] = value;

获取数组大小可以用arrayName.length

==内存分析==

数组声明是放在栈中，而真正创建出的数组放在堆中

image-20230218142303826

初始化

静态初始化：声明+创建+赋值 一条龙

1
int[] array = {1,2,3,4,5};

动态初始化：声明–>创建–>赋值

动态初始化包括默认初始化，值默认是0

1
2
int[] array = new int[10];
array[0] = 1;

多维数组

可以看成数组中的数组，其每个元素都是数组

1
int[][] arrays = {{1,2}, {2,3}};

定义就是在类型后加[]，几维数组就加几个[]

上面是二维数组，同理三位数组就是int[ ] [ ] [ ]

上面的arrays就可以看作两行两列

==多维数组使用==

1
2
int[][] arrays = {{1,2}, {2,3}};
System.out.println(arrays[0][0]);

arrays第一个[0]表示数组中第一个元素，也就是{1,2}，然后第二个[0]表示{1,2}中第一个元素

image-20230218210226351

Arrays类

Arrays.toString

打印数组内容

1
2
3
int[] a = {1,6,845,774,85,4,78,74};
System.out.println(Arrays.toString(a));
// [1, 6, 845, 774, 85, 4, 78, 74]

Arrays.sort

对数组进行排序，升序

1
2
3
4
int[] a = {1,6,845,774,85,4,78,74};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
// [1, 4, 6, 74, 78, 85, 774, 845]

Arrays.fill

数组填充，可以理解为覆盖

1
2
3
4
int[] a = {1,6,845,774,85,4,78,74};
Arrays.fill(a, 666);
System.out.println(Arrays.toString(a));
// [666, 666, 666, 666, 666, 666, 666, 666]
1
2
3
4
int[] a = {1,6,845,774,85,4,78,74};
Arrays.fill(a,2, 4, 666);
System.out.println(Arrays.toString(a));
// [1, 6, 666, 666, 85, 4, 78, 74]

在Arrays.fill(a,2, 4, 666)的语句中的2, 4表示从数组第2位到第四位填充成666

Arrays.equals

进行数组比较

1
2
3
4
int[] a = {1,6};
int[] b = {1,6};
System.out.println(Arrays.equals(a, b));
// true

冒泡排序

进行两次循环，第一次循环是循环的轮数，第二次是内循环

然后进行比较如果前一个数比后一个数大就相互交换位置

从而达到一种排序效果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public static void main(String[] args) {
    int[] nums = {2,56,8855,85,4,8,484};

    int[] up = up(nums);
    System.out.println(Arrays.toString(up));
}
public static int[] up(int[] nums) {
    int dump = 0;
    // 轮数
    for (int i = 0; i < nums.length-1; i++) {
        // 内循环
        boolean flag = false;
        for (int two = 0;two <nums.length-1-i;two++){
            if (nums[two]>nums[two+1]){
                dump = nums[two+1];
                nums[two+1] = nums[two];
                nums[two] = dump;
                flag = true;
            }
        }
        if (flag==false){
            break;
        }
    }
    return nums;
}

关于定义flag = false的原因：

  • 这是一种优化，用来减少循环轮数，从而缩短时间
  • 大概意思就是：这个数组有7个数，假如当循环到4次的时候没有数字变动（说明已经排序好了），其中一轮循环中的内循环结束，nums[two]>nums[two+1]这一条语句就为false，里面的语句就不会执行，flag就不会变成true，也就是false，因为内循环结束，就会执行if(flag==false)退出循环，从而减少了循环轮数

稀疏数组

用于压缩，其主要目的是将关键信息记录下来，然后保存下来，再读取还原表

举例：

表：

0 0 0 22 0 0 15
0 11 0 0 0 17 0
0 0 0 -6 0 0 0
0 0 0 0 0 39 0
91 0 0 0 0 0 0
0 0 28 0 0 0 0

稀疏组：

行 列 值
[0] 6 7 8
[1] 0 3 22
[2] 0 6 15
[3] 1 1 11
[4] 1 5 17
[5] 2 3 -6
[6] 3 5 39
[7] 4 0 91
[8] 5 2 28

第一行，即[0]行：

  • 稀疏组中[0]行是用于存储表的格式，即是一个6行、7列、有8个关键字的表

  • 第一行的8是用于确定稀疏组的行数

第一行以下的，即[1]-[8]行：

  • 行、列用来表示关键字的横纵坐标，就是用来表示这个关键字在二维数组中的哪个地方
  • 值就是这个关键字的值

用代码塑造出这个稀疏数组后，通过读取对应的数字就可以还原表

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
int[][] arrays1 = new int[11][11];
arrays1[1][2] = 1;
arrays1[2][3] = 1;
System.out.println("原始数组：");
for (int[] array : arrays1) {
    for (int i : array) {
        System.out.print(i+"\t");
    }
    System.out.println();
}
System.out.println("=================================");
// 1.有效数,稀疏组行
int cont = 0;
for (int i=0; i < arrays1.length; i++) {
    for (int j=0; j < arrays1[i].length; j++){
        if (arrays1[i][j] !=0){
            cont++;
        }
    }
}

// 2.创建稀疏组
int[][] arrays2 = new int[cont+1][3];
arrays2[0][0] = arrays1.length;
arrays2[0][1] = arrays1.length;
arrays2[0][2] = cont;

// 3.记录关键信息,即表已创好
int sum = 0;
for (int i = 0; i < arrays1.length; i++){
    for (int j = 0; j < arrays1[i].length; j++){
        if (arrays1[i][j] !=0){
            sum++;
            arrays2[sum][0] = i;
            arrays2[sum][1] = j;
            arrays2[sum][2] = arrays1[i][j];

        }
    }
}
System.out.println("稀疏数组：");
for (int[] array : arrays2) {
    for (int i : array) {
        System.out.print(i+"\t");
    }
    System.out.println();
}
System.out.println("=================================");
// 还原
int[][] arrays3 = new int[arrays2[0][0]][arrays2[0][1]];
for (int i = 1; i < arrays2.length; i++){
    arrays3[arrays2[i][0]][arrays2[i][1]] = arrays2[i][2];
}
System.out.println("稀疏组表：");
for (int[] array : arrays3) {
    for (int i : array) {
        System.out.print(i+"\t");
    }
    System.out.println();
}