Java入门学习笔记（五）

数组

数组是相同类型数据的有序集合
两种声明类型：

dataType[] arrayRefVar;
//or
dataType arrayRefVar[];//模仿c++方法

数组元素都是固定的，创建后不能改变。

Java内存分析

堆：存放new的对象和数组，可以被所有线程共享，不会存放别的对象引用。
栈：存放基本变量类型（会包含这个类型的具体数值），引用对象的变量（会存放这个应用在堆里面的具体地址），声明数组时存在这里
方法区：可以被所有线程共享，包含了所有class和static变量

三种初始化方式

静态初始化

```java
int[] nums = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2}

**动态初始化**
```java
int[] nums2 = new int[10];

数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也被按照实例变量相同的方式被隐式初始化。

数组基本特点

• 元素必须是相同类型
• 数组中的元素可以是任意数据类型，包括基本类型和引用类型。例如int[], Man[]。
• 数组变量属于引用类型，数组也可以看成是对象，其中每个元素相当于该对象的成员变量。

多维数组

多维数组可以看成是数组的数组

int[][] nums = new int[2][5];

Arrays类

冒泡排序

import java.util.Arrays;

public class Demo1 {
    public static void main(String[] args) {
        int[] nums = {1,5,8,2,4,10,22,15};
        int[] sort = bubble(nums);

        System.out.println(Arrays.toString(sort));

    }
    public static int[] bubble(int[] nums){
        int temp = 0;
        boolean flag = false; //优化 不需要排序的情况

        for(int i = 0; i<nums.length-1;i++){
            for(int j = 0; j<nums.length-1-i;j++){
                if(nums[j+1]<nums[j]){
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                    flag = true;
                }
            if(flag=false){
                break;
            }
            }
        }
        return nums;
    }
}

稀疏数组

稀疏数组保存为行、列、值

public class Demo2 {
    public static void main(String[] args) {
        int[][] a = new int[11][11];
        a[3][5] = 5;
        a[7][9] = 10;

        //输出原始数组
        for (int i = 0; i < a[0].length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                System.out.print(a[i][j] + "\t");
            }
            System.out.println();
        }

        //转换为稀疏数组，获取有效值个数
        int sum = 0;
        for (int i = 0; i < a[0].length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                if (a[i][j] != 0) {
                    sum++;
                }
            }
        }

        //稀疏数组
        int[][] compress = new int[sum + 1][3];
        //总的行列有效值个数
        compress[0][0] = a[0].length;
        compress[0][1] = a[0].length;
        compress[0][2] = sum;

        //行，列，值
        int count = 0;
        for (int m = 0; m < a[0].length; m++) {
            for (int n = 0; n < a[0].length; n++) {
                if (a[m][n] != 0) {
                    count++;
                    compress[count][0] = m;
                    compress[count][1] = n;
                    compress[count][2] = a[m][n];
                }
            }
        }

        //打印稀疏数组
        for (int m = 0; m < compress[0].length; m++) {
            for (int n = 0; n < 3; n++) {
                System.out.print(compress[m][n] + " ");
            }
            System.out.println();
        }

        //还原
        int[][] original = new int[compress[0][0]][compress[0][1]];
        for(int i=1;i<compress.length;i++){
            original[compress[i][0]][compress[i][1]] = compress[i][2];
        }

        for (int i = 0; i < a[0].length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                System.out.print(original[i][j] + "\t");
            }
            System.out.println();
        }
    }
}