数组

图片说明

数组声明创建

图片说明

代码见真知😎

图片说明

三种创建数组的方法

三种初始化

默认初始化

去代码里看看😀

**浅

**

深

Java内存分析:

Java内存: 堆 栈 方法区

堆

存放new的对象和数组

可以被所有的线程共享,不会存放别的对象引用

栈

存放基本变量类型(会包含这个基本类型的具体数值)

引用对象的变量(会存放这个引用在堆里面的具体地址)

图解

图片说明

方法区

可以被所有的线程共享

包含了所有的class和 static变量

数组的四个特点

下标越界? 啥东东

运行结果

小结:

数组的使用

1.普通for循环

2.增强for循环

3.数组作方法入参

4.数组作返回值

解释:int[] ReverseArrays = new int[arrays.length];

图片说明

多维数组

Arrays类

图片说明

老规矩看代码

图片说明

冒泡排序(面试喜欢)

看代码

优化


运行结果


稀疏数组

图片说明
图片说明

代码见真知 

package com.vis_yang.arrays;
public class ChessArrays {
    public static void main(String[] args) {
        //创建一个二维数组 11*11  0:没有棋子  1:黑棋  2:白棋
        int[][] arrays1 = new int[11][11];  //行前列后
        arrays1[1][2] = 1;
        arrays1[2][3] = 2;
        //输出原始的数组
        for (int[] array : arrays1) {
            for (int arr : array) {
                System.out.print(arr + " ");
            }
            System.out.println();
        }
        System.out.println("以上是原始的数组");
        //压缩成稀疏数组
        //1.遍历二维数组获取有效值的个数
        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 += 1;
                }
            }
        }
        System.out.println("有效值个数是" + sum + "个");
        //2.创建一个稀疏数组的数组   稀疏数组列数是固定的3列,下标也是从0开始  行数随有效个数累计(存储)
        int[][] arrays2 = new int[sum + 1][3];  //行前列后   1是头行,每增加一个有效数字就加一行
        //以下实际是在赋值稀疏数组的头行 存储原始数组的行列数以及有效数字个数
        arrays2[0][0] = 11;//存储原始数组行数
        arrays2[0][1] = 11;//存储原始数组列数
        arrays2[0][2] = 2;//存储原始数组有效值个数
        //3.遍历原始二维数组,将非0的值,存放在稀疏数组中
        int count = 0;    //实际这里也是在计算有效个数来确定要存的行数
        for (int i = 0; i < arrays1.length; i++) {   //控制遍历原始数组的行数
            for (int j = 0; j < arrays1[i].length; j++) {  //控制遍历原始数组的列数
                if (arrays1[i][j] != 0) {
                    count++;
                    //以下实际是在赋值稀疏数组的下半身   存储有效数字在原始数组中的位置
                    arrays2[count][0] = i;  //存原始数组有效数字的行位置
                    arrays2[count][1] = j;  //存原始数组有效数字的列位置
                    arrays2[count][2] = arrays1[i][j];    //存原始数组的有效数字的值
                }
            }
        }
        //输出稀疏数组
        System.out.println("以下是压缩成的稀疏数组:");
        System.out.println("行" + " " + "列" + " " + "值");
        for (int[] array : arrays2) {
            for (int arr : array) {
                System.out.print(arr + " ");
            }
            System.out.println();
        }
        //还原稀疏数组
        System.out.println("还原稀疏数组");
        //1.重新构造一个新数组用于还原                      //还原长度用稀疏数组的头行数据                        // arrays2[0][0]=11
        int[][] arrays3 = new int[arrays2[0][0]][arrays2[0][1]];   //11*11的空数组              //arrays2[0][1]=11
        //实际已知长度 也可以直接用 new int [11][11]
        //2.遍历稀疏数组的下半身找出存的值存回这个数组中
        for (int i = 1; i < arrays2.length; i++) {  //从1开始,头行不用遍历
            arrays3[arrays2[i][0]][arrays2[i][1]] = arrays2[i][2];  //arrays2[i][2]就是原来稀疏数组存的有效数字的值现在存到空数组arrays3中
        }                                                             //arrays2[i][0] 有效值数字在原来数组中的行
                                                                      //arrays2[i][1] 有效值数字在原来数组中的列
        //遍历打印数组arrays3
        for (int[] array : arrays3) {
            for (int arr : array) {
                System.out.print(arr + " ");
            }
            System.out.println();
        }
    }
}


运行结果

图片说明